Last active
August 29, 2015 14:18
-
-
Save rodneyrehm/03debd117ffaf42b2209 to your computer and use it in GitHub Desktop.
Emscripten async experiment
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| CC ?= gcc | |
| CXX ?= g++ | |
| CFLAGS ?= -Wall -O2 -fPIC -stdlib=libc++ | |
| CXXFLAGS ?= -Wall -O2 -fPIC -stdlib=libc++ | |
| LDFLAGS ?= -Wall -O2 -fPIC -stdlib=libc++ -Wl,--no-undefined | |
| SOURCES = \ | |
| test.cpp | |
| CSOURCES = | |
| OBJECTS = $(SOURCES:.cpp=.o) | |
| COBJECTS = $(CSOURCES:.c=.o) | |
| static: asyncified.a | |
| asyncified.a: $(COBJECTS) $(OBJECTS) | |
| $(AR) rcvs $@ $(COBJECTS) $(OBJECTS) | |
| js-debug: static | |
| emcc asyncified.a -o asyncified.js \ | |
| -O0 \ | |
| -s EXPORTED_FUNCTIONS="['_asyncified_method']" \ | |
| -s DISABLE_EXCEPTION_CATCHING=0 \ | |
| -s ALLOW_MEMORY_GROWTH=1 \ | |
| -s EMTERPRETIFY=1 \ | |
| -s EMTERPRETIFY_ASYNC=1 \ | |
| -s EMTERPRETIFY_WHITELIST=@whitelist.json \ | |
| -s ASSERTIONS=1 \ | |
| -s SAFE_HEAP=1 \ | |
| -s DEMANGLE_SUPPORT=1 \ | |
| --profiling-funcs \ | |
| --minify 0 \ | |
| --memory-init-file 1 | |
| %.o: %.c | |
| $(CC) $(CFLAGS) -c -o $@ $< | |
| %.o: %.cpp | |
| $(CXX) $(CXXFLAGS) -c -o $@ $< | |
| %: %.o static | |
| $(CXX) $(CXXFLAGS) -o $@ $+ $(LDFLAGS) $(LDLIBS) |
This file has been truncated, but you can view the full file.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // The Module object: Our interface to the outside world. We import | |
| // and export values on it, and do the work to get that through | |
| // closure compiler if necessary. There are various ways Module can be used: | |
| // 1. Not defined. We create it here | |
| // 2. A function parameter, function(Module) { ..generated code.. } | |
| // 3. pre-run appended it, var Module = {}; ..generated code.. | |
| // 4. External script tag defines var Module. | |
| // We need to do an eval in order to handle the closure compiler | |
| // case, where this code here is minified but Module was defined | |
| // elsewhere (e.g. case 4 above). We also need to check if Module | |
| // already exists (e.g. case 3 above). | |
| // Note that if you want to run closure, and also to use Module | |
| // after the generated code, you will need to define var Module = {}; | |
| // before the code. Then that object will be used in the code, and you | |
| // can continue to use Module afterwards as well. | |
| var Module; | |
| if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {}; | |
| // Sometimes an existing Module object exists with properties | |
| // meant to overwrite the default module functionality. Here | |
| // we collect those properties and reapply _after_ we configure | |
| // the current environment's defaults to avoid having to be so | |
| // defensive during initialization. | |
| var moduleOverrides = {}; | |
| for (var key in Module) { | |
| if (Module.hasOwnProperty(key)) { | |
| moduleOverrides[key] = Module[key]; | |
| } | |
| } | |
| // The environment setup code below is customized to use Module. | |
| // *** Environment setup code *** | |
| var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function'; | |
| 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 | |
| if (!Module['print']) Module['print'] = function print(x) { | |
| process['stdout'].write(x + '\n'); | |
| }; | |
| if (!Module['printErr']) Module['printErr'] = function printErr(x) { | |
| process['stderr'].write(x + '\n'); | |
| }; | |
| var nodeFS = require('fs'); | |
| var nodePath = require('path'); | |
| Module['read'] = function read(filename, binary) { | |
| filename = nodePath['normalize'](filename); | |
| var ret = nodeFS['readFileSync'](filename); | |
| // 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); | |
| } | |
| if (ret && !binary) ret = ret.toString(); | |
| return ret; | |
| }; | |
| Module['readBinary'] = function readBinary(filename) { return Module['read'](filename, true) }; | |
| Module['load'] = function load(f) { | |
| globalEval(read(f)); | |
| }; | |
| if (!Module['thisProgram']) { | |
| if (process['argv'].length > 1) { | |
| Module['thisProgram'] = process['argv'][1].replace(/\\/g, '/'); | |
| } else { | |
| Module['thisProgram'] = 'unknown-program'; | |
| } | |
| } | |
| Module['arguments'] = process['argv'].slice(2); | |
| if (typeof module !== 'undefined') { | |
| module['exports'] = Module; | |
| } | |
| process['on']('uncaughtException', function(ex) { | |
| // suppress ExitStatus exceptions from showing an error | |
| if (!(ex instanceof ExitStatus)) { | |
| throw ex; | |
| } | |
| }); | |
| } | |
| else if (ENVIRONMENT_IS_SHELL) { | |
| if (!Module['print']) Module['print'] = print; | |
| if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm | |
| if (typeof read != 'undefined') { | |
| Module['read'] = read; | |
| } else { | |
| Module['read'] = function read() { throw 'no read() available (jsc?)' }; | |
| } | |
| Module['readBinary'] = function readBinary(f) { | |
| if (typeof readbuffer === 'function') { | |
| return new Uint8Array(readbuffer(f)); | |
| } | |
| var data = read(f, 'binary'); | |
| assert(typeof data === 'object'); | |
| return data; | |
| }; | |
| if (typeof scriptArgs != 'undefined') { | |
| Module['arguments'] = scriptArgs; | |
| } else if (typeof arguments != 'undefined') { | |
| Module['arguments'] = arguments; | |
| } | |
| } | |
| else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { | |
| Module['read'] = function read(url) { | |
| var xhr = new XMLHttpRequest(); | |
| xhr.open('GET', url, false); | |
| xhr.send(null); | |
| return xhr.responseText; | |
| }; | |
| if (typeof arguments != 'undefined') { | |
| Module['arguments'] = arguments; | |
| } | |
| if (typeof console !== 'undefined') { | |
| if (!Module['print']) Module['print'] = function print(x) { | |
| console.log(x); | |
| }; | |
| if (!Module['printErr']) Module['printErr'] = function printErr(x) { | |
| console.log(x); | |
| }; | |
| } else { | |
| // Probably a worker, and without console.log. 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 | |
| })); | |
| } | |
| if (ENVIRONMENT_IS_WORKER) { | |
| Module['load'] = importScripts; | |
| } | |
| if (typeof Module['setWindowTitle'] === 'undefined') { | |
| Module['setWindowTitle'] = function(title) { document.title = title }; | |
| } | |
| } | |
| else { | |
| // 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'] && Module['read']) { | |
| Module['load'] = function load(f) { | |
| globalEval(Module['read'](f)); | |
| }; | |
| } | |
| if (!Module['print']) { | |
| Module['print'] = function(){}; | |
| } | |
| if (!Module['printErr']) { | |
| Module['printErr'] = Module['print']; | |
| } | |
| if (!Module['arguments']) { | |
| Module['arguments'] = []; | |
| } | |
| if (!Module['thisProgram']) { | |
| Module['thisProgram'] = './this.program'; | |
| } | |
| // *** Environment setup code *** | |
| // Closure helpers | |
| Module.print = Module['print']; | |
| Module.printErr = Module['printErr']; | |
| // Callbacks | |
| Module['preRun'] = []; | |
| Module['postRun'] = []; | |
| // Merge back in the overrides | |
| for (var key in moduleOverrides) { | |
| if (moduleOverrides.hasOwnProperty(key)) { | |
| Module[key] = moduleOverrides[key]; | |
| } | |
| } | |
| // === Preamble library stuff === | |
| // Documentation for the public APIs defined in this file must be updated in: | |
| // site/source/docs/api_reference/preamble.js.rst | |
| // A prebuilt local version of the documentation is available at: | |
| // site/build/text/docs/api_reference/preamble.js.txt | |
| // You can also build docs locally as HTML or other formats in site/ | |
| // An online HTML version (which may be of a different version of Emscripten) | |
| // is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html | |
| //======================================== | |
| // Runtime code shared with compiler | |
| //======================================== | |
| var Runtime = { | |
| setTempRet0: function (value) { | |
| tempRet0 = value; | |
| }, | |
| getTempRet0: function () { | |
| return tempRet0; | |
| }, | |
| stackSave: function () { | |
| return STACKTOP; | |
| }, | |
| stackRestore: function (stackTop) { | |
| STACKTOP = stackTop; | |
| }, | |
| getNativeTypeSize: function (type) { | |
| switch (type) { | |
| case 'i1': case 'i8': return 1; | |
| case 'i16': return 2; | |
| case 'i32': return 4; | |
| case 'i64': return 8; | |
| case 'float': return 4; | |
| case 'double': return 8; | |
| default: { | |
| if (type[type.length-1] === '*') { | |
| return Runtime.QUANTUM_SIZE; // A pointer | |
| } else if (type[0] === 'i') { | |
| var bits = parseInt(type.substr(1)); | |
| assert(bits % 8 === 0); | |
| return bits/8; | |
| } else { | |
| return 0; | |
| } | |
| } | |
| } | |
| }, | |
| getNativeFieldSize: function (type) { | |
| return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE); | |
| }, | |
| STACK_ALIGN: 16, | |
| prepVararg: function (ptr, type) { | |
| if (type === 'double' || type === 'i64') { | |
| // move so the load is aligned | |
| if (ptr & 7) { | |
| assert((ptr & 7) === 4); | |
| ptr += 4; | |
| } | |
| } else { | |
| assert((ptr & 3) === 0); | |
| } | |
| return ptr; | |
| }, | |
| getAlignSize: function (type, size, vararg) { | |
| // we align i64s and doubles on 64-bit boundaries, unlike x86 | |
| if (!vararg && (type == 'i64' || type == 'double')) return 8; | |
| if (!type) return Math.min(size, 8); // align structures internally to 64 bits | |
| return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE); | |
| }, | |
| dynCall: function (sig, ptr, args) { | |
| if (args && args.length) { | |
| assert(args.length == sig.length-1); | |
| if (!args.splice) args = Array.prototype.slice.call(args); | |
| args.splice(0, 0, ptr); | |
| assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\''); | |
| return Module['dynCall_' + sig].apply(null, args); | |
| } else { | |
| assert(sig.length == 1); | |
| assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\''); | |
| return Module['dynCall_' + sig].call(null, ptr); | |
| } | |
| }, | |
| functionPointers: [], | |
| addFunction: function (func) { | |
| for (var i = 0; i < Runtime.functionPointers.length; i++) { | |
| if (!Runtime.functionPointers[i]) { | |
| Runtime.functionPointers[i] = func; | |
| return 2*(1 + i); | |
| } | |
| } | |
| throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.'; | |
| }, | |
| removeFunction: function (index) { | |
| Runtime.functionPointers[(index-2)/2] = null; | |
| }, | |
| asmConsts: [], | |
| 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, sig) { | |
| assert(sig); | |
| if (!Runtime.funcWrappers[sig]) { | |
| Runtime.funcWrappers[sig] = {}; | |
| } | |
| var sigCache = Runtime.funcWrappers[sig]; | |
| if (!sigCache[func]) { | |
| sigCache[func] = function dynCall_wrapper() { | |
| return Runtime.dynCall(sig, func, arguments); | |
| }; | |
| } | |
| return sigCache[func]; | |
| }, | |
| getCompilerSetting: function (name) { | |
| throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work'; | |
| }, | |
| stackAlloc: function (size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = (((STACKTOP)+15)&-16);(assert((((STACKTOP|0) < (STACK_MAX|0))|0))|0); return ret; }, | |
| staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + (assert(!staticSealed),size))|0;STATICTOP = (((STATICTOP)+15)&-16); return ret; }, | |
| dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + (assert(DYNAMICTOP > 0),size))|0;DYNAMICTOP = (((DYNAMICTOP)+15)&-16); if (DYNAMICTOP >= TOTAL_MEMORY) { var success = enlargeMemory(); if (!success) return 0; }; return ret; }, | |
| alignMemory: function (size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 16))*(quantum ? quantum : 16); return ret; }, | |
| makeBigInt: function (low,high,unsigned) { var ret = (unsigned ? ((+((low>>>0)))+((+((high>>>0)))*(+4294967296))) : ((+((low>>>0)))+((+((high|0)))*(+4294967296)))); return ret; }, | |
| GLOBAL_BASE: 2048, | |
| QUANTUM_SIZE: 4, | |
| __dummy__: 0 | |
| } | |
| Module['Runtime'] = Runtime; | |
| // ASM_JS safe heap | |
| function getSafeHeapType(bytes, isFloat) { | |
| switch (bytes) { | |
| case 1: return 'i8'; | |
| case 2: return 'i16'; | |
| case 4: return isFloat ? 'float' : 'i32'; | |
| case 8: return 'double'; | |
| default: assert(0); | |
| } | |
| } | |
| function SAFE_HEAP_STORE(dest, value, bytes, isFloat) { | |
| if (dest <= 0) abort('segmentation fault storing ' + bytes + ' bytes to address ' + dest); | |
| if (dest % bytes !== 0) abort('alignment error storing to address ' + dest + ', which was expected to be aligned to a multiple of ' + bytes); | |
| if (dest + bytes > Math.max(DYNAMICTOP, STATICTOP)) abort('segmentation fault, exceeded the top of the available heap when storing ' + bytes + ' bytes to address ' + dest + '. STATICTOP=' + STATICTOP + ', DYNAMICTOP=' + DYNAMICTOP); | |
| assert(DYNAMICTOP <= TOTAL_MEMORY); | |
| setValue(dest, value, getSafeHeapType(bytes, isFloat), 1); | |
| } | |
| function SAFE_HEAP_LOAD(dest, bytes, isFloat, unsigned) { | |
| if (dest <= 0) abort('segmentation fault loading ' + bytes + ' bytes from address ' + dest); | |
| if (dest % bytes !== 0) abort('alignment error loading from address ' + dest + ', which was expected to be aligned to a multiple of ' + bytes); | |
| if (dest + bytes > Math.max(DYNAMICTOP, STATICTOP)) abort('segmentation fault, exceeded the top of the available heap when loading ' + bytes + ' bytes from address ' + dest + '. STATICTOP=' + STATICTOP + ', DYNAMICTOP=' + DYNAMICTOP); | |
| assert(DYNAMICTOP <= TOTAL_MEMORY); | |
| var type = getSafeHeapType(bytes, isFloat); | |
| var ret = getValue(dest, type, 1); | |
| if (unsigned) ret = unSign(ret, parseInt(type.substr(1)), 1); | |
| return ret; | |
| } | |
| function SAFE_FT_MASK(value, mask) { | |
| var ret = value & mask; | |
| if (ret !== value) { | |
| abort('Function table mask error: function pointer is ' + value + ' which is masked by ' + mask + ', the likely cause of this is that the function pointer is being called by the wrong type.'); | |
| } | |
| return ret; | |
| } | |
| //======================================== | |
| // Runtime essentials | |
| //======================================== | |
| var __THREW__ = 0; // Used in checking for thrown exceptions. | |
| var ABORT = false; // whether we are quitting the application. no code should run after this. set in exit() and abort() | |
| var EXITSTATUS = 0; | |
| 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, tempDouble, tempFloat; | |
| var tempI64, tempI64b; | |
| var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9; | |
| function assert(condition, text) { | |
| if (!condition) { | |
| abort('Assertion failed: ' + text); | |
| } | |
| } | |
| var globalScope = this; | |
| // Returns the C function with a specified identifier (for C++, you need to do manual name mangling) | |
| function getCFunc(ident) { | |
| var func = Module['_' + ident]; // closure exported function | |
| if (!func) { | |
| try { | |
| func = eval('_' + ident); // explicit lookup | |
| } catch(e) {} | |
| } | |
| assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)'); | |
| return func; | |
| } | |
| var cwrap, ccall; | |
| (function(){ | |
| var JSfuncs = { | |
| // Helpers for cwrap -- it can't refer to Runtime directly because it might | |
| // be renamed by closure, instead it calls JSfuncs['stackSave'].body to find | |
| // out what the minified function name is. | |
| 'stackSave': function() { | |
| Runtime.stackSave() | |
| }, | |
| 'stackRestore': function() { | |
| Runtime.stackRestore() | |
| }, | |
| // type conversion from js to c | |
| 'arrayToC' : function(arr) { | |
| var ret = Runtime.stackAlloc(arr.length); | |
| writeArrayToMemory(arr, ret); | |
| return ret; | |
| }, | |
| 'stringToC' : function(str) { | |
| var ret = 0; | |
| if (str !== null && str !== undefined && str !== 0) { // null string | |
| // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0' | |
| ret = Runtime.stackAlloc((str.length << 2) + 1); | |
| writeStringToMemory(str, ret); | |
| } | |
| return ret; | |
| } | |
| }; | |
| // For fast lookup of conversion functions | |
| var toC = {'string' : JSfuncs['stringToC'], 'array' : JSfuncs['arrayToC']}; | |
| // C calling interface. | |
| ccall = function ccallFunc(ident, returnType, argTypes, args) { | |
| var func = getCFunc(ident); | |
| var cArgs = []; | |
| var stack = 0; | |
| assert(returnType !== 'array', 'Return type should not be "array".'); | |
| if (args) { | |
| for (var i = 0; i < args.length; i++) { | |
| var converter = toC[argTypes[i]]; | |
| if (converter) { | |
| if (stack === 0) stack = Runtime.stackSave(); | |
| cArgs[i] = converter(args[i]); | |
| } else { | |
| cArgs[i] = args[i]; | |
| } | |
| } | |
| } | |
| var ret = func.apply(null, cArgs); | |
| if (typeof EmterpreterAsync === 'object') { | |
| assert(!EmterpreterAsync.state, 'cannot start async op with normal JS calling ccall'); | |
| } | |
| if (returnType === 'string') ret = Pointer_stringify(ret); | |
| if (stack !== 0) Runtime.stackRestore(stack); | |
| return ret; | |
| } | |
| var sourceRegex = /^function\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/; | |
| function parseJSFunc(jsfunc) { | |
| // Match the body and the return value of a javascript function source | |
| var parsed = jsfunc.toString().match(sourceRegex).slice(1); | |
| return {arguments : parsed[0], body : parsed[1], returnValue: parsed[2]} | |
| } | |
| var JSsource = {}; | |
| for (var fun in JSfuncs) { | |
| if (JSfuncs.hasOwnProperty(fun)) { | |
| // Elements of toCsource are arrays of three items: | |
| // the code, and the return value | |
| JSsource[fun] = parseJSFunc(JSfuncs[fun]); | |
| } | |
| } | |
| cwrap = function cwrap(ident, returnType, argTypes) { | |
| argTypes = argTypes || []; | |
| var cfunc = getCFunc(ident); | |
| // When the function takes numbers and returns a number, we can just return | |
| // the original function | |
| var numericArgs = argTypes.every(function(type){ return type === 'number'}); | |
| var numericRet = (returnType !== 'string'); | |
| if ( numericRet && numericArgs) { | |
| return cfunc; | |
| } | |
| // Creation of the arguments list (["$1","$2",...,"$nargs"]) | |
| var argNames = argTypes.map(function(x,i){return '$'+i}); | |
| var funcstr = "(function(" + argNames.join(',') + ") {"; | |
| var nargs = argTypes.length; | |
| if (!numericArgs) { | |
| // Generate the code needed to convert the arguments from javascript | |
| // values to pointers | |
| funcstr += 'var stack = ' + JSsource['stackSave'].body + ';'; | |
| for (var i = 0; i < nargs; i++) { | |
| var arg = argNames[i], type = argTypes[i]; | |
| if (type === 'number') continue; | |
| var convertCode = JSsource[type + 'ToC']; // [code, return] | |
| funcstr += 'var ' + convertCode.arguments + ' = ' + arg + ';'; | |
| funcstr += convertCode.body + ';'; | |
| funcstr += arg + '=' + convertCode.returnValue + ';'; | |
| } | |
| } | |
| // When the code is compressed, the name of cfunc is not literally 'cfunc' anymore | |
| var cfuncname = parseJSFunc(function(){return cfunc}).returnValue; | |
| // Call the function | |
| funcstr += 'var ret = ' + cfuncname + '(' + argNames.join(',') + ');'; | |
| if (!numericRet) { // Return type can only by 'string' or 'number' | |
| // Convert the result to a string | |
| var strgfy = parseJSFunc(function(){return Pointer_stringify}).returnValue; | |
| funcstr += 'ret = ' + strgfy + '(ret);'; | |
| } | |
| funcstr += "if (typeof EmterpreterAsync === 'object') { assert(!EmterpreterAsync.state, 'cannot start async op with normal JS calling cwrap') }"; | |
| if (!numericArgs) { | |
| // If we had a stack, restore it | |
| funcstr += JSsource['stackRestore'].body.replace('()', '(stack)') + ';'; | |
| } | |
| funcstr += 'return ret})'; | |
| return eval(funcstr); | |
| }; | |
| })(); | |
| Module["cwrap"] = cwrap; | |
| Module["ccall"] = ccall; | |
| function setValue(ptr, value, type, noSafe) { | |
| type = type || 'i8'; | |
| if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit | |
| if (noSafe) { | |
| switch(type) { | |
| case 'i1': HEAP8[((ptr)>>0)]=value; break; | |
| case 'i8': HEAP8[((ptr)>>0)]=value; break; | |
| case 'i16': HEAP16[((ptr)>>1)]=value; break; | |
| case 'i32': HEAP32[((ptr)>>2)]=value; break; | |
| case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break; | |
| case 'float': HEAPF32[((ptr)>>2)]=value; break; | |
| case 'double': HEAPF64[((ptr)>>3)]=value; break; | |
| default: abort('invalid type for setValue: ' + type); | |
| } | |
| } else { | |
| switch(type) { | |
| case 'i1': ((SAFE_HEAP_STORE(((ptr)|0), ((value)|0), 1, 0))|0); break; | |
| case 'i8': ((SAFE_HEAP_STORE(((ptr)|0), ((value)|0), 1, 0))|0); break; | |
| case 'i16': ((SAFE_HEAP_STORE(((ptr)|0), ((value)|0), 2, 0))|0); break; | |
| case 'i32': ((SAFE_HEAP_STORE(((ptr)|0), ((value)|0), 4, 0))|0); break; | |
| case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= (+1) ? (tempDouble > (+0) ? ((Math_min((+(Math_floor((tempDouble)/(+4294967296)))), (+4294967295)))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/(+4294967296))))))>>>0) : 0)],((SAFE_HEAP_STORE(((ptr)|0), ((tempI64[0])|0), 4, 0))|0),((SAFE_HEAP_STORE((((ptr)+(4))|0), ((tempI64[1])|0), 4, 0))|0)); break; | |
| case 'float': (+(SAFE_HEAP_STORE(((ptr)|0), (+(value)), 4, 1))); break; | |
| case 'double': (+(SAFE_HEAP_STORE(((ptr)|0), (+(value)), 8, 1))); break; | |
| default: abort('invalid type for setValue: ' + type); | |
| } | |
| } | |
| } | |
| Module['setValue'] = setValue; | |
| function getValue(ptr, type, noSafe) { | |
| type = type || 'i8'; | |
| if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit | |
| if (noSafe) { | |
| switch(type) { | |
| case 'i1': return HEAP8[((ptr)>>0)]; | |
| case 'i8': return HEAP8[((ptr)>>0)]; | |
| 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 HEAPF64[((ptr)>>3)]; | |
| default: abort('invalid type for setValue: ' + type); | |
| } | |
| } else { | |
| switch(type) { | |
| case 'i1': return ((SAFE_HEAP_LOAD(((ptr)|0), 1, 0, 0))|0); | |
| case 'i8': return ((SAFE_HEAP_LOAD(((ptr)|0), 1, 0, 0))|0); | |
| case 'i16': return ((SAFE_HEAP_LOAD(((ptr)|0), 2, 0, 0))|0); | |
| case 'i32': return ((SAFE_HEAP_LOAD(((ptr)|0), 4, 0, 0))|0); | |
| case 'i64': return ((SAFE_HEAP_LOAD(((ptr)|0), 8, 0, 0))|0); | |
| case 'float': return (+(SAFE_HEAP_LOAD(((ptr)|0), 4, 1, 0))); | |
| case 'double': return (+(SAFE_HEAP_LOAD(((ptr)|0), 8, 1, 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 | |
| var ALLOC_DYNAMIC = 3; // Cannot be freed except through sbrk | |
| var ALLOC_NONE = 4; // Do not allocate | |
| Module['ALLOC_NORMAL'] = ALLOC_NORMAL; | |
| Module['ALLOC_STACK'] = ALLOC_STACK; | |
| Module['ALLOC_STATIC'] = ALLOC_STATIC; | |
| Module['ALLOC_DYNAMIC'] = ALLOC_DYNAMIC; | |
| Module['ALLOC_NONE'] = ALLOC_NONE; | |
| // 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, ptr) { | |
| 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; | |
| if (allocator == ALLOC_NONE) { | |
| ret = ptr; | |
| } else { | |
| ret = [_malloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length)); | |
| } | |
| if (zeroinit) { | |
| var ptr = ret, stop; | |
| assert((ret & 3) == 0); | |
| stop = ret + (size & ~3); | |
| for (; ptr < stop; ptr += 4) { | |
| HEAP32[((ptr)>>2)]=0; | |
| } | |
| stop = ret + size; | |
| while (ptr < stop) { | |
| HEAP8[((ptr++)>>0)]=0; | |
| } | |
| return ret; | |
| } | |
| if (singleType === 'i8') { | |
| if (slab.subarray || slab.slice) { | |
| HEAPU8.set(slab, ret); | |
| } else { | |
| HEAPU8.set(new Uint8Array(slab), ret); | |
| } | |
| return ret; | |
| } | |
| var i = 0, type, typeSize, previousType; | |
| 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); | |
| // no need to look up size unless type changes, so cache it | |
| if (previousType !== type) { | |
| typeSize = Runtime.getNativeTypeSize(type); | |
| previousType = type; | |
| } | |
| i += typeSize; | |
| } | |
| return ret; | |
| } | |
| Module['allocate'] = allocate; | |
| function Pointer_stringify(ptr, /* optional */ length) { | |
| if (length === 0 || !ptr) return ''; | |
| // TODO: use TextDecoder | |
| // Find the length, and check for UTF while doing so | |
| var hasUtf = 0; | |
| var t; | |
| var i = 0; | |
| while (1) { | |
| assert(ptr + i < TOTAL_MEMORY); | |
| t = ((SAFE_HEAP_LOAD((((ptr)+(i))|0), 1, 0, 1))|0); | |
| hasUtf |= t; | |
| if (t == 0 && !length) break; | |
| i++; | |
| if (length && i == length) break; | |
| } | |
| if (!length) length = i; | |
| var ret = ''; | |
| if (hasUtf < 128) { | |
| var MAX_CHUNK = 1024; // split up into chunks, because .apply on a huge string can overflow the stack | |
| var curr; | |
| while (length > 0) { | |
| curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK))); | |
| ret = ret ? ret + curr : curr; | |
| ptr += MAX_CHUNK; | |
| length -= MAX_CHUNK; | |
| } | |
| return ret; | |
| } | |
| return Module['UTF8ToString'](ptr); | |
| } | |
| Module['Pointer_stringify'] = Pointer_stringify; | |
| // Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns | |
| // a copy of that string as a Javascript String object. | |
| function AsciiToString(ptr) { | |
| var str = ''; | |
| while (1) { | |
| var ch = ((SAFE_HEAP_LOAD(((ptr++)|0), 1, 0, 0))|0); | |
| if (!ch) return str; | |
| str += String.fromCharCode(ch); | |
| } | |
| } | |
| Module['AsciiToString'] = AsciiToString; | |
| // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', | |
| // null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP. | |
| function stringToAscii(str, outPtr) { | |
| return writeAsciiToMemory(str, outPtr, false); | |
| } | |
| Module['stringToAscii'] = stringToAscii; | |
| // Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the a given array that contains uint8 values, returns | |
| // a copy of that string as a Javascript String object. | |
| function UTF8ArrayToString(u8Array, idx) { | |
| var u0, u1, u2, u3, u4, u5; | |
| var str = ''; | |
| while (1) { | |
| // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629 | |
| u0 = u8Array[idx++]; | |
| if (!u0) return str; | |
| if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } | |
| u1 = u8Array[idx++] & 63; | |
| if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } | |
| u2 = u8Array[idx++] & 63; | |
| if ((u0 & 0xF0) == 0xE0) { | |
| u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; | |
| } else { | |
| u3 = u8Array[idx++] & 63; | |
| if ((u0 & 0xF8) == 0xF0) { | |
| u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | u3; | |
| } else { | |
| u4 = u8Array[idx++] & 63; | |
| if ((u0 & 0xFC) == 0xF8) { | |
| u0 = ((u0 & 3) << 24) | (u1 << 18) | (u2 << 12) | (u3 << 6) | u4; | |
| } else { | |
| u5 = u8Array[idx++] & 63; | |
| u0 = ((u0 & 1) << 30) | (u1 << 24) | (u2 << 18) | (u3 << 12) | (u4 << 6) | u5; | |
| } | |
| } | |
| } | |
| if (u0 < 0x10000) { | |
| str += String.fromCharCode(u0); | |
| } else { | |
| var ch = u0 - 0x10000; | |
| str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); | |
| } | |
| } | |
| } | |
| Module['UTF8ArrayToString'] = UTF8ArrayToString; | |
| // Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns | |
| // a copy of that string as a Javascript String object. | |
| function UTF8ToString(ptr) { | |
| return UTF8ArrayToString(HEAPU8, ptr); | |
| } | |
| Module['UTF8ToString'] = UTF8ToString; | |
| // Copies the given Javascript String object 'str' to the given byte array at address 'outIdx', | |
| // encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP. | |
| // Use the function lengthBytesUTF8() to compute the exact number of bytes (excluding null terminator) that this function will write. | |
| // Parameters: | |
| // str: the Javascript string to copy. | |
| // outU8Array: the array to copy to. Each index in this array is assumed to be one 8-byte element. | |
| // outIdx: The starting offset in the array to begin the copying. | |
| // maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null | |
| // terminator, i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else. | |
| // maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator. | |
| // Returns the number of bytes written, EXCLUDING the null terminator. | |
| function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) { | |
| if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes. | |
| return 0; | |
| var startIdx = outIdx; | |
| var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. | |
| for (var i = 0; i < str.length; ++i) { | |
| // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. | |
| // See http://unicode.org/faq/utf_bom.html#utf16-3 | |
| // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629 | |
| var u = str.charCodeAt(i); // possibly a lead surrogate | |
| if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); | |
| if (u <= 0x7F) { | |
| if (outIdx >= endIdx) break; | |
| outU8Array[outIdx++] = u; | |
| } else if (u <= 0x7FF) { | |
| if (outIdx + 1 >= endIdx) break; | |
| outU8Array[outIdx++] = 0xC0 | (u >> 6); | |
| outU8Array[outIdx++] = 0x80 | (u & 63); | |
| } else if (u <= 0xFFFF) { | |
| if (outIdx + 2 >= endIdx) break; | |
| outU8Array[outIdx++] = 0xE0 | (u >> 12); | |
| outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); | |
| outU8Array[outIdx++] = 0x80 | (u & 63); | |
| } else if (u <= 0x1FFFFF) { | |
| if (outIdx + 3 >= endIdx) break; | |
| outU8Array[outIdx++] = 0xF0 | (u >> 18); | |
| outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); | |
| outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); | |
| outU8Array[outIdx++] = 0x80 | (u & 63); | |
| } else if (u <= 0x3FFFFFF) { | |
| if (outIdx + 4 >= endIdx) break; | |
| outU8Array[outIdx++] = 0xF8 | (u >> 24); | |
| outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63); | |
| outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); | |
| outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); | |
| outU8Array[outIdx++] = 0x80 | (u & 63); | |
| } else { | |
| if (outIdx + 5 >= endIdx) break; | |
| outU8Array[outIdx++] = 0xFC | (u >> 30); | |
| outU8Array[outIdx++] = 0x80 | ((u >> 24) & 63); | |
| outU8Array[outIdx++] = 0x80 | ((u >> 18) & 63); | |
| outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); | |
| outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); | |
| outU8Array[outIdx++] = 0x80 | (u & 63); | |
| } | |
| } | |
| // Null-terminate the pointer to the buffer. | |
| outU8Array[outIdx] = 0; | |
| return outIdx - startIdx; | |
| } | |
| Module['stringToUTF8Array'] = stringToUTF8Array; | |
| // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', | |
| // null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP. | |
| // Use the function lengthBytesUTF8() to compute the exact number of bytes (excluding null terminator) that this function will write. | |
| // Returns the number of bytes written, EXCLUDING the null terminator. | |
| function stringToUTF8(str, outPtr, maxBytesToWrite) { | |
| assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); | |
| return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite); | |
| } | |
| Module['stringToUTF8'] = stringToUTF8; | |
| // Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte. | |
| function lengthBytesUTF8(str) { | |
| var len = 0; | |
| for (var i = 0; i < str.length; ++i) { | |
| // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. | |
| // See http://unicode.org/faq/utf_bom.html#utf16-3 | |
| var u = str.charCodeAt(i); // possibly a lead surrogate | |
| if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); | |
| if (u <= 0x7F) { | |
| ++len; | |
| } else if (u <= 0x7FF) { | |
| len += 2; | |
| } else if (u <= 0xFFFF) { | |
| len += 3; | |
| } else if (u <= 0x1FFFFF) { | |
| len += 4; | |
| } else if (u <= 0x3FFFFFF) { | |
| len += 5; | |
| } else { | |
| len += 6; | |
| } | |
| } | |
| return len; | |
| } | |
| Module['lengthBytesUTF8'] = lengthBytesUTF8; | |
| // Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns | |
| // a copy of that string as a Javascript String object. | |
| function UTF16ToString(ptr) { | |
| var i = 0; | |
| var str = ''; | |
| while (1) { | |
| var codeUnit = ((SAFE_HEAP_LOAD((((ptr)+(i*2))|0), 2, 0, 0))|0); | |
| if (codeUnit == 0) | |
| return str; | |
| ++i; | |
| // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through. | |
| str += String.fromCharCode(codeUnit); | |
| } | |
| } | |
| Module['UTF16ToString'] = UTF16ToString; | |
| // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', | |
| // null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP. | |
| // Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write. | |
| // Parameters: | |
| // str: the Javascript string to copy. | |
| // outPtr: Byte address in Emscripten HEAP where to write the string to. | |
| // maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null | |
| // terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else. | |
| // maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator. | |
| // Returns the number of bytes written, EXCLUDING the null terminator. | |
| function stringToUTF16(str, outPtr, maxBytesToWrite) { | |
| assert(typeof maxBytesToWrite == 'number', 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); | |
| // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. | |
| if (maxBytesToWrite === undefined) { | |
| maxBytesToWrite = 0x7FFFFFFF; | |
| } | |
| if (maxBytesToWrite < 2) return 0; | |
| maxBytesToWrite -= 2; // Null terminator. | |
| var startPtr = outPtr; | |
| var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; | |
| for (var i = 0; i < numCharsToWrite; ++i) { | |
| // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. | |
| var codeUnit = str.charCodeAt(i); // possibly a lead surrogate | |
| ((SAFE_HEAP_STORE(((outPtr)|0), ((codeUnit)|0), 2, 0))|0); | |
| outPtr += 2; | |
| } | |
| // Null-terminate the pointer to the HEAP. | |
| ((SAFE_HEAP_STORE(((outPtr)|0), ((0)|0), 2, 0))|0); | |
| return outPtr - startPtr; | |
| } | |
| Module['stringToUTF16'] = stringToUTF16; | |
| // Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. | |
| function lengthBytesUTF16(str) { | |
| return str.length*2; | |
| } | |
| Module['lengthBytesUTF16'] = lengthBytesUTF16; | |
| function UTF32ToString(ptr) { | |
| var i = 0; | |
| var str = ''; | |
| while (1) { | |
| var utf32 = ((SAFE_HEAP_LOAD((((ptr)+(i*4))|0), 4, 0, 0))|0); | |
| if (utf32 == 0) | |
| return str; | |
| ++i; | |
| // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. | |
| // See http://unicode.org/faq/utf_bom.html#utf16-3 | |
| if (utf32 >= 0x10000) { | |
| var ch = utf32 - 0x10000; | |
| str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); | |
| } else { | |
| str += String.fromCharCode(utf32); | |
| } | |
| } | |
| } | |
| Module['UTF32ToString'] = UTF32ToString; | |
| // Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', | |
| // null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP. | |
| // Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write. | |
| // Parameters: | |
| // str: the Javascript string to copy. | |
| // outPtr: Byte address in Emscripten HEAP where to write the string to. | |
| // maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null | |
| // terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else. | |
| // maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator. | |
| // Returns the number of bytes written, EXCLUDING the null terminator. | |
| function stringToUTF32(str, outPtr, maxBytesToWrite) { | |
| assert(typeof maxBytesToWrite == 'number', 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); | |
| // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. | |
| if (maxBytesToWrite === undefined) { | |
| maxBytesToWrite = 0x7FFFFFFF; | |
| } | |
| if (maxBytesToWrite < 4) return 0; | |
| var startPtr = outPtr; | |
| var endPtr = startPtr + maxBytesToWrite - 4; | |
| for (var i = 0; i < str.length; ++i) { | |
| // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. | |
| // See http://unicode.org/faq/utf_bom.html#utf16-3 | |
| var codeUnit = str.charCodeAt(i); // possibly a lead surrogate | |
| if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { | |
| var trailSurrogate = str.charCodeAt(++i); | |
| codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); | |
| } | |
| ((SAFE_HEAP_STORE(((outPtr)|0), ((codeUnit)|0), 4, 0))|0); | |
| outPtr += 4; | |
| if (outPtr + 4 > endPtr) break; | |
| } | |
| // Null-terminate the pointer to the HEAP. | |
| ((SAFE_HEAP_STORE(((outPtr)|0), ((0)|0), 4, 0))|0); | |
| return outPtr - startPtr; | |
| } | |
| Module['stringToUTF32'] = stringToUTF32; | |
| // Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. | |
| function lengthBytesUTF32(str) { | |
| var len = 0; | |
| for (var i = 0; i < str.length; ++i) { | |
| // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. | |
| // See http://unicode.org/faq/utf_bom.html#utf16-3 | |
| var codeUnit = str.charCodeAt(i); | |
| if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. | |
| len += 4; | |
| } | |
| return len; | |
| } | |
| Module['lengthBytesUTF32'] = lengthBytesUTF32; | |
| function demangle(func) { | |
| var hasLibcxxabi = !!Module['___cxa_demangle']; | |
| if (hasLibcxxabi) { | |
| try { | |
| var buf = _malloc(func.length); | |
| writeStringToMemory(func.substr(1), buf); | |
| var status = _malloc(4); | |
| var ret = Module['___cxa_demangle'](buf, 0, 0, status); | |
| if (getValue(status, 'i32') === 0 && ret) { | |
| return Pointer_stringify(ret); | |
| } | |
| // otherwise, libcxxabi failed, we can try ours which may return a partial result | |
| } catch(e) { | |
| // failure when using libcxxabi, we can try ours which may return a partial result | |
| } finally { | |
| if (buf) _free(buf); | |
| if (status) _free(status); | |
| if (ret) _free(ret); | |
| } | |
| } | |
| var i = 3; | |
| // params, etc. | |
| var basicTypes = { | |
| 'v': 'void', | |
| 'b': 'bool', | |
| 'c': 'char', | |
| 's': 'short', | |
| 'i': 'int', | |
| 'l': 'long', | |
| 'f': 'float', | |
| 'd': 'double', | |
| 'w': 'wchar_t', | |
| 'a': 'signed char', | |
| 'h': 'unsigned char', | |
| 't': 'unsigned short', | |
| 'j': 'unsigned int', | |
| 'm': 'unsigned long', | |
| 'x': 'long long', | |
| 'y': 'unsigned long long', | |
| 'z': '...' | |
| }; | |
| var subs = []; | |
| var first = true; | |
| function dump(x) { | |
| //return; | |
| if (x) Module.print(x); | |
| Module.print(func); | |
| var pre = ''; | |
| for (var a = 0; a < i; a++) pre += ' '; | |
| Module.print (pre + '^'); | |
| } | |
| function parseNested() { | |
| i++; | |
| if (func[i] === 'K') i++; // ignore const | |
| var parts = []; | |
| while (func[i] !== 'E') { | |
| if (func[i] === 'S') { // substitution | |
| i++; | |
| var next = func.indexOf('_', i); | |
| var num = func.substring(i, next) || 0; | |
| parts.push(subs[num] || '?'); | |
| i = next+1; | |
| continue; | |
| } | |
| if (func[i] === 'C') { // constructor | |
| parts.push(parts[parts.length-1]); | |
| i += 2; | |
| continue; | |
| } | |
| var size = parseInt(func.substr(i)); | |
| var pre = size.toString().length; | |
| if (!size || !pre) { i--; break; } // counter i++ below us | |
| var curr = func.substr(i + pre, size); | |
| parts.push(curr); | |
| subs.push(curr); | |
| i += pre + size; | |
| } | |
| i++; // skip E | |
| return parts; | |
| } | |
| function parse(rawList, limit, allowVoid) { // main parser | |
| limit = limit || Infinity; | |
| var ret = '', list = []; | |
| function flushList() { | |
| return '(' + list.join(', ') + ')'; | |
| } | |
| var name; | |
| if (func[i] === 'N') { | |
| // namespaced N-E | |
| name = parseNested().join('::'); | |
| limit--; | |
| if (limit === 0) return rawList ? [name] : name; | |
| } else { | |
| // not namespaced | |
| if (func[i] === 'K' || (first && func[i] === 'L')) i++; // ignore const and first 'L' | |
| var size = parseInt(func.substr(i)); | |
| if (size) { | |
| var pre = size.toString().length; | |
| name = func.substr(i + pre, size); | |
| i += pre + size; | |
| } | |
| } | |
| first = false; | |
| if (func[i] === 'I') { | |
| i++; | |
| var iList = parse(true); | |
| var iRet = parse(true, 1, true); | |
| ret += iRet[0] + ' ' + name + '<' + iList.join(', ') + '>'; | |
| } else { | |
| ret = name; | |
| } | |
| paramLoop: while (i < func.length && limit-- > 0) { | |
| //dump('paramLoop'); | |
| var c = func[i++]; | |
| if (c in basicTypes) { | |
| list.push(basicTypes[c]); | |
| } else { | |
| switch (c) { | |
| case 'P': list.push(parse(true, 1, true)[0] + '*'); break; // pointer | |
| case 'R': list.push(parse(true, 1, true)[0] + '&'); break; // reference | |
| case 'L': { // literal | |
| i++; // skip basic type | |
| var end = func.indexOf('E', i); | |
| var size = end - i; | |
| list.push(func.substr(i, size)); | |
| i += size + 2; // size + 'EE' | |
| break; | |
| } | |
| case 'A': { // array | |
| var size = parseInt(func.substr(i)); | |
| i += size.toString().length; | |
| if (func[i] !== '_') throw '?'; | |
| i++; // skip _ | |
| list.push(parse(true, 1, true)[0] + ' [' + size + ']'); | |
| break; | |
| } | |
| case 'E': break paramLoop; | |
| default: ret += '?' + c; break paramLoop; | |
| } | |
| } | |
| } | |
| if (!allowVoid && list.length === 1 && list[0] === 'void') list = []; // avoid (void) | |
| if (rawList) { | |
| if (ret) { | |
| list.push(ret + '?'); | |
| } | |
| return list; | |
| } else { | |
| return ret + flushList(); | |
| } | |
| } | |
| var parsed = func; | |
| try { | |
| // Special-case the entry point, since its name differs from other name mangling. | |
| if (func == 'Object._main' || func == '_main') { | |
| return 'main()'; | |
| } | |
| if (typeof func === 'number') func = Pointer_stringify(func); | |
| if (func[0] !== '_') return func; | |
| if (func[1] !== '_') return func; // C function | |
| if (func[2] !== 'Z') return func; | |
| switch (func[3]) { | |
| case 'n': return 'operator new()'; | |
| case 'd': return 'operator delete()'; | |
| } | |
| parsed = parse(); | |
| } catch(e) { | |
| parsed += '?'; | |
| } | |
| if (parsed.indexOf('?') >= 0 && !hasLibcxxabi) { | |
| Runtime.warnOnce('warning: a problem occurred in builtin C++ name demangling; build with -s DEMANGLE_SUPPORT=1 to link in libcxxabi demangling'); | |
| } | |
| return parsed; | |
| } | |
| function demangleAll(text) { | |
| return text.replace(/__Z[\w\d_]+/g, function(x) { var y = demangle(x); return x === y ? x : (x + ' [' + y + ']') }); | |
| } | |
| function jsStackTrace() { | |
| var err = new Error(); | |
| if (!err.stack) { | |
| // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown, | |
| // so try that as a special-case. | |
| try { | |
| throw new Error(0); | |
| } catch(e) { | |
| err = e; | |
| } | |
| if (!err.stack) { | |
| return '(no stack trace available)'; | |
| } | |
| } | |
| return err.stack.toString(); | |
| } | |
| function stackTrace() { | |
| return demangleAll(jsStackTrace()); | |
| } | |
| Module['stackTrace'] = stackTrace; | |
| // Memory management | |
| var PAGE_SIZE = 4096; | |
| function alignMemoryPage(x) { | |
| if (x % 4096 > 0) { | |
| x += (4096 - (x % 4096)); | |
| } | |
| return x; | |
| } | |
| var HEAP; | |
| var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64; | |
| var STATIC_BASE = 0, STATICTOP = 0, staticSealed = false; // static area | |
| var STACK_BASE = 0, STACKTOP = 0, STACK_MAX = 0; // stack area | |
| var DYNAMIC_BASE = 0, DYNAMICTOP = 0; // dynamic area handled by sbrk | |
| function enlargeMemory() { | |
| // TOTAL_MEMORY is the current size of the actual array, and DYNAMICTOP is the new top. | |
| assert(DYNAMICTOP >= TOTAL_MEMORY); | |
| assert(TOTAL_MEMORY > 4); // So the loop below will not be infinite | |
| var OLD_TOTAL_MEMORY = TOTAL_MEMORY; | |
| var LIMIT = Math.pow(2, 31); // 2GB is a practical maximum, as we use signed ints as pointers | |
| // and JS engines seem unhappy to give us 2GB arrays currently | |
| if (DYNAMICTOP >= LIMIT) return false; | |
| while (TOTAL_MEMORY <= DYNAMICTOP) { // Simple heuristic. | |
| if (TOTAL_MEMORY < LIMIT/2) { | |
| TOTAL_MEMORY = alignMemoryPage(2*TOTAL_MEMORY); // double until 1GB | |
| } else { | |
| var last = TOTAL_MEMORY; | |
| TOTAL_MEMORY = alignMemoryPage((3*TOTAL_MEMORY + LIMIT)/4); // add smaller increments towards 2GB, which we cannot reach | |
| if (TOTAL_MEMORY <= last) return false; | |
| } | |
| } | |
| TOTAL_MEMORY = Math.max(TOTAL_MEMORY, 16*1024*1024); | |
| if (TOTAL_MEMORY >= LIMIT) return false; | |
| Module.printErr('Warning: Enlarging memory arrays, this is not fast! ' + [OLD_TOTAL_MEMORY, TOTAL_MEMORY]); | |
| var start = Date.now(); | |
| try { | |
| if (ArrayBuffer.transfer) { | |
| buffer = ArrayBuffer.transfer(buffer, TOTAL_MEMORY); | |
| } else { | |
| var oldHEAP8 = HEAP8; | |
| buffer = new ArrayBuffer(TOTAL_MEMORY); | |
| } | |
| } catch(e) { | |
| return false; | |
| } | |
| var success = _emscripten_replace_memory(buffer); | |
| if (!success) return false; | |
| // everything worked | |
| Module['buffer'] = buffer; | |
| Module['HEAP8'] = HEAP8 = new Int8Array(buffer); | |
| Module['HEAP16'] = HEAP16 = new Int16Array(buffer); | |
| Module['HEAP32'] = HEAP32 = new Int32Array(buffer); | |
| Module['HEAPU8'] = HEAPU8 = new Uint8Array(buffer); | |
| Module['HEAPU16'] = HEAPU16 = new Uint16Array(buffer); | |
| Module['HEAPU32'] = HEAPU32 = new Uint32Array(buffer); | |
| Module['HEAPF32'] = HEAPF32 = new Float32Array(buffer); | |
| Module['HEAPF64'] = HEAPF64 = new Float64Array(buffer); | |
| if (!ArrayBuffer.transfer) { | |
| HEAP8.set(oldHEAP8); | |
| } | |
| Module.printErr('enlarged memory arrays from ' + OLD_TOTAL_MEMORY + ' to ' + TOTAL_MEMORY + ', took ' + (Date.now() - start) + ' ms (has ArrayBuffer.transfer? ' + (!!ArrayBuffer.transfer) + ')'); | |
| return true; | |
| } | |
| var byteLength; | |
| try { | |
| byteLength = Function.prototype.call.bind(Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength').get); | |
| byteLength(new ArrayBuffer(4)); // can fail on older ie | |
| } catch(e) { // can fail on older node/v8 | |
| byteLength = function(buffer) { return buffer.byteLength; }; | |
| } | |
| var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880; | |
| var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 16777216; | |
| var totalMemory = 64*1024; | |
| while (totalMemory < TOTAL_MEMORY || totalMemory < 2*TOTAL_STACK) { | |
| if (totalMemory < 16*1024*1024) { | |
| totalMemory *= 2; | |
| } else { | |
| totalMemory += 16*1024*1024 | |
| } | |
| } | |
| totalMemory = Math.max(totalMemory, 16*1024*1024); | |
| if (totalMemory !== TOTAL_MEMORY) { | |
| Module.printErr('increasing TOTAL_MEMORY to ' + totalMemory + ' to be compliant with the asm.js spec (and given that TOTAL_STACK=' + TOTAL_STACK + ')'); | |
| TOTAL_MEMORY = totalMemory; | |
| } | |
| // Initialize the runtime's memory | |
| // check for full engine support (use string 'subarray' to avoid closure compiler confusion) | |
| assert(typeof Int32Array !== 'undefined' && typeof Float64Array !== 'undefined' && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']), | |
| 'JS engine does not provide full typed array support'); | |
| 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['buffer'] = buffer; | |
| Module['HEAP8'] = HEAP8; | |
| Module['HEAP16'] = HEAP16; | |
| Module['HEAP32'] = HEAP32; | |
| Module['HEAPU8'] = HEAPU8; | |
| Module['HEAPU16'] = HEAPU16; | |
| Module['HEAPU32'] = HEAPU32; | |
| Module['HEAPF32'] = HEAPF32; | |
| Module['HEAPF64'] = HEAPF64; | |
| function callRuntimeCallbacks(callbacks) { | |
| while(callbacks.length > 0) { | |
| var callback = callbacks.shift(); | |
| if (typeof callback == 'function') { | |
| callback(); | |
| continue; | |
| } | |
| var func = callback.func; | |
| if (typeof func === 'number') { | |
| if (callback.arg === undefined) { | |
| Runtime.dynCall('v', func); | |
| } else { | |
| Runtime.dynCall('vi', func, [callback.arg]); | |
| } | |
| } else { | |
| func(callback.arg === undefined ? null : callback.arg); | |
| } | |
| } | |
| } | |
| var __ATPRERUN__ = []; // functions called before the runtime is initialized | |
| var __ATINIT__ = []; // functions called during startup | |
| var __ATMAIN__ = []; // functions called when main() is to be run | |
| var __ATEXIT__ = []; // functions called during shutdown | |
| var __ATPOSTRUN__ = []; // functions called after the runtime has exited | |
| var runtimeInitialized = false; | |
| var runtimeExited = false; | |
| function preRun() { | |
| // compatibility - merge in anything from Module['preRun'] at this time | |
| if (Module['preRun']) { | |
| if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; | |
| while (Module['preRun'].length) { | |
| addOnPreRun(Module['preRun'].shift()); | |
| } | |
| } | |
| callRuntimeCallbacks(__ATPRERUN__); | |
| } | |
| function ensureInitRuntime() { | |
| if (runtimeInitialized) return; | |
| runtimeInitialized = true; | |
| callRuntimeCallbacks(__ATINIT__); | |
| } | |
| function preMain() { | |
| callRuntimeCallbacks(__ATMAIN__); | |
| } | |
| function exitRuntime() { | |
| callRuntimeCallbacks(__ATEXIT__); | |
| runtimeExited = true; | |
| } | |
| function postRun() { | |
| // compatibility - merge in anything from Module['postRun'] at this time | |
| if (Module['postRun']) { | |
| if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; | |
| while (Module['postRun'].length) { | |
| addOnPostRun(Module['postRun'].shift()); | |
| } | |
| } | |
| callRuntimeCallbacks(__ATPOSTRUN__); | |
| } | |
| function addOnPreRun(cb) { | |
| __ATPRERUN__.unshift(cb); | |
| } | |
| Module['addOnPreRun'] = Module.addOnPreRun = addOnPreRun; | |
| function addOnInit(cb) { | |
| __ATINIT__.unshift(cb); | |
| } | |
| Module['addOnInit'] = Module.addOnInit = addOnInit; | |
| function addOnPreMain(cb) { | |
| __ATMAIN__.unshift(cb); | |
| } | |
| Module['addOnPreMain'] = Module.addOnPreMain = addOnPreMain; | |
| function addOnExit(cb) { | |
| __ATEXIT__.unshift(cb); | |
| } | |
| Module['addOnExit'] = Module.addOnExit = addOnExit; | |
| function addOnPostRun(cb) { | |
| __ATPOSTRUN__.unshift(cb); | |
| } | |
| Module['addOnPostRun'] = Module.addOnPostRun = addOnPostRun; | |
| // Tools | |
| function intArrayFromString(stringy, dontAddNull, length /* optional */) { | |
| var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; | |
| var u8array = new Array(len); | |
| var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); | |
| if (dontAddNull) u8array.length = numBytesWritten; | |
| return u8array; | |
| } | |
| 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; | |
| function writeStringToMemory(string, buffer, dontAddNull) { | |
| var array = intArrayFromString(string, dontAddNull); | |
| var i = 0; | |
| while (i < array.length) { | |
| var chr = array[i]; | |
| ((SAFE_HEAP_STORE((((buffer)+(i))|0), ((chr)|0), 1, 0))|0); | |
| i = i + 1; | |
| } | |
| } | |
| Module['writeStringToMemory'] = writeStringToMemory; | |
| function writeArrayToMemory(array, buffer) { | |
| for (var i = 0; i < array.length; i++) { | |
| ((SAFE_HEAP_STORE(((buffer++)|0), ((array[i])|0), 1, 0))|0); | |
| } | |
| } | |
| Module['writeArrayToMemory'] = writeArrayToMemory; | |
| function writeAsciiToMemory(str, buffer, dontAddNull) { | |
| for (var i = 0; i < str.length; ++i) { | |
| assert(str.charCodeAt(i) === str.charCodeAt(i)&0xff); | |
| ((SAFE_HEAP_STORE(((buffer++)|0), ((str.charCodeAt(i))|0), 1, 0))|0); | |
| } | |
| // Null-terminate the pointer to the HEAP. | |
| if (!dontAddNull) ((SAFE_HEAP_STORE(((buffer)|0), ((0)|0), 1, 0))|0); | |
| } | |
| Module['writeAsciiToMemory'] = writeAsciiToMemory; | |
| function unSign(value, bits, ignore) { | |
| 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; | |
| } | |
| function reSign(value, bits, ignore) { | |
| 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; | |
| } | |
| // check for imul support, and also for correctness ( https://bugs.webkit.org/show_bug.cgi?id=126345 ) | |
| if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) { | |
| var ah = a >>> 16; | |
| var al = a & 0xffff; | |
| var bh = b >>> 16; | |
| var bl = b & 0xffff; | |
| return (al*bl + ((ah*bl + al*bh) << 16))|0; | |
| }; | |
| Math.imul = Math['imul']; | |
| if (!Math['clz32']) Math['clz32'] = function(x) { | |
| x = x >>> 0; | |
| for (var i = 0; i < 32; i++) { | |
| if (x & (1 << (31 - i))) return i; | |
| } | |
| return 32; | |
| }; | |
| Math.clz32 = Math['clz32'] | |
| var Math_abs = Math.abs; | |
| var Math_cos = Math.cos; | |
| var Math_sin = Math.sin; | |
| var Math_tan = Math.tan; | |
| var Math_acos = Math.acos; | |
| var Math_asin = Math.asin; | |
| var Math_atan = Math.atan; | |
| var Math_atan2 = Math.atan2; | |
| var Math_exp = Math.exp; | |
| var Math_log = Math.log; | |
| var Math_sqrt = Math.sqrt; | |
| var Math_ceil = Math.ceil; | |
| var Math_floor = Math.floor; | |
| var Math_pow = Math.pow; | |
| var Math_imul = Math.imul; | |
| var Math_fround = Math.fround; | |
| var Math_min = Math.min; | |
| var Math_clz32 = Math.clz32; | |
| // 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 runDependencyWatcher = null; | |
| var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled | |
| var runDependencyTracking = {}; | |
| 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() { | |
| if (ABORT) { | |
| clearInterval(runDependencyWatcher); | |
| runDependencyWatcher = null; | |
| return; | |
| } | |
| 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)'); | |
| } | |
| }, 10000); | |
| } | |
| } 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 (dependenciesFulfilled) { | |
| var callback = dependenciesFulfilled; | |
| dependenciesFulfilled = null; | |
| callback(); // can add another dependenciesFulfilled | |
| } | |
| } | |
| } | |
| Module['removeRunDependency'] = removeRunDependency; | |
| Module["preloadedImages"] = {}; // maps url to image data | |
| Module["preloadedAudios"] = {}; // maps url to audio data | |
| var memoryInitializer = null; | |
| // === Body === | |
| Runtime.asmConsts = [function() { console.log("asyncified_method()") }, function() { { console.log("set timer to release wait loop"); _are_we_done_yet = false; } }, function() { console.log("before a bit_of_stack()") }, function() { console.log("a_bit_of_stack()") }, function() { console.log("waiting...", Date.now()); }, function() { console.log("before emscripten_sleep()") }, function() { console.log("after emscripten_sleep()") }, function() { console.log("we are done!", Date.now()); }, function() { console.log("end of a_bit_of_stack()") }, function() { console.log("after a bit_of_stack()") }, function() { done() }, function() { console.log("after done()") }]; | |
| STATIC_BASE = 2048; | |
| STATICTOP = STATIC_BASE + 1053592; | |
| var EMTSTACKTOP = STATIC_BASE + 5000, EMT_STACK_MAX = EMTSTACKTOP + 1048576; | |
| /* global initializers */ __ATINIT__.push(); | |
| var memoryInitializer = "asyncified.js.mem"; | |
| var tempDoublePtr = Runtime.alignMemory(allocate(12, "i8", ALLOC_STATIC), 8); | |
| assert(tempDoublePtr % 8 == 0); | |
| function copyTempFloat(ptr) { // functions, because inlining this code increases code size too much | |
| HEAP8[tempDoublePtr] = HEAP8[ptr]; | |
| HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; | |
| HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; | |
| HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; | |
| } | |
| function copyTempDouble(ptr) { | |
| HEAP8[tempDoublePtr] = HEAP8[ptr]; | |
| HEAP8[tempDoublePtr+1] = HEAP8[ptr+1]; | |
| HEAP8[tempDoublePtr+2] = HEAP8[ptr+2]; | |
| HEAP8[tempDoublePtr+3] = HEAP8[ptr+3]; | |
| HEAP8[tempDoublePtr+4] = HEAP8[ptr+4]; | |
| HEAP8[tempDoublePtr+5] = HEAP8[ptr+5]; | |
| HEAP8[tempDoublePtr+6] = HEAP8[ptr+6]; | |
| HEAP8[tempDoublePtr+7] = HEAP8[ptr+7]; | |
| } | |
| Module["_i64Add"] = _i64Add; | |
| var _BDtoIHigh=true; | |
| Module["_i64Subtract"] = _i64Subtract; | |
| var ___errno_state=0;function ___setErrNo(value) { | |
| // For convenient setting and returning of errno. | |
| ((SAFE_HEAP_STORE(((___errno_state)|0), ((value)|0), 4, 0))|0); | |
| return value; | |
| } | |
| var ERRNO_CODES={EPERM:1,ENOENT:2,ESRCH:3,EINTR:4,EIO:5,ENXIO:6,E2BIG:7,ENOEXEC:8,EBADF:9,ECHILD:10,EAGAIN:11,EWOULDBLOCK:11,ENOMEM:12,EACCES:13,EFAULT:14,ENOTBLK:15,EBUSY:16,EEXIST:17,EXDEV:18,ENODEV:19,ENOTDIR:20,EISDIR:21,EINVAL:22,ENFILE:23,EMFILE:24,ENOTTY:25,ETXTBSY:26,EFBIG:27,ENOSPC:28,ESPIPE:29,EROFS:30,EMLINK:31,EPIPE:32,EDOM:33,ERANGE:34,ENOMSG:42,EIDRM:43,ECHRNG:44,EL2NSYNC:45,EL3HLT:46,EL3RST:47,ELNRNG:48,EUNATCH:49,ENOCSI:50,EL2HLT:51,EDEADLK:35,ENOLCK:37,EBADE:52,EBADR:53,EXFULL:54,ENOANO:55,EBADRQC:56,EBADSLT:57,EDEADLOCK:35,EBFONT:59,ENOSTR:60,ENODATA:61,ETIME:62,ENOSR:63,ENONET:64,ENOPKG:65,EREMOTE:66,ENOLINK:67,EADV:68,ESRMNT:69,ECOMM:70,EPROTO:71,EMULTIHOP:72,EDOTDOT:73,EBADMSG:74,ENOTUNIQ:76,EBADFD:77,EREMCHG:78,ELIBACC:79,ELIBBAD:80,ELIBSCN:81,ELIBMAX:82,ELIBEXEC:83,ENOSYS:38,ENOTEMPTY:39,ENAMETOOLONG:36,ELOOP:40,EOPNOTSUPP:95,EPFNOSUPPORT:96,ECONNRESET:104,ENOBUFS:105,EAFNOSUPPORT:97,EPROTOTYPE:91,ENOTSOCK:88,ENOPROTOOPT:92,ESHUTDOWN:108,ECONNREFUSED:111,EADDRINUSE:98,ECONNABORTED:103,ENETUNREACH:101,ENETDOWN:100,ETIMEDOUT:110,EHOSTDOWN:112,EHOSTUNREACH:113,EINPROGRESS:115,EALREADY:114,EDESTADDRREQ:89,EMSGSIZE:90,EPROTONOSUPPORT:93,ESOCKTNOSUPPORT:94,EADDRNOTAVAIL:99,ENETRESET:102,EISCONN:106,ENOTCONN:107,ETOOMANYREFS:109,EUSERS:87,EDQUOT:122,ESTALE:116,ENOTSUP:95,ENOMEDIUM:123,EILSEQ:84,EOVERFLOW:75,ECANCELED:125,ENOTRECOVERABLE:131,EOWNERDEAD:130,ESTRPIPE:86};function _sysconf(name) { | |
| // long sysconf(int name); | |
| // http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html | |
| switch(name) { | |
| case 30: return PAGE_SIZE; | |
| case 132: | |
| case 133: | |
| case 12: | |
| case 137: | |
| case 138: | |
| case 15: | |
| case 235: | |
| case 16: | |
| case 17: | |
| case 18: | |
| case 19: | |
| case 20: | |
| case 149: | |
| case 13: | |
| case 10: | |
| case 236: | |
| case 153: | |
| case 9: | |
| case 21: | |
| case 22: | |
| case 159: | |
| case 154: | |
| case 14: | |
| case 77: | |
| case 78: | |
| case 139: | |
| case 80: | |
| case 81: | |
| case 79: | |
| case 82: | |
| case 68: | |
| case 67: | |
| case 164: | |
| case 11: | |
| case 29: | |
| case 47: | |
| case 48: | |
| case 95: | |
| case 52: | |
| case 51: | |
| case 46: | |
| return 200809; | |
| case 27: | |
| case 246: | |
| case 127: | |
| case 128: | |
| case 23: | |
| case 24: | |
| case 160: | |
| case 161: | |
| case 181: | |
| case 182: | |
| case 242: | |
| case 183: | |
| case 184: | |
| case 243: | |
| case 244: | |
| case 245: | |
| case 165: | |
| case 178: | |
| case 179: | |
| case 49: | |
| case 50: | |
| case 168: | |
| case 169: | |
| case 175: | |
| case 170: | |
| case 171: | |
| case 172: | |
| case 97: | |
| case 76: | |
| case 32: | |
| case 173: | |
| case 35: | |
| return -1; | |
| case 176: | |
| case 177: | |
| case 7: | |
| case 155: | |
| case 8: | |
| case 157: | |
| case 125: | |
| case 126: | |
| case 92: | |
| case 93: | |
| case 129: | |
| case 130: | |
| case 131: | |
| case 94: | |
| case 91: | |
| return 1; | |
| case 74: | |
| case 60: | |
| case 69: | |
| case 70: | |
| case 4: | |
| return 1024; | |
| case 31: | |
| case 42: | |
| case 72: | |
| return 32; | |
| case 87: | |
| case 26: | |
| case 33: | |
| return 2147483647; | |
| case 34: | |
| case 1: | |
| return 47839; | |
| case 38: | |
| case 36: | |
| return 99; | |
| case 43: | |
| case 37: | |
| return 2048; | |
| case 0: return 2097152; | |
| case 3: return 65536; | |
| case 28: return 32768; | |
| case 44: return 32767; | |
| case 75: return 16384; | |
| case 39: return 1000; | |
| case 89: return 700; | |
| case 71: return 256; | |
| case 40: return 255; | |
| case 2: return 100; | |
| case 180: return 64; | |
| case 25: return 20; | |
| case 5: return 16; | |
| case 6: return 6; | |
| case 73: return 4; | |
| case 84: { | |
| if (typeof navigator === 'object') return navigator['hardwareConcurrency'] || 1; | |
| return 1; | |
| } | |
| } | |
| ___setErrNo(ERRNO_CODES.EINVAL); | |
| return -1; | |
| } | |
| var _emscripten_preinvoke=true; | |
| Module["_memset"] = _memset; | |
| var _BDtoILow=true; | |
| var _emscripten_resume=true; | |
| var _BItoD=true; | |
| var _emscripten_landingpad=true; | |
| Module["_bitshift64Shl"] = _bitshift64Shl; | |
| function _abort() { | |
| Module['abort'](); | |
| } | |
| var ERRNO_MESSAGES={0:"Success",1:"Not super-user",2:"No such file or directory",3:"No such process",4:"Interrupted system call",5:"I/O error",6:"No such device or address",7:"Arg list too long",8:"Exec format error",9:"Bad file number",10:"No children",11:"No more processes",12:"Not enough core",13:"Permission denied",14:"Bad address",15:"Block device required",16:"Mount device busy",17:"File exists",18:"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:"Not a typewriter",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:"Math arg out of domain of func",34:"Math result not representable",35:"File locking deadlock error",36:"File or path name too long",37:"No record locks available",38:"Function not implemented",39:"Directory not empty",40:"Too many symbolic links",42:"No message of desired type",43:"Identifier removed",44:"Channel number out of range",45:"Level 2 not synchronized",46:"Level 3 halted",47:"Level 3 reset",48:"Link number out of range",49:"Protocol driver not attached",50:"No CSI structure available",51:"Level 2 halted",52:"Invalid exchange",53:"Invalid request descriptor",54:"Exchange full",55:"No anode",56:"Invalid request code",57:"Invalid slot",59:"Bad font file fmt",60:"Device not a stream",61:"No data (for no delay io)",62:"Timer expired",63:"Out of streams resources",64:"Machine is not on the network",65:"Package not installed",66:"The object is remote",67:"The link has been severed",68:"Advertise error",69:"Srmount error",70:"Communication error on send",71:"Protocol error",72:"Multihop attempted",73:"Cross mount point (not really error)",74:"Trying to read unreadable message",75:"Value too large for defined data type",76:"Given log. name not unique",77:"f.d. invalid for this operation",78:"Remote address changed",79:"Can access a needed shared lib",80:"Accessing a corrupted shared lib",81:".lib section in a.out corrupted",82:"Attempting to link in too many libs",83:"Attempting to exec a shared library",84:"Illegal byte sequence",86:"Streams pipe error",87:"Too many users",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:"Unknown protocol",94:"Socket type not supported",95:"Not supported",96:"Protocol family not supported",97:"Address family not supported by protocol family",98:"Address already in use",99:"Address not available",100:"Network interface is not configured",101:"Network is unreachable",102:"Connection reset by network",103:"Connection aborted",104:"Connection reset by peer",105:"No buffer space available",106:"Socket is already connected",107:"Socket is not connected",108:"Can't send after socket shutdown",109:"Too many references",110:"Connection timed out",111:"Connection refused",112:"Host is down",113:"Host is unreachable",114:"Socket already connected",115:"Connection already in progress",116:"Stale file handle",122:"Quota exceeded",123:"No medium (in tape drive)",125:"Operation canceled",130:"Previous owner died",131:"State not recoverable"}; | |
| var TTY={ttys:[],init:function () { | |
| // https://github.com/kripken/emscripten/pull/1555 | |
| // if (ENVIRONMENT_IS_NODE) { | |
| // // currently, FS.init does not distinguish if process.stdin is a file or TTY | |
| // // device, it always assumes it's a TTY device. because of this, we're forcing | |
| // // process.stdin to UTF8 encoding to at least make stdin reading compatible | |
| // // with text files until FS.init can be refactored. | |
| // process['stdin']['setEncoding']('utf8'); | |
| // } | |
| },shutdown:function () { | |
| // https://github.com/kripken/emscripten/pull/1555 | |
| // if (ENVIRONMENT_IS_NODE) { | |
| // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)? | |
| // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation | |
| // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists? | |
| // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle | |
| // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call | |
| // process['stdin']['pause'](); | |
| // } | |
| },register:function (dev, ops) { | |
| TTY.ttys[dev] = { input: [], output: [], ops: ops }; | |
| FS.registerDevice(dev, TTY.stream_ops); | |
| },stream_ops:{open:function (stream) { | |
| var tty = TTY.ttys[stream.node.rdev]; | |
| if (!tty) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENODEV); | |
| } | |
| stream.tty = tty; | |
| stream.seekable = false; | |
| },close:function (stream) { | |
| // flush any pending line data | |
| stream.tty.ops.flush(stream.tty); | |
| },flush:function (stream) { | |
| stream.tty.ops.flush(stream.tty); | |
| },read:function (stream, buffer, offset, length, pos /* ignored */) { | |
| if (!stream.tty || !stream.tty.ops.get_char) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENXIO); | |
| } | |
| var bytesRead = 0; | |
| for (var i = 0; i < length; i++) { | |
| var result; | |
| try { | |
| result = stream.tty.ops.get_char(stream.tty); | |
| } catch (e) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EIO); | |
| } | |
| if (result === undefined && bytesRead === 0) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EAGAIN); | |
| } | |
| if (result === null || result === undefined) break; | |
| bytesRead++; | |
| buffer[offset+i] = result; | |
| } | |
| if (bytesRead) { | |
| stream.node.timestamp = Date.now(); | |
| } | |
| return bytesRead; | |
| },write:function (stream, buffer, offset, length, pos) { | |
| if (!stream.tty || !stream.tty.ops.put_char) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENXIO); | |
| } | |
| for (var i = 0; i < length; i++) { | |
| try { | |
| stream.tty.ops.put_char(stream.tty, buffer[offset+i]); | |
| } catch (e) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EIO); | |
| } | |
| } | |
| if (length) { | |
| stream.node.timestamp = Date.now(); | |
| } | |
| return i; | |
| }},default_tty_ops:{get_char:function (tty) { | |
| if (!tty.input.length) { | |
| var result = null; | |
| if (ENVIRONMENT_IS_NODE) { | |
| // we will read data by chunks of BUFSIZE | |
| var BUFSIZE = 256; | |
| var buf = new Buffer(BUFSIZE); | |
| var bytesRead = 0; | |
| var fd = process.stdin.fd; | |
| // Linux and Mac cannot use process.stdin.fd (which isn't set up as sync) | |
| var usingDevice = false; | |
| try { | |
| fd = fs.openSync('/dev/stdin', 'r'); | |
| usingDevice = true; | |
| } catch (e) {} | |
| bytesRead = fs.readSync(fd, buf, 0, BUFSIZE, null); | |
| if (usingDevice) { fs.closeSync(fd); } | |
| if (bytesRead > 0) { | |
| result = buf.slice(0, bytesRead).toString('utf-8'); | |
| } else { | |
| result = null; | |
| } | |
| } else if (typeof window != 'undefined' && | |
| typeof window.prompt == 'function') { | |
| // Browser. | |
| result = window.prompt('Input: '); // returns null on cancel | |
| if (result !== null) { | |
| result += '\n'; | |
| } | |
| } else if (typeof readline == 'function') { | |
| // Command line. | |
| result = readline(); | |
| if (result !== null) { | |
| result += '\n'; | |
| } | |
| } | |
| if (!result) { | |
| return null; | |
| } | |
| tty.input = intArrayFromString(result, true); | |
| } | |
| return tty.input.shift(); | |
| },put_char:function (tty, val) { | |
| if (val === null || val === 10) { | |
| Module['print'](UTF8ArrayToString(tty.output, 0)); | |
| tty.output = []; | |
| } else { | |
| if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle. | |
| } | |
| },flush:function (tty) { | |
| if (tty.output && tty.output.length > 0) { | |
| Module['print'](UTF8ArrayToString(tty.output, 0)); | |
| tty.output = []; | |
| } | |
| }},default_tty1_ops:{put_char:function (tty, val) { | |
| if (val === null || val === 10) { | |
| Module['printErr'](UTF8ArrayToString(tty.output, 0)); | |
| tty.output = []; | |
| } else { | |
| if (val != 0) tty.output.push(val); | |
| } | |
| },flush:function (tty) { | |
| if (tty.output && tty.output.length > 0) { | |
| Module['printErr'](UTF8ArrayToString(tty.output, 0)); | |
| tty.output = []; | |
| } | |
| }}}; | |
| var MEMFS={ops_table:null,mount:function (mount) { | |
| return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0); | |
| },createNode:function (parent, name, mode, dev) { | |
| if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { | |
| // no supported | |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); | |
| } | |
| if (!MEMFS.ops_table) { | |
| MEMFS.ops_table = { | |
| dir: { | |
| node: { | |
| getattr: MEMFS.node_ops.getattr, | |
| setattr: MEMFS.node_ops.setattr, | |
| lookup: MEMFS.node_ops.lookup, | |
| mknod: MEMFS.node_ops.mknod, | |
| rename: MEMFS.node_ops.rename, | |
| unlink: MEMFS.node_ops.unlink, | |
| rmdir: MEMFS.node_ops.rmdir, | |
| readdir: MEMFS.node_ops.readdir, | |
| symlink: MEMFS.node_ops.symlink | |
| }, | |
| stream: { | |
| llseek: MEMFS.stream_ops.llseek | |
| } | |
| }, | |
| file: { | |
| node: { | |
| getattr: MEMFS.node_ops.getattr, | |
| setattr: MEMFS.node_ops.setattr | |
| }, | |
| stream: { | |
| llseek: MEMFS.stream_ops.llseek, | |
| read: MEMFS.stream_ops.read, | |
| write: MEMFS.stream_ops.write, | |
| allocate: MEMFS.stream_ops.allocate, | |
| mmap: MEMFS.stream_ops.mmap, | |
| msync: MEMFS.stream_ops.msync | |
| } | |
| }, | |
| link: { | |
| node: { | |
| getattr: MEMFS.node_ops.getattr, | |
| setattr: MEMFS.node_ops.setattr, | |
| readlink: MEMFS.node_ops.readlink | |
| }, | |
| stream: {} | |
| }, | |
| chrdev: { | |
| node: { | |
| getattr: MEMFS.node_ops.getattr, | |
| setattr: MEMFS.node_ops.setattr | |
| }, | |
| stream: FS.chrdev_stream_ops | |
| } | |
| }; | |
| } | |
| var node = FS.createNode(parent, name, mode, dev); | |
| if (FS.isDir(node.mode)) { | |
| node.node_ops = MEMFS.ops_table.dir.node; | |
| node.stream_ops = MEMFS.ops_table.dir.stream; | |
| node.contents = {}; | |
| } else if (FS.isFile(node.mode)) { | |
| node.node_ops = MEMFS.ops_table.file.node; | |
| node.stream_ops = MEMFS.ops_table.file.stream; | |
| node.usedBytes = 0; // The actual number of bytes used in the typed array, as opposed to contents.buffer.byteLength which gives the whole capacity. | |
| // When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred | |
| // for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size | |
| // penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme. | |
| node.contents = null; | |
| } else if (FS.isLink(node.mode)) { | |
| node.node_ops = MEMFS.ops_table.link.node; | |
| node.stream_ops = MEMFS.ops_table.link.stream; | |
| } else if (FS.isChrdev(node.mode)) { | |
| node.node_ops = MEMFS.ops_table.chrdev.node; | |
| node.stream_ops = MEMFS.ops_table.chrdev.stream; | |
| } | |
| node.timestamp = Date.now(); | |
| // add the new node to the parent | |
| if (parent) { | |
| parent.contents[name] = node; | |
| } | |
| return node; | |
| },getFileDataAsRegularArray:function (node) { | |
| if (node.contents && node.contents.subarray) { | |
| var arr = []; | |
| for (var i = 0; i < node.usedBytes; ++i) arr.push(node.contents[i]); | |
| return arr; // Returns a copy of the original data. | |
| } | |
| return node.contents; // No-op, the file contents are already in a JS array. Return as-is. | |
| },getFileDataAsTypedArray:function (node) { | |
| if (!node.contents) return new Uint8Array; | |
| if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); // Make sure to not return excess unused bytes. | |
| return new Uint8Array(node.contents); | |
| },expandFileStorage:function (node, newCapacity) { | |
| // If we are asked to expand the size of a file that already exists, revert to using a standard JS array to store the file | |
| // instead of a typed array. This makes resizing the array more flexible because we can just .push() elements at the back to | |
| // increase the size. | |
| if (node.contents && node.contents.subarray && newCapacity > node.contents.length) { | |
| node.contents = MEMFS.getFileDataAsRegularArray(node); | |
| node.usedBytes = node.contents.length; // We might be writing to a lazy-loaded file which had overridden this property, so force-reset it. | |
| } | |
| if (!node.contents || node.contents.subarray) { // Keep using a typed array if creating a new storage, or if old one was a typed array as well. | |
| var prevCapacity = node.contents ? node.contents.buffer.byteLength : 0; | |
| if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough. | |
| // Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity. | |
| // For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to | |
| // avoid overshooting the allocation cap by a very large margin. | |
| var CAPACITY_DOUBLING_MAX = 1024 * 1024; | |
| newCapacity = Math.max(newCapacity, (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) | 0); | |
| if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding. | |
| var oldContents = node.contents; | |
| node.contents = new Uint8Array(newCapacity); // Allocate new storage. | |
| if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage. | |
| return; | |
| } | |
| // Not using a typed array to back the file storage. Use a standard JS array instead. | |
| if (!node.contents && newCapacity > 0) node.contents = []; | |
| while (node.contents.length < newCapacity) node.contents.push(0); | |
| },resizeFileStorage:function (node, newSize) { | |
| if (node.usedBytes == newSize) return; | |
| if (newSize == 0) { | |
| node.contents = null; // Fully decommit when requesting a resize to zero. | |
| node.usedBytes = 0; | |
| return; | |
| } | |
| if (!node.contents || node.contents.subarray) { // Resize a typed array if that is being used as the backing store. | |
| var oldContents = node.contents; | |
| node.contents = new Uint8Array(new ArrayBuffer(newSize)); // Allocate new storage. | |
| if (oldContents) { | |
| node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))); // Copy old data over to the new storage. | |
| } | |
| node.usedBytes = newSize; | |
| return; | |
| } | |
| // Backing with a JS array. | |
| if (!node.contents) node.contents = []; | |
| if (node.contents.length > newSize) node.contents.length = newSize; | |
| else while (node.contents.length < newSize) node.contents.push(0); | |
| node.usedBytes = newSize; | |
| },node_ops:{getattr:function (node) { | |
| var attr = {}; | |
| // device numbers reuse inode numbers. | |
| attr.dev = FS.isChrdev(node.mode) ? node.id : 1; | |
| attr.ino = node.id; | |
| attr.mode = node.mode; | |
| attr.nlink = 1; | |
| attr.uid = 0; | |
| attr.gid = 0; | |
| attr.rdev = node.rdev; | |
| if (FS.isDir(node.mode)) { | |
| attr.size = 4096; | |
| } else if (FS.isFile(node.mode)) { | |
| attr.size = node.usedBytes; | |
| } else if (FS.isLink(node.mode)) { | |
| attr.size = node.link.length; | |
| } else { | |
| attr.size = 0; | |
| } | |
| attr.atime = new Date(node.timestamp); | |
| attr.mtime = new Date(node.timestamp); | |
| attr.ctime = new Date(node.timestamp); | |
| // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize), | |
| // but this is not required by the standard. | |
| attr.blksize = 4096; | |
| attr.blocks = Math.ceil(attr.size / attr.blksize); | |
| return attr; | |
| },setattr:function (node, attr) { | |
| if (attr.mode !== undefined) { | |
| node.mode = attr.mode; | |
| } | |
| if (attr.timestamp !== undefined) { | |
| node.timestamp = attr.timestamp; | |
| } | |
| if (attr.size !== undefined) { | |
| MEMFS.resizeFileStorage(node, attr.size); | |
| } | |
| },lookup:function (parent, name) { | |
| throw FS.genericErrors[ERRNO_CODES.ENOENT]; | |
| },mknod:function (parent, name, mode, dev) { | |
| return MEMFS.createNode(parent, name, mode, dev); | |
| },rename:function (old_node, new_dir, new_name) { | |
| // if we're overwriting a directory at new_name, make sure it's empty. | |
| if (FS.isDir(old_node.mode)) { | |
| var new_node; | |
| try { | |
| new_node = FS.lookupNode(new_dir, new_name); | |
| } catch (e) { | |
| } | |
| if (new_node) { | |
| for (var i in new_node.contents) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY); | |
| } | |
| } | |
| } | |
| // do the internal rewiring | |
| delete old_node.parent.contents[old_node.name]; | |
| old_node.name = new_name; | |
| new_dir.contents[new_name] = old_node; | |
| old_node.parent = new_dir; | |
| },unlink:function (parent, name) { | |
| delete parent.contents[name]; | |
| },rmdir:function (parent, name) { | |
| var node = FS.lookupNode(parent, name); | |
| for (var i in node.contents) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY); | |
| } | |
| delete parent.contents[name]; | |
| },readdir:function (node) { | |
| var entries = ['.', '..'] | |
| for (var key in node.contents) { | |
| if (!node.contents.hasOwnProperty(key)) { | |
| continue; | |
| } | |
| entries.push(key); | |
| } | |
| return entries; | |
| },symlink:function (parent, newname, oldpath) { | |
| var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 40960, 0); | |
| node.link = oldpath; | |
| return node; | |
| },readlink:function (node) { | |
| if (!FS.isLink(node.mode)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| return node.link; | |
| }},stream_ops:{read:function (stream, buffer, offset, length, position) { | |
| var contents = stream.node.contents; | |
| if (position >= stream.node.usedBytes) return 0; | |
| var size = Math.min(stream.node.usedBytes - position, length); | |
| assert(size >= 0); | |
| if (size > 8 && contents.subarray) { // non-trivial, and typed array | |
| buffer.set(contents.subarray(position, position + size), offset); | |
| } else | |
| { | |
| for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]; | |
| } | |
| return size; | |
| },write:function (stream, buffer, offset, length, position, canOwn) { | |
| if (!length) return 0; | |
| var node = stream.node; | |
| node.timestamp = Date.now(); | |
| if (buffer.subarray && (!node.contents || node.contents.subarray)) { // This write is from a typed array to a typed array? | |
| if (canOwn) { // Can we just reuse the buffer we are given? | |
| assert(position === 0, 'canOwn must imply no weird position inside the file'); | |
| node.contents = buffer.subarray(offset, offset + length); | |
| node.usedBytes = length; | |
| return length; | |
| } else if (node.usedBytes === 0 && position === 0) { // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data. | |
| node.contents = new Uint8Array(buffer.subarray(offset, offset + length)); | |
| node.usedBytes = length; | |
| return length; | |
| } else if (position + length <= node.usedBytes) { // Writing to an already allocated and used subrange of the file? | |
| node.contents.set(buffer.subarray(offset, offset + length), position); | |
| return length; | |
| } | |
| } | |
| // Appending to an existing file and we need to reallocate, or source data did not come as a typed array. | |
| MEMFS.expandFileStorage(node, position+length); | |
| if (node.contents.subarray && buffer.subarray) node.contents.set(buffer.subarray(offset, offset + length), position); // Use typed array write if available. | |
| else | |
| for (var i = 0; i < length; i++) { | |
| node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not. | |
| } | |
| node.usedBytes = Math.max(node.usedBytes, position+length); | |
| return length; | |
| },llseek:function (stream, offset, whence) { | |
| var position = offset; | |
| if (whence === 1) { // SEEK_CUR. | |
| position += stream.position; | |
| } else if (whence === 2) { // SEEK_END. | |
| if (FS.isFile(stream.node.mode)) { | |
| position += stream.node.usedBytes; | |
| } | |
| } | |
| if (position < 0) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| return position; | |
| },allocate:function (stream, offset, length) { | |
| MEMFS.expandFileStorage(stream.node, offset + length); | |
| stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length); | |
| },mmap:function (stream, buffer, offset, length, position, prot, flags) { | |
| if (!FS.isFile(stream.node.mode)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENODEV); | |
| } | |
| var ptr; | |
| var allocated; | |
| var contents = stream.node.contents; | |
| // Only make a new copy when MAP_PRIVATE is specified. | |
| if ( !(flags & 2) && | |
| (contents.buffer === buffer || contents.buffer === buffer.buffer) ) { | |
| // We can't emulate MAP_SHARED when the file is not backed by the buffer | |
| // we're mapping to (e.g. the HEAP buffer). | |
| allocated = false; | |
| ptr = contents.byteOffset; | |
| } else { | |
| // Try to avoid unnecessary slices. | |
| if (position > 0 || position + length < stream.node.usedBytes) { | |
| if (contents.subarray) { | |
| contents = contents.subarray(position, position + length); | |
| } else { | |
| contents = Array.prototype.slice.call(contents, position, position + length); | |
| } | |
| } | |
| allocated = true; | |
| ptr = _malloc(length); | |
| if (!ptr) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOMEM); | |
| } | |
| buffer.set(contents, ptr); | |
| } | |
| return { ptr: ptr, allocated: allocated }; | |
| },msync:function (stream, buffer, offset, length, mmapFlags) { | |
| if (!FS.isFile(stream.node.mode)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENODEV); | |
| } | |
| if (mmapFlags & 2) { | |
| // MAP_PRIVATE calls need not to be synced back to underlying fs | |
| return 0; | |
| } | |
| var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); | |
| // should we check if bytesWritten and length are the same? | |
| return 0; | |
| }}}; | |
| var IDBFS={dbs:{},indexedDB:function () { | |
| if (typeof indexedDB !== 'undefined') return indexedDB; | |
| var ret = null; | |
| if (typeof window === 'object') ret = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; | |
| assert(ret, 'IDBFS used, but indexedDB not supported'); | |
| return ret; | |
| },DB_VERSION:21,DB_STORE_NAME:"FILE_DATA",mount:function (mount) { | |
| // reuse all of the core MEMFS functionality | |
| return MEMFS.mount.apply(null, arguments); | |
| },syncfs:function (mount, populate, callback) { | |
| IDBFS.getLocalSet(mount, function(err, local) { | |
| if (err) return callback(err); | |
| IDBFS.getRemoteSet(mount, function(err, remote) { | |
| if (err) return callback(err); | |
| var src = populate ? remote : local; | |
| var dst = populate ? local : remote; | |
| IDBFS.reconcile(src, dst, callback); | |
| }); | |
| }); | |
| },getDB:function (name, callback) { | |
| // check the cache first | |
| var db = IDBFS.dbs[name]; | |
| if (db) { | |
| return callback(null, db); | |
| } | |
| var req; | |
| try { | |
| req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION); | |
| } catch (e) { | |
| return callback(e); | |
| } | |
| req.onupgradeneeded = function(e) { | |
| var db = e.target.result; | |
| var transaction = e.target.transaction; | |
| var fileStore; | |
| if (db.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) { | |
| fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME); | |
| } else { | |
| fileStore = db.createObjectStore(IDBFS.DB_STORE_NAME); | |
| } | |
| if (!fileStore.indexNames.contains('timestamp')) { | |
| fileStore.createIndex('timestamp', 'timestamp', { unique: false }); | |
| } | |
| }; | |
| req.onsuccess = function() { | |
| db = req.result; | |
| // add to the cache | |
| IDBFS.dbs[name] = db; | |
| callback(null, db); | |
| }; | |
| req.onerror = function(e) { | |
| callback(this.error); | |
| e.preventDefault(); | |
| }; | |
| },getLocalSet:function (mount, callback) { | |
| var entries = {}; | |
| function isRealDir(p) { | |
| return p !== '.' && p !== '..'; | |
| }; | |
| function toAbsolute(root) { | |
| return function(p) { | |
| return PATH.join2(root, p); | |
| } | |
| }; | |
| var check = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint)); | |
| while (check.length) { | |
| var path = check.pop(); | |
| var stat; | |
| try { | |
| stat = FS.stat(path); | |
| } catch (e) { | |
| return callback(e); | |
| } | |
| if (FS.isDir(stat.mode)) { | |
| check.push.apply(check, FS.readdir(path).filter(isRealDir).map(toAbsolute(path))); | |
| } | |
| entries[path] = { timestamp: stat.mtime }; | |
| } | |
| return callback(null, { type: 'local', entries: entries }); | |
| },getRemoteSet:function (mount, callback) { | |
| var entries = {}; | |
| IDBFS.getDB(mount.mountpoint, function(err, db) { | |
| if (err) return callback(err); | |
| var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly'); | |
| transaction.onerror = function(e) { | |
| callback(this.error); | |
| e.preventDefault(); | |
| }; | |
| var store = transaction.objectStore(IDBFS.DB_STORE_NAME); | |
| var index = store.index('timestamp'); | |
| index.openKeyCursor().onsuccess = function(event) { | |
| var cursor = event.target.result; | |
| if (!cursor) { | |
| return callback(null, { type: 'remote', db: db, entries: entries }); | |
| } | |
| entries[cursor.primaryKey] = { timestamp: cursor.key }; | |
| cursor.continue(); | |
| }; | |
| }); | |
| },loadLocalEntry:function (path, callback) { | |
| var stat, node; | |
| try { | |
| var lookup = FS.lookupPath(path); | |
| node = lookup.node; | |
| stat = FS.stat(path); | |
| } catch (e) { | |
| return callback(e); | |
| } | |
| if (FS.isDir(stat.mode)) { | |
| return callback(null, { timestamp: stat.mtime, mode: stat.mode }); | |
| } else if (FS.isFile(stat.mode)) { | |
| // Performance consideration: storing a normal JavaScript array to a IndexedDB is much slower than storing a typed array. | |
| // Therefore always convert the file contents to a typed array first before writing the data to IndexedDB. | |
| node.contents = MEMFS.getFileDataAsTypedArray(node); | |
| return callback(null, { timestamp: stat.mtime, mode: stat.mode, contents: node.contents }); | |
| } else { | |
| return callback(new Error('node type not supported')); | |
| } | |
| },storeLocalEntry:function (path, entry, callback) { | |
| try { | |
| if (FS.isDir(entry.mode)) { | |
| FS.mkdir(path, entry.mode); | |
| } else if (FS.isFile(entry.mode)) { | |
| FS.writeFile(path, entry.contents, { encoding: 'binary', canOwn: true }); | |
| } else { | |
| return callback(new Error('node type not supported')); | |
| } | |
| FS.chmod(path, entry.mode); | |
| FS.utime(path, entry.timestamp, entry.timestamp); | |
| } catch (e) { | |
| return callback(e); | |
| } | |
| callback(null); | |
| },removeLocalEntry:function (path, callback) { | |
| try { | |
| var lookup = FS.lookupPath(path); | |
| var stat = FS.stat(path); | |
| if (FS.isDir(stat.mode)) { | |
| FS.rmdir(path); | |
| } else if (FS.isFile(stat.mode)) { | |
| FS.unlink(path); | |
| } | |
| } catch (e) { | |
| return callback(e); | |
| } | |
| callback(null); | |
| },loadRemoteEntry:function (store, path, callback) { | |
| var req = store.get(path); | |
| req.onsuccess = function(event) { callback(null, event.target.result); }; | |
| req.onerror = function(e) { | |
| callback(this.error); | |
| e.preventDefault(); | |
| }; | |
| },storeRemoteEntry:function (store, path, entry, callback) { | |
| var req = store.put(entry, path); | |
| req.onsuccess = function() { callback(null); }; | |
| req.onerror = function(e) { | |
| callback(this.error); | |
| e.preventDefault(); | |
| }; | |
| },removeRemoteEntry:function (store, path, callback) { | |
| var req = store.delete(path); | |
| req.onsuccess = function() { callback(null); }; | |
| req.onerror = function(e) { | |
| callback(this.error); | |
| e.preventDefault(); | |
| }; | |
| },reconcile:function (src, dst, callback) { | |
| var total = 0; | |
| var create = []; | |
| Object.keys(src.entries).forEach(function (key) { | |
| var e = src.entries[key]; | |
| var e2 = dst.entries[key]; | |
| if (!e2 || e.timestamp > e2.timestamp) { | |
| create.push(key); | |
| total++; | |
| } | |
| }); | |
| var remove = []; | |
| Object.keys(dst.entries).forEach(function (key) { | |
| var e = dst.entries[key]; | |
| var e2 = src.entries[key]; | |
| if (!e2) { | |
| remove.push(key); | |
| total++; | |
| } | |
| }); | |
| if (!total) { | |
| return callback(null); | |
| } | |
| var errored = false; | |
| var completed = 0; | |
| var db = src.type === 'remote' ? src.db : dst.db; | |
| var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite'); | |
| var store = transaction.objectStore(IDBFS.DB_STORE_NAME); | |
| function done(err) { | |
| if (err) { | |
| if (!done.errored) { | |
| done.errored = true; | |
| return callback(err); | |
| } | |
| return; | |
| } | |
| if (++completed >= total) { | |
| return callback(null); | |
| } | |
| }; | |
| transaction.onerror = function(e) { | |
| done(this.error); | |
| e.preventDefault(); | |
| }; | |
| // sort paths in ascending order so directory entries are created | |
| // before the files inside them | |
| create.sort().forEach(function (path) { | |
| if (dst.type === 'local') { | |
| IDBFS.loadRemoteEntry(store, path, function (err, entry) { | |
| if (err) return done(err); | |
| IDBFS.storeLocalEntry(path, entry, done); | |
| }); | |
| } else { | |
| IDBFS.loadLocalEntry(path, function (err, entry) { | |
| if (err) return done(err); | |
| IDBFS.storeRemoteEntry(store, path, entry, done); | |
| }); | |
| } | |
| }); | |
| // sort paths in descending order so files are deleted before their | |
| // parent directories | |
| remove.sort().reverse().forEach(function(path) { | |
| if (dst.type === 'local') { | |
| IDBFS.removeLocalEntry(path, done); | |
| } else { | |
| IDBFS.removeRemoteEntry(store, path, done); | |
| } | |
| }); | |
| }}; | |
| var NODEFS={isWindows:false,staticInit:function () { | |
| NODEFS.isWindows = !!process.platform.match(/^win/); | |
| },mount:function (mount) { | |
| assert(ENVIRONMENT_IS_NODE); | |
| return NODEFS.createNode(null, '/', NODEFS.getMode(mount.opts.root), 0); | |
| },createNode:function (parent, name, mode, dev) { | |
| if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| var node = FS.createNode(parent, name, mode); | |
| node.node_ops = NODEFS.node_ops; | |
| node.stream_ops = NODEFS.stream_ops; | |
| return node; | |
| },getMode:function (path) { | |
| var stat; | |
| try { | |
| stat = fs.lstatSync(path); | |
| if (NODEFS.isWindows) { | |
| // On Windows, directories return permission bits 'rw-rw-rw-', even though they have 'rwxrwxrwx', so | |
| // propagate write bits to execute bits. | |
| stat.mode = stat.mode | ((stat.mode & 146) >> 1); | |
| } | |
| } catch (e) { | |
| if (!e.code) throw e; | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| return stat.mode; | |
| },realPath:function (node) { | |
| var parts = []; | |
| while (node.parent !== node) { | |
| parts.push(node.name); | |
| node = node.parent; | |
| } | |
| parts.push(node.mount.opts.root); | |
| parts.reverse(); | |
| return PATH.join.apply(null, parts); | |
| },flagsToPermissionStringMap:{0:"r",1:"r+",2:"r+",64:"r",65:"r+",66:"r+",129:"rx+",193:"rx+",514:"w+",577:"w",578:"w+",705:"wx",706:"wx+",1024:"a",1025:"a",1026:"a+",1089:"a",1090:"a+",1153:"ax",1154:"ax+",1217:"ax",1218:"ax+",4096:"rs",4098:"rs+"},flagsToPermissionString:function (flags) { | |
| if (flags in NODEFS.flagsToPermissionStringMap) { | |
| return NODEFS.flagsToPermissionStringMap[flags]; | |
| } else { | |
| return flags; | |
| } | |
| },node_ops:{getattr:function (node) { | |
| var path = NODEFS.realPath(node); | |
| var stat; | |
| try { | |
| stat = fs.lstatSync(path); | |
| } catch (e) { | |
| if (!e.code) throw e; | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake them with default blksize of 4096. | |
| // See http://support.microsoft.com/kb/140365 | |
| if (NODEFS.isWindows && !stat.blksize) { | |
| stat.blksize = 4096; | |
| } | |
| if (NODEFS.isWindows && !stat.blocks) { | |
| stat.blocks = (stat.size+stat.blksize-1)/stat.blksize|0; | |
| } | |
| return { | |
| dev: stat.dev, | |
| ino: stat.ino, | |
| mode: stat.mode, | |
| nlink: stat.nlink, | |
| uid: stat.uid, | |
| gid: stat.gid, | |
| rdev: stat.rdev, | |
| size: stat.size, | |
| atime: stat.atime, | |
| mtime: stat.mtime, | |
| ctime: stat.ctime, | |
| blksize: stat.blksize, | |
| blocks: stat.blocks | |
| }; | |
| },setattr:function (node, attr) { | |
| var path = NODEFS.realPath(node); | |
| try { | |
| if (attr.mode !== undefined) { | |
| fs.chmodSync(path, attr.mode); | |
| // update the common node structure mode as well | |
| node.mode = attr.mode; | |
| } | |
| if (attr.timestamp !== undefined) { | |
| var date = new Date(attr.timestamp); | |
| fs.utimesSync(path, date, date); | |
| } | |
| if (attr.size !== undefined) { | |
| fs.truncateSync(path, attr.size); | |
| } | |
| } catch (e) { | |
| if (!e.code) throw e; | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| },lookup:function (parent, name) { | |
| var path = PATH.join2(NODEFS.realPath(parent), name); | |
| var mode = NODEFS.getMode(path); | |
| return NODEFS.createNode(parent, name, mode); | |
| },mknod:function (parent, name, mode, dev) { | |
| var node = NODEFS.createNode(parent, name, mode, dev); | |
| // create the backing node for this in the fs root as well | |
| var path = NODEFS.realPath(node); | |
| try { | |
| if (FS.isDir(node.mode)) { | |
| fs.mkdirSync(path, node.mode); | |
| } else { | |
| fs.writeFileSync(path, '', { mode: node.mode }); | |
| } | |
| } catch (e) { | |
| if (!e.code) throw e; | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| return node; | |
| },rename:function (oldNode, newDir, newName) { | |
| var oldPath = NODEFS.realPath(oldNode); | |
| var newPath = PATH.join2(NODEFS.realPath(newDir), newName); | |
| try { | |
| fs.renameSync(oldPath, newPath); | |
| } catch (e) { | |
| if (!e.code) throw e; | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| },unlink:function (parent, name) { | |
| var path = PATH.join2(NODEFS.realPath(parent), name); | |
| try { | |
| fs.unlinkSync(path); | |
| } catch (e) { | |
| if (!e.code) throw e; | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| },rmdir:function (parent, name) { | |
| var path = PATH.join2(NODEFS.realPath(parent), name); | |
| try { | |
| fs.rmdirSync(path); | |
| } catch (e) { | |
| if (!e.code) throw e; | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| },readdir:function (node) { | |
| var path = NODEFS.realPath(node); | |
| try { | |
| return fs.readdirSync(path); | |
| } catch (e) { | |
| if (!e.code) throw e; | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| },symlink:function (parent, newName, oldPath) { | |
| var newPath = PATH.join2(NODEFS.realPath(parent), newName); | |
| try { | |
| fs.symlinkSync(oldPath, newPath); | |
| } catch (e) { | |
| if (!e.code) throw e; | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| },readlink:function (node) { | |
| var path = NODEFS.realPath(node); | |
| try { | |
| path = fs.readlinkSync(path); | |
| path = NODEJS_PATH.relative(NODEJS_PATH.resolve(node.mount.opts.root), path); | |
| return path; | |
| } catch (e) { | |
| if (!e.code) throw e; | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| }},stream_ops:{open:function (stream) { | |
| var path = NODEFS.realPath(stream.node); | |
| try { | |
| if (FS.isFile(stream.node.mode)) { | |
| stream.nfd = fs.openSync(path, NODEFS.flagsToPermissionString(stream.flags)); | |
| } | |
| } catch (e) { | |
| if (!e.code) throw e; | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| },close:function (stream) { | |
| try { | |
| if (FS.isFile(stream.node.mode) && stream.nfd) { | |
| fs.closeSync(stream.nfd); | |
| } | |
| } catch (e) { | |
| if (!e.code) throw e; | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| },read:function (stream, buffer, offset, length, position) { | |
| if (length === 0) return 0; // node errors on 0 length reads | |
| // FIXME this is terrible. | |
| var nbuffer = new Buffer(length); | |
| var res; | |
| try { | |
| res = fs.readSync(stream.nfd, nbuffer, 0, length, position); | |
| } catch (e) { | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| if (res > 0) { | |
| for (var i = 0; i < res; i++) { | |
| buffer[offset + i] = nbuffer[i]; | |
| } | |
| } | |
| return res; | |
| },write:function (stream, buffer, offset, length, position) { | |
| // FIXME this is terrible. | |
| var nbuffer = new Buffer(buffer.subarray(offset, offset + length)); | |
| var res; | |
| try { | |
| res = fs.writeSync(stream.nfd, nbuffer, 0, length, position); | |
| } catch (e) { | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| return res; | |
| },llseek:function (stream, offset, whence) { | |
| var position = offset; | |
| if (whence === 1) { // SEEK_CUR. | |
| position += stream.position; | |
| } else if (whence === 2) { // SEEK_END. | |
| if (FS.isFile(stream.node.mode)) { | |
| try { | |
| var stat = fs.fstatSync(stream.nfd); | |
| position += stat.size; | |
| } catch (e) { | |
| throw new FS.ErrnoError(ERRNO_CODES[e.code]); | |
| } | |
| } | |
| } | |
| if (position < 0) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| return position; | |
| }}}; | |
| var _stdin=allocate(1, "i32*", ALLOC_STATIC); | |
| var _stdout=allocate(1, "i32*", ALLOC_STATIC); | |
| var _stderr=allocate(1, "i32*", ALLOC_STATIC); | |
| function _fflush(stream) { | |
| // int fflush(FILE *stream); | |
| // http://pubs.opengroup.org/onlinepubs/000095399/functions/fflush.html | |
| /* | |
| // Disabled, see https://github.com/kripken/emscripten/issues/2770 | |
| stream = FS.getStreamFromPtr(stream); | |
| if (stream.stream_ops.flush) { | |
| stream.stream_ops.flush(stream); | |
| } | |
| */ | |
| }var FS={root:null,mounts:[],devices:[null],streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,trackingDelegate:{},tracking:{openFlags:{READ:1,WRITE:2}},ErrnoError:null,genericErrors:{},handleFSError:function (e) { | |
| if (!(e instanceof FS.ErrnoError)) throw e + ' : ' + stackTrace(); | |
| return ___setErrNo(e.errno); | |
| },lookupPath:function (path, opts) { | |
| path = PATH.resolve(FS.cwd(), path); | |
| opts = opts || {}; | |
| if (!path) return { path: '', node: null }; | |
| var defaults = { | |
| follow_mount: true, | |
| recurse_count: 0 | |
| }; | |
| for (var key in defaults) { | |
| if (opts[key] === undefined) { | |
| opts[key] = defaults[key]; | |
| } | |
| } | |
| if (opts.recurse_count > 8) { // max recursive lookup of 8 | |
| throw new FS.ErrnoError(ERRNO_CODES.ELOOP); | |
| } | |
| // split the path | |
| var parts = PATH.normalizeArray(path.split('/').filter(function(p) { | |
| return !!p; | |
| }), false); | |
| // start at the root | |
| var current = FS.root; | |
| var current_path = '/'; | |
| for (var i = 0; i < parts.length; i++) { | |
| var islast = (i === parts.length-1); | |
| if (islast && opts.parent) { | |
| // stop resolving | |
| break; | |
| } | |
| current = FS.lookupNode(current, parts[i]); | |
| current_path = PATH.join2(current_path, parts[i]); | |
| // jump to the mount's root node if this is a mountpoint | |
| if (FS.isMountpoint(current)) { | |
| if (!islast || (islast && opts.follow_mount)) { | |
| current = current.mounted.root; | |
| } | |
| } | |
| // by default, lookupPath will not follow a symlink if it is the final path component. | |
| // setting opts.follow = true will override this behavior. | |
| if (!islast || opts.follow) { | |
| var count = 0; | |
| while (FS.isLink(current.mode)) { | |
| var link = FS.readlink(current_path); | |
| current_path = PATH.resolve(PATH.dirname(current_path), link); | |
| var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count }); | |
| current = lookup.node; | |
| if (count++ > 40) { // limit max consecutive symlinks to 40 (SYMLOOP_MAX). | |
| throw new FS.ErrnoError(ERRNO_CODES.ELOOP); | |
| } | |
| } | |
| } | |
| } | |
| return { path: current_path, node: current }; | |
| },getPath:function (node) { | |
| var path; | |
| while (true) { | |
| if (FS.isRoot(node)) { | |
| var mount = node.mount.mountpoint; | |
| if (!path) return mount; | |
| return mount[mount.length-1] !== '/' ? mount + '/' + path : mount + path; | |
| } | |
| path = path ? node.name + '/' + path : node.name; | |
| node = node.parent; | |
| } | |
| },hashName:function (parentid, name) { | |
| var hash = 0; | |
| for (var i = 0; i < name.length; i++) { | |
| hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0; | |
| } | |
| return ((parentid + hash) >>> 0) % FS.nameTable.length; | |
| },hashAddNode:function (node) { | |
| var hash = FS.hashName(node.parent.id, node.name); | |
| node.name_next = FS.nameTable[hash]; | |
| FS.nameTable[hash] = node; | |
| },hashRemoveNode:function (node) { | |
| var hash = FS.hashName(node.parent.id, node.name); | |
| if (FS.nameTable[hash] === node) { | |
| FS.nameTable[hash] = node.name_next; | |
| } else { | |
| var current = FS.nameTable[hash]; | |
| while (current) { | |
| if (current.name_next === node) { | |
| current.name_next = node.name_next; | |
| break; | |
| } | |
| current = current.name_next; | |
| } | |
| } | |
| },lookupNode:function (parent, name) { | |
| var err = FS.mayLookup(parent); | |
| if (err) { | |
| throw new FS.ErrnoError(err, parent); | |
| } | |
| var hash = FS.hashName(parent.id, name); | |
| for (var node = FS.nameTable[hash]; node; node = node.name_next) { | |
| var nodeName = node.name; | |
| if (node.parent.id === parent.id && nodeName === name) { | |
| return node; | |
| } | |
| } | |
| // if we failed to find it in the cache, call into the VFS | |
| return FS.lookup(parent, name); | |
| },createNode:function (parent, name, mode, rdev) { | |
| if (!FS.FSNode) { | |
| FS.FSNode = function(parent, name, mode, rdev) { | |
| if (!parent) { | |
| parent = this; // root node sets parent to itself | |
| } | |
| this.parent = parent; | |
| this.mount = parent.mount; | |
| this.mounted = null; | |
| this.id = FS.nextInode++; | |
| this.name = name; | |
| this.mode = mode; | |
| this.node_ops = {}; | |
| this.stream_ops = {}; | |
| this.rdev = rdev; | |
| }; | |
| FS.FSNode.prototype = {}; | |
| // compatibility | |
| var readMode = 292 | 73; | |
| var writeMode = 146; | |
| // NOTE we must use Object.defineProperties instead of individual calls to | |
| // Object.defineProperty in order to make closure compiler happy | |
| Object.defineProperties(FS.FSNode.prototype, { | |
| read: { | |
| get: function() { return (this.mode & readMode) === readMode; }, | |
| set: function(val) { val ? this.mode |= readMode : this.mode &= ~readMode; } | |
| }, | |
| write: { | |
| get: function() { return (this.mode & writeMode) === writeMode; }, | |
| set: function(val) { val ? this.mode |= writeMode : this.mode &= ~writeMode; } | |
| }, | |
| isFolder: { | |
| get: function() { return FS.isDir(this.mode); } | |
| }, | |
| isDevice: { | |
| get: function() { return FS.isChrdev(this.mode); } | |
| } | |
| }); | |
| } | |
| var node = new FS.FSNode(parent, name, mode, rdev); | |
| FS.hashAddNode(node); | |
| return node; | |
| },destroyNode:function (node) { | |
| FS.hashRemoveNode(node); | |
| },isRoot:function (node) { | |
| return node === node.parent; | |
| },isMountpoint:function (node) { | |
| return !!node.mounted; | |
| },isFile:function (mode) { | |
| return (mode & 61440) === 32768; | |
| },isDir:function (mode) { | |
| return (mode & 61440) === 16384; | |
| },isLink:function (mode) { | |
| return (mode & 61440) === 40960; | |
| },isChrdev:function (mode) { | |
| return (mode & 61440) === 8192; | |
| },isBlkdev:function (mode) { | |
| return (mode & 61440) === 24576; | |
| },isFIFO:function (mode) { | |
| return (mode & 61440) === 4096; | |
| },isSocket:function (mode) { | |
| return (mode & 49152) === 49152; | |
| },flagModes:{"r":0,"rs":1052672,"r+":2,"w":577,"wx":705,"xw":705,"w+":578,"wx+":706,"xw+":706,"a":1089,"ax":1217,"xa":1217,"a+":1090,"ax+":1218,"xa+":1218},modeStringToFlags:function (str) { | |
| var flags = FS.flagModes[str]; | |
| if (typeof flags === 'undefined') { | |
| throw new Error('Unknown file open mode: ' + str); | |
| } | |
| return flags; | |
| },flagsToPermissionString:function (flag) { | |
| var accmode = flag & 2097155; | |
| var perms = ['r', 'w', 'rw'][accmode]; | |
| if ((flag & 512)) { | |
| perms += 'w'; | |
| } | |
| return perms; | |
| },nodePermissions:function (node, perms) { | |
| if (FS.ignorePermissions) { | |
| return 0; | |
| } | |
| // return 0 if any user, group or owner bits are set. | |
| if (perms.indexOf('r') !== -1 && !(node.mode & 292)) { | |
| return ERRNO_CODES.EACCES; | |
| } else if (perms.indexOf('w') !== -1 && !(node.mode & 146)) { | |
| return ERRNO_CODES.EACCES; | |
| } else if (perms.indexOf('x') !== -1 && !(node.mode & 73)) { | |
| return ERRNO_CODES.EACCES; | |
| } | |
| return 0; | |
| },mayLookup:function (dir) { | |
| var err = FS.nodePermissions(dir, 'x'); | |
| if (err) return err; | |
| if (!dir.node_ops.lookup) return ERRNO_CODES.EACCES; | |
| return 0; | |
| },mayCreate:function (dir, name) { | |
| try { | |
| var node = FS.lookupNode(dir, name); | |
| return ERRNO_CODES.EEXIST; | |
| } catch (e) { | |
| } | |
| return FS.nodePermissions(dir, 'wx'); | |
| },mayDelete:function (dir, name, isdir) { | |
| var node; | |
| try { | |
| node = FS.lookupNode(dir, name); | |
| } catch (e) { | |
| return e.errno; | |
| } | |
| var err = FS.nodePermissions(dir, 'wx'); | |
| if (err) { | |
| return err; | |
| } | |
| if (isdir) { | |
| if (!FS.isDir(node.mode)) { | |
| return ERRNO_CODES.ENOTDIR; | |
| } | |
| if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { | |
| return ERRNO_CODES.EBUSY; | |
| } | |
| } else { | |
| if (FS.isDir(node.mode)) { | |
| return ERRNO_CODES.EISDIR; | |
| } | |
| } | |
| return 0; | |
| },mayOpen:function (node, flags) { | |
| if (!node) { | |
| return ERRNO_CODES.ENOENT; | |
| } | |
| if (FS.isLink(node.mode)) { | |
| return ERRNO_CODES.ELOOP; | |
| } else if (FS.isDir(node.mode)) { | |
| if ((flags & 2097155) !== 0 || // opening for write | |
| (flags & 512)) { | |
| return ERRNO_CODES.EISDIR; | |
| } | |
| } | |
| return FS.nodePermissions(node, FS.flagsToPermissionString(flags)); | |
| },MAX_OPEN_FDS:4096,nextfd:function (fd_start, fd_end) { | |
| fd_start = fd_start || 0; | |
| fd_end = fd_end || FS.MAX_OPEN_FDS; | |
| for (var fd = fd_start; fd <= fd_end; fd++) { | |
| if (!FS.streams[fd]) { | |
| return fd; | |
| } | |
| } | |
| throw new FS.ErrnoError(ERRNO_CODES.EMFILE); | |
| },getStream:function (fd) { | |
| return FS.streams[fd]; | |
| },createStream:function (stream, fd_start, fd_end) { | |
| if (!FS.FSStream) { | |
| FS.FSStream = function(){}; | |
| FS.FSStream.prototype = {}; | |
| // compatibility | |
| Object.defineProperties(FS.FSStream.prototype, { | |
| object: { | |
| get: function() { return this.node; }, | |
| set: function(val) { this.node = val; } | |
| }, | |
| isRead: { | |
| get: function() { return (this.flags & 2097155) !== 1; } | |
| }, | |
| isWrite: { | |
| get: function() { return (this.flags & 2097155) !== 0; } | |
| }, | |
| isAppend: { | |
| get: function() { return (this.flags & 1024); } | |
| } | |
| }); | |
| } | |
| // clone it, so we can return an instance of FSStream | |
| var newStream = new FS.FSStream(); | |
| for (var p in stream) { | |
| newStream[p] = stream[p]; | |
| } | |
| stream = newStream; | |
| var fd = FS.nextfd(fd_start, fd_end); | |
| stream.fd = fd; | |
| FS.streams[fd] = stream; | |
| return stream; | |
| },closeStream:function (fd) { | |
| FS.streams[fd] = null; | |
| },getStreamFromPtr:function (ptr) { | |
| return FS.streams[ptr - 1]; | |
| },getPtrForStream:function (stream) { | |
| return stream ? stream.fd + 1 : 0; | |
| },chrdev_stream_ops:{open:function (stream) { | |
| var device = FS.getDevice(stream.node.rdev); | |
| // override node's stream ops with the device's | |
| stream.stream_ops = device.stream_ops; | |
| // forward the open call | |
| if (stream.stream_ops.open) { | |
| stream.stream_ops.open(stream); | |
| } | |
| },llseek:function () { | |
| throw new FS.ErrnoError(ERRNO_CODES.ESPIPE); | |
| }},major:function (dev) { | |
| return ((dev) >> 8); | |
| },minor:function (dev) { | |
| return ((dev) & 0xff); | |
| },makedev:function (ma, mi) { | |
| return ((ma) << 8 | (mi)); | |
| },registerDevice:function (dev, ops) { | |
| FS.devices[dev] = { stream_ops: ops }; | |
| },getDevice:function (dev) { | |
| return FS.devices[dev]; | |
| },getMounts:function (mount) { | |
| var mounts = []; | |
| var check = [mount]; | |
| while (check.length) { | |
| var m = check.pop(); | |
| mounts.push(m); | |
| check.push.apply(check, m.mounts); | |
| } | |
| return mounts; | |
| },syncfs:function (populate, callback) { | |
| if (typeof(populate) === 'function') { | |
| callback = populate; | |
| populate = false; | |
| } | |
| var mounts = FS.getMounts(FS.root.mount); | |
| var completed = 0; | |
| function done(err) { | |
| if (err) { | |
| if (!done.errored) { | |
| done.errored = true; | |
| return callback(err); | |
| } | |
| return; | |
| } | |
| if (++completed >= mounts.length) { | |
| callback(null); | |
| } | |
| }; | |
| // sync all mounts | |
| mounts.forEach(function (mount) { | |
| if (!mount.type.syncfs) { | |
| return done(null); | |
| } | |
| mount.type.syncfs(mount, populate, done); | |
| }); | |
| },mount:function (type, opts, mountpoint) { | |
| var root = mountpoint === '/'; | |
| var pseudo = !mountpoint; | |
| var node; | |
| if (root && FS.root) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EBUSY); | |
| } else if (!root && !pseudo) { | |
| var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); | |
| mountpoint = lookup.path; // use the absolute path | |
| node = lookup.node; | |
| if (FS.isMountpoint(node)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EBUSY); | |
| } | |
| if (!FS.isDir(node.mode)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR); | |
| } | |
| } | |
| var mount = { | |
| type: type, | |
| opts: opts, | |
| mountpoint: mountpoint, | |
| mounts: [] | |
| }; | |
| // create a root node for the fs | |
| var mountRoot = type.mount(mount); | |
| mountRoot.mount = mount; | |
| mount.root = mountRoot; | |
| if (root) { | |
| FS.root = mountRoot; | |
| } else if (node) { | |
| // set as a mountpoint | |
| node.mounted = mount; | |
| // add the new mount to the current mount's children | |
| if (node.mount) { | |
| node.mount.mounts.push(mount); | |
| } | |
| } | |
| return mountRoot; | |
| },unmount:function (mountpoint) { | |
| var lookup = FS.lookupPath(mountpoint, { follow_mount: false }); | |
| if (!FS.isMountpoint(lookup.node)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| // destroy the nodes for this mount, and all its child mounts | |
| var node = lookup.node; | |
| var mount = node.mounted; | |
| var mounts = FS.getMounts(mount); | |
| Object.keys(FS.nameTable).forEach(function (hash) { | |
| var current = FS.nameTable[hash]; | |
| while (current) { | |
| var next = current.name_next; | |
| if (mounts.indexOf(current.mount) !== -1) { | |
| FS.destroyNode(current); | |
| } | |
| current = next; | |
| } | |
| }); | |
| // no longer a mountpoint | |
| node.mounted = null; | |
| // remove this mount from the child mounts | |
| var idx = node.mount.mounts.indexOf(mount); | |
| assert(idx !== -1); | |
| node.mount.mounts.splice(idx, 1); | |
| },lookup:function (parent, name) { | |
| return parent.node_ops.lookup(parent, name); | |
| },mknod:function (path, mode, dev) { | |
| var lookup = FS.lookupPath(path, { parent: true }); | |
| var parent = lookup.node; | |
| var name = PATH.basename(path); | |
| if (!name || name === '.' || name === '..') { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| var err = FS.mayCreate(parent, name); | |
| if (err) { | |
| throw new FS.ErrnoError(err); | |
| } | |
| if (!parent.node_ops.mknod) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); | |
| } | |
| return parent.node_ops.mknod(parent, name, mode, dev); | |
| },create:function (path, mode) { | |
| mode = mode !== undefined ? mode : 438 /* 0666 */; | |
| mode &= 4095; | |
| mode |= 32768; | |
| return FS.mknod(path, mode, 0); | |
| },mkdir:function (path, mode) { | |
| mode = mode !== undefined ? mode : 511 /* 0777 */; | |
| mode &= 511 | 512; | |
| mode |= 16384; | |
| return FS.mknod(path, mode, 0); | |
| },mkdev:function (path, mode, dev) { | |
| if (typeof(dev) === 'undefined') { | |
| dev = mode; | |
| mode = 438 /* 0666 */; | |
| } | |
| mode |= 8192; | |
| return FS.mknod(path, mode, dev); | |
| },symlink:function (oldpath, newpath) { | |
| if (!PATH.resolve(oldpath)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOENT); | |
| } | |
| var lookup = FS.lookupPath(newpath, { parent: true }); | |
| var parent = lookup.node; | |
| if (!parent) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOENT); | |
| } | |
| var newname = PATH.basename(newpath); | |
| var err = FS.mayCreate(parent, newname); | |
| if (err) { | |
| throw new FS.ErrnoError(err); | |
| } | |
| if (!parent.node_ops.symlink) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); | |
| } | |
| return parent.node_ops.symlink(parent, newname, oldpath); | |
| },rename:function (old_path, new_path) { | |
| var old_dirname = PATH.dirname(old_path); | |
| var new_dirname = PATH.dirname(new_path); | |
| var old_name = PATH.basename(old_path); | |
| var new_name = PATH.basename(new_path); | |
| // parents must exist | |
| var lookup, old_dir, new_dir; | |
| try { | |
| lookup = FS.lookupPath(old_path, { parent: true }); | |
| old_dir = lookup.node; | |
| lookup = FS.lookupPath(new_path, { parent: true }); | |
| new_dir = lookup.node; | |
| } catch (e) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EBUSY); | |
| } | |
| if (!old_dir || !new_dir) throw new FS.ErrnoError(ERRNO_CODES.ENOENT); | |
| // need to be part of the same mount | |
| if (old_dir.mount !== new_dir.mount) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EXDEV); | |
| } | |
| // source must exist | |
| var old_node = FS.lookupNode(old_dir, old_name); | |
| // old path should not be an ancestor of the new path | |
| var relative = PATH.relative(old_path, new_dirname); | |
| if (relative.charAt(0) !== '.') { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| // new path should not be an ancestor of the old path | |
| relative = PATH.relative(new_path, old_dirname); | |
| if (relative.charAt(0) !== '.') { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY); | |
| } | |
| // see if the new path already exists | |
| var new_node; | |
| try { | |
| new_node = FS.lookupNode(new_dir, new_name); | |
| } catch (e) { | |
| // not fatal | |
| } | |
| // early out if nothing needs to change | |
| if (old_node === new_node) { | |
| return; | |
| } | |
| // we'll need to delete the old entry | |
| var isdir = FS.isDir(old_node.mode); | |
| var err = FS.mayDelete(old_dir, old_name, isdir); | |
| if (err) { | |
| throw new FS.ErrnoError(err); | |
| } | |
| // need delete permissions if we'll be overwriting. | |
| // need create permissions if new doesn't already exist. | |
| err = new_node ? | |
| FS.mayDelete(new_dir, new_name, isdir) : | |
| FS.mayCreate(new_dir, new_name); | |
| if (err) { | |
| throw new FS.ErrnoError(err); | |
| } | |
| if (!old_dir.node_ops.rename) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); | |
| } | |
| if (FS.isMountpoint(old_node) || (new_node && FS.isMountpoint(new_node))) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EBUSY); | |
| } | |
| // if we are going to change the parent, check write permissions | |
| if (new_dir !== old_dir) { | |
| err = FS.nodePermissions(old_dir, 'w'); | |
| if (err) { | |
| throw new FS.ErrnoError(err); | |
| } | |
| } | |
| try { | |
| if (FS.trackingDelegate['willMovePath']) { | |
| FS.trackingDelegate['willMovePath'](old_path, new_path); | |
| } | |
| } catch(e) { | |
| console.log("FS.trackingDelegate['willMovePath']('"+old_path+"', '"+new_path+"') threw an exception: " + e.message); | |
| } | |
| // remove the node from the lookup hash | |
| FS.hashRemoveNode(old_node); | |
| // do the underlying fs rename | |
| try { | |
| old_dir.node_ops.rename(old_node, new_dir, new_name); | |
| } catch (e) { | |
| throw e; | |
| } finally { | |
| // add the node back to the hash (in case node_ops.rename | |
| // changed its name) | |
| FS.hashAddNode(old_node); | |
| } | |
| try { | |
| if (FS.trackingDelegate['onMovePath']) FS.trackingDelegate['onMovePath'](old_path, new_path); | |
| } catch(e) { | |
| console.log("FS.trackingDelegate['onMovePath']('"+old_path+"', '"+new_path+"') threw an exception: " + e.message); | |
| } | |
| },rmdir:function (path) { | |
| var lookup = FS.lookupPath(path, { parent: true }); | |
| var parent = lookup.node; | |
| var name = PATH.basename(path); | |
| var node = FS.lookupNode(parent, name); | |
| var err = FS.mayDelete(parent, name, true); | |
| if (err) { | |
| throw new FS.ErrnoError(err); | |
| } | |
| if (!parent.node_ops.rmdir) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); | |
| } | |
| if (FS.isMountpoint(node)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EBUSY); | |
| } | |
| try { | |
| if (FS.trackingDelegate['willDeletePath']) { | |
| FS.trackingDelegate['willDeletePath'](path); | |
| } | |
| } catch(e) { | |
| console.log("FS.trackingDelegate['willDeletePath']('"+path+"') threw an exception: " + e.message); | |
| } | |
| parent.node_ops.rmdir(parent, name); | |
| FS.destroyNode(node); | |
| try { | |
| if (FS.trackingDelegate['onDeletePath']) FS.trackingDelegate['onDeletePath'](path); | |
| } catch(e) { | |
| console.log("FS.trackingDelegate['onDeletePath']('"+path+"') threw an exception: " + e.message); | |
| } | |
| },readdir:function (path) { | |
| var lookup = FS.lookupPath(path, { follow: true }); | |
| var node = lookup.node; | |
| if (!node.node_ops.readdir) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR); | |
| } | |
| return node.node_ops.readdir(node); | |
| },unlink:function (path) { | |
| var lookup = FS.lookupPath(path, { parent: true }); | |
| var parent = lookup.node; | |
| var name = PATH.basename(path); | |
| var node = FS.lookupNode(parent, name); | |
| var err = FS.mayDelete(parent, name, false); | |
| if (err) { | |
| // POSIX says unlink should set EPERM, not EISDIR | |
| if (err === ERRNO_CODES.EISDIR) err = ERRNO_CODES.EPERM; | |
| throw new FS.ErrnoError(err); | |
| } | |
| if (!parent.node_ops.unlink) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); | |
| } | |
| if (FS.isMountpoint(node)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EBUSY); | |
| } | |
| try { | |
| if (FS.trackingDelegate['willDeletePath']) { | |
| FS.trackingDelegate['willDeletePath'](path); | |
| } | |
| } catch(e) { | |
| console.log("FS.trackingDelegate['willDeletePath']('"+path+"') threw an exception: " + e.message); | |
| } | |
| parent.node_ops.unlink(parent, name); | |
| FS.destroyNode(node); | |
| try { | |
| if (FS.trackingDelegate['onDeletePath']) FS.trackingDelegate['onDeletePath'](path); | |
| } catch(e) { | |
| console.log("FS.trackingDelegate['onDeletePath']('"+path+"') threw an exception: " + e.message); | |
| } | |
| },readlink:function (path) { | |
| var lookup = FS.lookupPath(path); | |
| var link = lookup.node; | |
| if (!link) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOENT); | |
| } | |
| if (!link.node_ops.readlink) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| return PATH.resolve(FS.getPath(lookup.node.parent), link.node_ops.readlink(link)); | |
| },stat:function (path, dontFollow) { | |
| var lookup = FS.lookupPath(path, { follow: !dontFollow }); | |
| var node = lookup.node; | |
| if (!node) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOENT); | |
| } | |
| if (!node.node_ops.getattr) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); | |
| } | |
| return node.node_ops.getattr(node); | |
| },lstat:function (path) { | |
| return FS.stat(path, true); | |
| },chmod:function (path, mode, dontFollow) { | |
| var node; | |
| if (typeof path === 'string') { | |
| var lookup = FS.lookupPath(path, { follow: !dontFollow }); | |
| node = lookup.node; | |
| } else { | |
| node = path; | |
| } | |
| if (!node.node_ops.setattr) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); | |
| } | |
| node.node_ops.setattr(node, { | |
| mode: (mode & 4095) | (node.mode & ~4095), | |
| timestamp: Date.now() | |
| }); | |
| },lchmod:function (path, mode) { | |
| FS.chmod(path, mode, true); | |
| },fchmod:function (fd, mode) { | |
| var stream = FS.getStream(fd); | |
| if (!stream) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EBADF); | |
| } | |
| FS.chmod(stream.node, mode); | |
| },chown:function (path, uid, gid, dontFollow) { | |
| var node; | |
| if (typeof path === 'string') { | |
| var lookup = FS.lookupPath(path, { follow: !dontFollow }); | |
| node = lookup.node; | |
| } else { | |
| node = path; | |
| } | |
| if (!node.node_ops.setattr) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); | |
| } | |
| node.node_ops.setattr(node, { | |
| timestamp: Date.now() | |
| // we ignore the uid / gid for now | |
| }); | |
| },lchown:function (path, uid, gid) { | |
| FS.chown(path, uid, gid, true); | |
| },fchown:function (fd, uid, gid) { | |
| var stream = FS.getStream(fd); | |
| if (!stream) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EBADF); | |
| } | |
| FS.chown(stream.node, uid, gid); | |
| },truncate:function (path, len) { | |
| if (len < 0) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| var node; | |
| if (typeof path === 'string') { | |
| var lookup = FS.lookupPath(path, { follow: true }); | |
| node = lookup.node; | |
| } else { | |
| node = path; | |
| } | |
| if (!node.node_ops.setattr) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EPERM); | |
| } | |
| if (FS.isDir(node.mode)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EISDIR); | |
| } | |
| if (!FS.isFile(node.mode)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| var err = FS.nodePermissions(node, 'w'); | |
| if (err) { | |
| throw new FS.ErrnoError(err); | |
| } | |
| node.node_ops.setattr(node, { | |
| size: len, | |
| timestamp: Date.now() | |
| }); | |
| },ftruncate:function (fd, len) { | |
| var stream = FS.getStream(fd); | |
| if (!stream) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EBADF); | |
| } | |
| if ((stream.flags & 2097155) === 0) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| FS.truncate(stream.node, len); | |
| },utime:function (path, atime, mtime) { | |
| var lookup = FS.lookupPath(path, { follow: true }); | |
| var node = lookup.node; | |
| node.node_ops.setattr(node, { | |
| timestamp: Math.max(atime, mtime) | |
| }); | |
| },open:function (path, flags, mode, fd_start, fd_end) { | |
| if (path === "") { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOENT); | |
| } | |
| flags = typeof flags === 'string' ? FS.modeStringToFlags(flags) : flags; | |
| mode = typeof mode === 'undefined' ? 438 /* 0666 */ : mode; | |
| if ((flags & 64)) { | |
| mode = (mode & 4095) | 32768; | |
| } else { | |
| mode = 0; | |
| } | |
| var node; | |
| if (typeof path === 'object') { | |
| node = path; | |
| } else { | |
| path = PATH.normalize(path); | |
| try { | |
| var lookup = FS.lookupPath(path, { | |
| follow: !(flags & 131072) | |
| }); | |
| node = lookup.node; | |
| } catch (e) { | |
| // ignore | |
| } | |
| } | |
| // perhaps we need to create the node | |
| var created = false; | |
| if ((flags & 64)) { | |
| if (node) { | |
| // if O_CREAT and O_EXCL are set, error out if the node already exists | |
| if ((flags & 128)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EEXIST); | |
| } | |
| } else { | |
| // node doesn't exist, try to create it | |
| node = FS.mknod(path, mode, 0); | |
| created = true; | |
| } | |
| } | |
| if (!node) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOENT); | |
| } | |
| // can't truncate a device | |
| if (FS.isChrdev(node.mode)) { | |
| flags &= ~512; | |
| } | |
| // check permissions, if this is not a file we just created now (it is ok to | |
| // create and write to a file with read-only permissions; it is read-only | |
| // for later use) | |
| if (!created) { | |
| var err = FS.mayOpen(node, flags); | |
| if (err) { | |
| throw new FS.ErrnoError(err); | |
| } | |
| } | |
| // do truncation if necessary | |
| if ((flags & 512)) { | |
| FS.truncate(node, 0); | |
| } | |
| // we've already handled these, don't pass down to the underlying vfs | |
| flags &= ~(128 | 512); | |
| // register the stream with the filesystem | |
| var stream = FS.createStream({ | |
| node: node, | |
| path: FS.getPath(node), // we want the absolute path to the node | |
| flags: flags, | |
| seekable: true, | |
| position: 0, | |
| stream_ops: node.stream_ops, | |
| // used by the file family libc calls (fopen, fwrite, ferror, etc.) | |
| ungotten: [], | |
| error: false | |
| }, fd_start, fd_end); | |
| // call the new stream's open function | |
| if (stream.stream_ops.open) { | |
| stream.stream_ops.open(stream); | |
| } | |
| if (Module['logReadFiles'] && !(flags & 1)) { | |
| if (!FS.readFiles) FS.readFiles = {}; | |
| if (!(path in FS.readFiles)) { | |
| FS.readFiles[path] = 1; | |
| Module['printErr']('read file: ' + path); | |
| } | |
| } | |
| try { | |
| if (FS.trackingDelegate['onOpenFile']) { | |
| var trackingFlags = 0; | |
| if ((flags & 2097155) !== 1) { | |
| trackingFlags |= FS.tracking.openFlags.READ; | |
| } | |
| if ((flags & 2097155) !== 0) { | |
| trackingFlags |= FS.tracking.openFlags.WRITE; | |
| } | |
| FS.trackingDelegate['onOpenFile'](path, trackingFlags); | |
| } | |
| } catch(e) { | |
| console.log("FS.trackingDelegate['onOpenFile']('"+path+"', flags) threw an exception: " + e.message); | |
| } | |
| return stream; | |
| },close:function (stream) { | |
| try { | |
| if (stream.stream_ops.close) { | |
| stream.stream_ops.close(stream); | |
| } | |
| } catch (e) { | |
| throw e; | |
| } finally { | |
| FS.closeStream(stream.fd); | |
| } | |
| },llseek:function (stream, offset, whence) { | |
| if (!stream.seekable || !stream.stream_ops.llseek) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ESPIPE); | |
| } | |
| stream.position = stream.stream_ops.llseek(stream, offset, whence); | |
| stream.ungotten = []; | |
| return stream.position; | |
| },read:function (stream, buffer, offset, length, position) { | |
| if (length < 0 || position < 0) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| if ((stream.flags & 2097155) === 1) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EBADF); | |
| } | |
| if (FS.isDir(stream.node.mode)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EISDIR); | |
| } | |
| if (!stream.stream_ops.read) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| var seeking = true; | |
| if (typeof position === 'undefined') { | |
| position = stream.position; | |
| seeking = false; | |
| } else if (!stream.seekable) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ESPIPE); | |
| } | |
| var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); | |
| if (!seeking) stream.position += bytesRead; | |
| return bytesRead; | |
| },write:function (stream, buffer, offset, length, position, canOwn) { | |
| if (length < 0 || position < 0) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| if ((stream.flags & 2097155) === 0) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EBADF); | |
| } | |
| if (FS.isDir(stream.node.mode)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EISDIR); | |
| } | |
| if (!stream.stream_ops.write) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| if (stream.flags & 1024) { | |
| // seek to the end before writing in append mode | |
| FS.llseek(stream, 0, 2); | |
| } | |
| var seeking = true; | |
| if (typeof position === 'undefined') { | |
| position = stream.position; | |
| seeking = false; | |
| } else if (!stream.seekable) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ESPIPE); | |
| } | |
| var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); | |
| if (!seeking) stream.position += bytesWritten; | |
| try { | |
| if (stream.path && FS.trackingDelegate['onWriteToFile']) FS.trackingDelegate['onWriteToFile'](stream.path); | |
| } catch(e) { | |
| console.log("FS.trackingDelegate['onWriteToFile']('"+path+"') threw an exception: " + e.message); | |
| } | |
| return bytesWritten; | |
| },allocate:function (stream, offset, length) { | |
| if (offset < 0 || length <= 0) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EINVAL); | |
| } | |
| if ((stream.flags & 2097155) === 0) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EBADF); | |
| } | |
| if (!FS.isFile(stream.node.mode) && !FS.isDir(node.mode)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENODEV); | |
| } | |
| if (!stream.stream_ops.allocate) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP); | |
| } | |
| stream.stream_ops.allocate(stream, offset, length); | |
| },mmap:function (stream, buffer, offset, length, position, prot, flags) { | |
| // TODO if PROT is PROT_WRITE, make sure we have write access | |
| if ((stream.flags & 2097155) === 1) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EACCES); | |
| } | |
| if (!stream.stream_ops.mmap) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENODEV); | |
| } | |
| return stream.stream_ops.mmap(stream, buffer, offset, length, position, prot, flags); | |
| },msync:function (stream, buffer, offset, length, mmapFlags) { | |
| if (!stream || !stream.stream_ops.msync) { | |
| return 0; | |
| } | |
| return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags); | |
| },munmap:function (stream) { | |
| return 0; | |
| },ioctl:function (stream, cmd, arg) { | |
| if (!stream.stream_ops.ioctl) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOTTY); | |
| } | |
| return stream.stream_ops.ioctl(stream, cmd, arg); | |
| },readFile:function (path, opts) { | |
| opts = opts || {}; | |
| opts.flags = opts.flags || 'r'; | |
| opts.encoding = opts.encoding || 'binary'; | |
| if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') { | |
| throw new Error('Invalid encoding type "' + opts.encoding + '"'); | |
| } | |
| var ret; | |
| var stream = FS.open(path, opts.flags); | |
| var stat = FS.stat(path); | |
| var length = stat.size; | |
| var buf = new Uint8Array(length); | |
| FS.read(stream, buf, 0, length, 0); | |
| if (opts.encoding === 'utf8') { | |
| ret = UTF8ArrayToString(buf, 0); | |
| } else if (opts.encoding === 'binary') { | |
| ret = buf; | |
| } | |
| FS.close(stream); | |
| return ret; | |
| },writeFile:function (path, data, opts) { | |
| opts = opts || {}; | |
| opts.flags = opts.flags || 'w'; | |
| opts.encoding = opts.encoding || 'utf8'; | |
| if (opts.encoding !== 'utf8' && opts.encoding !== 'binary') { | |
| throw new Error('Invalid encoding type "' + opts.encoding + '"'); | |
| } | |
| var stream = FS.open(path, opts.flags, opts.mode); | |
| if (opts.encoding === 'utf8') { | |
| var buf = new Uint8Array(lengthBytesUTF8(data)+1); | |
| var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); | |
| FS.write(stream, buf, 0, actualNumBytes, 0, opts.canOwn); | |
| } else if (opts.encoding === 'binary') { | |
| FS.write(stream, data, 0, data.length, 0, opts.canOwn); | |
| } | |
| FS.close(stream); | |
| },cwd:function () { | |
| return FS.currentPath; | |
| },chdir:function (path) { | |
| var lookup = FS.lookupPath(path, { follow: true }); | |
| if (!FS.isDir(lookup.node.mode)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.ENOTDIR); | |
| } | |
| var err = FS.nodePermissions(lookup.node, 'x'); | |
| if (err) { | |
| throw new FS.ErrnoError(err); | |
| } | |
| FS.currentPath = lookup.path; | |
| },createDefaultDirectories:function () { | |
| FS.mkdir('/tmp'); | |
| FS.mkdir('/home'); | |
| FS.mkdir('/home/web_user'); | |
| },createDefaultDevices:function () { | |
| // create /dev | |
| FS.mkdir('/dev'); | |
| // setup /dev/null | |
| FS.registerDevice(FS.makedev(1, 3), { | |
| read: function() { return 0; }, | |
| write: function() { return 0; } | |
| }); | |
| FS.mkdev('/dev/null', FS.makedev(1, 3)); | |
| // setup /dev/tty and /dev/tty1 | |
| // stderr needs to print output using Module['printErr'] | |
| // so we register a second tty just for it. | |
| TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); | |
| TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); | |
| FS.mkdev('/dev/tty', FS.makedev(5, 0)); | |
| FS.mkdev('/dev/tty1', FS.makedev(6, 0)); | |
| // setup /dev/[u]random | |
| var random_device; | |
| if (typeof crypto !== 'undefined') { | |
| // for modern web browsers | |
| var randomBuffer = new Uint8Array(1); | |
| random_device = function() { crypto.getRandomValues(randomBuffer); return randomBuffer[0]; }; | |
| } else if (ENVIRONMENT_IS_NODE) { | |
| // for nodejs | |
| random_device = function() { return require('crypto').randomBytes(1)[0]; }; | |
| } else { | |
| // default for ES5 platforms | |
| random_device = function() { return (Math.random()*256)|0; }; | |
| } | |
| FS.createDevice('/dev', 'random', random_device); | |
| FS.createDevice('/dev', 'urandom', random_device); | |
| // we're not going to emulate the actual shm device, | |
| // just create the tmp dirs that reside in it commonly | |
| FS.mkdir('/dev/shm'); | |
| FS.mkdir('/dev/shm/tmp'); | |
| },createStandardStreams:function () { | |
| // TODO deprecate the old functionality of a single | |
| // input / output callback and that utilizes FS.createDevice | |
| // and instead require a unique set of stream ops | |
| // by default, we symlink the standard streams to the | |
| // default tty devices. however, if the standard streams | |
| // have been overwritten we create a unique device for | |
| // them instead. | |
| if (Module['stdin']) { | |
| FS.createDevice('/dev', 'stdin', Module['stdin']); | |
| } else { | |
| FS.symlink('/dev/tty', '/dev/stdin'); | |
| } | |
| if (Module['stdout']) { | |
| FS.createDevice('/dev', 'stdout', null, Module['stdout']); | |
| } else { | |
| FS.symlink('/dev/tty', '/dev/stdout'); | |
| } | |
| if (Module['stderr']) { | |
| FS.createDevice('/dev', 'stderr', null, Module['stderr']); | |
| } else { | |
| FS.symlink('/dev/tty1', '/dev/stderr'); | |
| } | |
| // open default streams for the stdin, stdout and stderr devices | |
| var stdin = FS.open('/dev/stdin', 'r'); | |
| ((SAFE_HEAP_STORE(((_stdin)|0), ((FS.getPtrForStream(stdin))|0), 4, 0))|0); | |
| assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')'); | |
| var stdout = FS.open('/dev/stdout', 'w'); | |
| ((SAFE_HEAP_STORE(((_stdout)|0), ((FS.getPtrForStream(stdout))|0), 4, 0))|0); | |
| assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')'); | |
| var stderr = FS.open('/dev/stderr', 'w'); | |
| ((SAFE_HEAP_STORE(((_stderr)|0), ((FS.getPtrForStream(stderr))|0), 4, 0))|0); | |
| assert(stderr.fd === 2, 'invalid handle for stderr (' + stderr.fd + ')'); | |
| },ensureErrnoError:function () { | |
| if (FS.ErrnoError) return; | |
| FS.ErrnoError = function ErrnoError(errno, node) { | |
| this.node = node; | |
| this.setErrno = function(errno) { | |
| this.errno = errno; | |
| for (var key in ERRNO_CODES) { | |
| if (ERRNO_CODES[key] === errno) { | |
| this.code = key; | |
| break; | |
| } | |
| } | |
| }; | |
| this.setErrno(errno); | |
| this.message = ERRNO_MESSAGES[errno]; | |
| if (this.stack) this.stack = demangleAll(this.stack); | |
| }; | |
| FS.ErrnoError.prototype = new Error(); | |
| FS.ErrnoError.prototype.constructor = FS.ErrnoError; | |
| // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info) | |
| [ERRNO_CODES.ENOENT].forEach(function(code) { | |
| FS.genericErrors[code] = new FS.ErrnoError(code); | |
| FS.genericErrors[code].stack = '<generic error, no stack>'; | |
| }); | |
| },staticInit:function () { | |
| FS.ensureErrnoError(); | |
| FS.nameTable = new Array(4096); | |
| FS.mount(MEMFS, {}, '/'); | |
| FS.createDefaultDirectories(); | |
| FS.createDefaultDevices(); | |
| },init:function (input, output, error) { | |
| 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.ensureErrnoError(); | |
| // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here | |
| Module['stdin'] = input || Module['stdin']; | |
| Module['stdout'] = output || Module['stdout']; | |
| Module['stderr'] = error || Module['stderr']; | |
| FS.createStandardStreams(); | |
| },quit:function () { | |
| FS.init.initialized = false; | |
| for (var i = 0; i < FS.streams.length; i++) { | |
| var stream = FS.streams[i]; | |
| if (!stream) { | |
| continue; | |
| } | |
| FS.close(stream); | |
| } | |
| },getMode:function (canRead, canWrite) { | |
| var mode = 0; | |
| if (canRead) mode |= 292 | 73; | |
| if (canWrite) mode |= 146; | |
| return mode; | |
| },joinPath:function (parts, forceRelative) { | |
| var path = PATH.join.apply(null, parts); | |
| if (forceRelative && path[0] == '/') path = path.substr(1); | |
| return path; | |
| },absolutePath:function (relative, base) { | |
| return PATH.resolve(base, relative); | |
| },standardizePath:function (path) { | |
| return PATH.normalize(path); | |
| },findObject:function (path, dontResolveLastLink) { | |
| var ret = FS.analyzePath(path, dontResolveLastLink); | |
| if (ret.exists) { | |
| return ret.object; | |
| } else { | |
| ___setErrNo(ret.error); | |
| return null; | |
| } | |
| },analyzePath:function (path, dontResolveLastLink) { | |
| // operate from within the context of the symlink's target | |
| try { | |
| var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); | |
| path = lookup.path; | |
| } catch (e) { | |
| } | |
| var ret = { | |
| isRoot: false, exists: false, error: 0, name: null, path: null, object: null, | |
| parentExists: false, parentPath: null, parentObject: null | |
| }; | |
| try { | |
| var lookup = FS.lookupPath(path, { parent: true }); | |
| ret.parentExists = true; | |
| ret.parentPath = lookup.path; | |
| ret.parentObject = lookup.node; | |
| ret.name = PATH.basename(path); | |
| lookup = FS.lookupPath(path, { follow: !dontResolveLastLink }); | |
| ret.exists = true; | |
| ret.path = lookup.path; | |
| ret.object = lookup.node; | |
| ret.name = lookup.node.name; | |
| ret.isRoot = lookup.path === '/'; | |
| } catch (e) { | |
| ret.error = e.errno; | |
| }; | |
| return ret; | |
| },createFolder:function (parent, name, canRead, canWrite) { | |
| var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name); | |
| var mode = FS.getMode(canRead, canWrite); | |
| return FS.mkdir(path, mode); | |
| },createPath:function (parent, path, canRead, canWrite) { | |
| parent = typeof parent === 'string' ? parent : FS.getPath(parent); | |
| var parts = path.split('/').reverse(); | |
| while (parts.length) { | |
| var part = parts.pop(); | |
| if (!part) continue; | |
| var current = PATH.join2(parent, part); | |
| try { | |
| FS.mkdir(current); | |
| } catch (e) { | |
| // ignore EEXIST | |
| } | |
| parent = current; | |
| } | |
| return current; | |
| },createFile:function (parent, name, properties, canRead, canWrite) { | |
| var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name); | |
| var mode = FS.getMode(canRead, canWrite); | |
| return FS.create(path, mode); | |
| },createDataFile:function (parent, name, data, canRead, canWrite, canOwn) { | |
| var path = name ? PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name) : parent; | |
| var mode = FS.getMode(canRead, canWrite); | |
| var node = FS.create(path, mode); | |
| if (data) { | |
| if (typeof data === 'string') { | |
| var arr = new Array(data.length); | |
| for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); | |
| data = arr; | |
| } | |
| // make sure we can write to the file | |
| FS.chmod(node, mode | 146); | |
| var stream = FS.open(node, 'w'); | |
| FS.write(stream, data, 0, data.length, 0, canOwn); | |
| FS.close(stream); | |
| FS.chmod(node, mode); | |
| } | |
| return node; | |
| },createDevice:function (parent, name, input, output) { | |
| var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name); | |
| var mode = FS.getMode(!!input, !!output); | |
| if (!FS.createDevice.major) FS.createDevice.major = 64; | |
| var dev = FS.makedev(FS.createDevice.major++, 0); | |
| // Create a fake device that a set of stream ops to emulate | |
| // the old behavior. | |
| FS.registerDevice(dev, { | |
| open: function(stream) { | |
| stream.seekable = false; | |
| }, | |
| close: function(stream) { | |
| // flush any pending line data | |
| if (output && output.buffer && output.buffer.length) { | |
| output(10); | |
| } | |
| }, | |
| read: function(stream, buffer, offset, length, pos /* ignored */) { | |
| var bytesRead = 0; | |
| for (var i = 0; i < length; i++) { | |
| var result; | |
| try { | |
| result = input(); | |
| } catch (e) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EIO); | |
| } | |
| if (result === undefined && bytesRead === 0) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EAGAIN); | |
| } | |
| if (result === null || result === undefined) break; | |
| bytesRead++; | |
| buffer[offset+i] = result; | |
| } | |
| if (bytesRead) { | |
| stream.node.timestamp = Date.now(); | |
| } | |
| return bytesRead; | |
| }, | |
| write: function(stream, buffer, offset, length, pos) { | |
| for (var i = 0; i < length; i++) { | |
| try { | |
| output(buffer[offset+i]); | |
| } catch (e) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EIO); | |
| } | |
| } | |
| if (length) { | |
| stream.node.timestamp = Date.now(); | |
| } | |
| return i; | |
| } | |
| }); | |
| return FS.mkdev(path, mode, dev); | |
| },createLink:function (parent, name, target, canRead, canWrite) { | |
| var path = PATH.join2(typeof parent === 'string' ? parent : FS.getPath(parent), name); | |
| return FS.symlink(target, path); | |
| },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); | |
| obj.usedBytes = obj.contents.length; | |
| } catch (e) { | |
| success = false; | |
| } | |
| } else { | |
| throw new Error('Cannot load without read() or XMLHttpRequest.'); | |
| } | |
| if (!success) ___setErrNo(ERRNO_CODES.EIO); | |
| return success; | |
| },createLazyFile:function (parent, name, url, canRead, canWrite) { | |
| // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse. | |
| function LazyUint8Array() { | |
| this.lengthKnown = false; | |
| this.chunks = []; // Loaded chunks. Index is the chunk number | |
| } | |
| LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) { | |
| if (idx > this.length-1 || idx < 0) { | |
| return undefined; | |
| } | |
| var chunkOffset = idx % this.chunkSize; | |
| var chunkNum = (idx / this.chunkSize)|0; | |
| return this.getter(chunkNum)[chunkOffset]; | |
| } | |
| LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { | |
| this.getter = getter; | |
| } | |
| LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { | |
| // 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 = this; | |
| lazyArray.setDataGetter(function(chunkNum) { | |
| var start = chunkNum * chunkSize; | |
| var end = (chunkNum+1) * 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]; | |
| }); | |
| this._length = datalength; | |
| this._chunkSize = chunkSize; | |
| this.lengthKnown = true; | |
| } | |
| 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'; | |
| var lazyArray = new LazyUint8Array(); | |
| Object.defineProperty(lazyArray, "length", { | |
| get: function() { | |
| if(!this.lengthKnown) { | |
| this.cacheLength(); | |
| } | |
| return this._length; | |
| } | |
| }); | |
| Object.defineProperty(lazyArray, "chunkSize", { | |
| get: function() { | |
| if(!this.lengthKnown) { | |
| this.cacheLength(); | |
| } | |
| return this._chunkSize; | |
| } | |
| }); | |
| var properties = { isDevice: false, contents: lazyArray }; | |
| } else { | |
| var properties = { isDevice: false, url: url }; | |
| } | |
| var node = FS.createFile(parent, name, properties, canRead, canWrite); | |
| // This is a total hack, but I want to get this lazy file code out of the | |
| // core of MEMFS. If we want to keep this lazy file concept I feel it should | |
| // be its own thin LAZYFS proxying calls to MEMFS. | |
| if (properties.contents) { | |
| node.contents = properties.contents; | |
| } else if (properties.url) { | |
| node.contents = null; | |
| node.url = properties.url; | |
| } | |
| // Add a function that defers querying the file size until it is asked the first time. | |
| Object.defineProperty(node, "usedBytes", { | |
| get: function() { return this.contents.length; } | |
| }); | |
| // override each stream op with one that tries to force load the lazy file first | |
| var stream_ops = {}; | |
| var keys = Object.keys(node.stream_ops); | |
| keys.forEach(function(key) { | |
| var fn = node.stream_ops[key]; | |
| stream_ops[key] = function forceLoadLazyFile() { | |
| if (!FS.forceLoadFile(node)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EIO); | |
| } | |
| return fn.apply(null, arguments); | |
| }; | |
| }); | |
| // use a custom read function | |
| stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) { | |
| if (!FS.forceLoadFile(node)) { | |
| throw new FS.ErrnoError(ERRNO_CODES.EIO); | |
| } | |
| var contents = stream.node.contents; | |
| if (position >= contents.length) | |
| return 0; | |
| var size = Math.min(contents.length - position, length); | |
| assert(size >= 0); | |
| if (contents.slice) { // normal array | |
| for (var i = 0; i < size; i++) { | |
| buffer[offset + i] = contents[position + i]; | |
| } | |
| } else { | |
| for (var i = 0; i < size; i++) { // LazyUint8Array from sync binary XHR | |
| buffer[offset + i] = contents.get(position + i); | |
| } | |
| } | |
| return size; | |
| }; | |
| node.stream_ops = stream_ops; | |
| return node; | |
| },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn) { | |
| Browser.init(); | |
| // TODO we should allow people to just pass in a complete filename instead | |
| // of parent and name being that we just join them anyways | |
| var fullname = name ? PATH.resolve(PATH.join2(parent, name)) : parent; | |
| function processData(byteArray) { | |
| function finish(byteArray) { | |
| if (!dontCreateFile) { | |
| FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn); | |
| } | |
| 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); | |
| } | |
| },indexedDB:function () { | |
| return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB; | |
| },DB_NAME:function () { | |
| return 'EM_FS_' + window.location.pathname; | |
| },DB_VERSION:20,DB_STORE_NAME:"FILE_DATA",saveFilesToDB:function (paths, onload, onerror) { | |
| onload = onload || function(){}; | |
| onerror = onerror || function(){}; | |
| var indexedDB = FS.indexedDB(); | |
| try { | |
| var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); | |
| } catch (e) { | |
| return onerror(e); | |
| } | |
| openRequest.onupgradeneeded = function openRequest_onupgradeneeded() { | |
| console.log('creating db'); | |
| var db = openRequest.result; | |
| db.createObjectStore(FS.DB_STORE_NAME); | |
| }; | |
| openRequest.onsuccess = function openRequest_onsuccess() { | |
| var db = openRequest.result; | |
| var transaction = db.transaction([FS.DB_STORE_NAME], 'readwrite'); | |
| var files = transaction.objectStore(FS.DB_STORE_NAME); | |
| var ok = 0, fail = 0, total = paths.length; | |
| function finish() { | |
| if (fail == 0) onload(); else onerror(); | |
| } | |
| paths.forEach(function(path) { | |
| var putRequest = files.put(FS.analyzePath(path).object.contents, path); | |
| putRequest.onsuccess = function putRequest_onsuccess() { ok++; if (ok + fail == total) finish() }; | |
| putRequest.onerror = function putRequest_onerror() { fail++; if (ok + fail == total) finish() }; | |
| }); | |
| transaction.onerror = onerror; | |
| }; | |
| openRequest.onerror = onerror; | |
| },loadFilesFromDB:function (paths, onload, onerror) { | |
| onload = onload || function(){}; | |
| onerror = onerror || function(){}; | |
| var indexedDB = FS.indexedDB(); | |
| try { | |
| var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION); | |
| } catch (e) { | |
| return onerror(e); | |
| } | |
| openRequest.onupgradeneeded = onerror; // no database to load from | |
| openRequest.onsuccess = function openRequest_onsuccess() { | |
| var db = openRequest.result; | |
| try { | |
| var transaction = db.transaction([FS.DB_STORE_NAME], 'readonly'); | |
| } catch(e) { | |
| onerror(e); | |
| return; | |
| } | |
| var files = transaction.objectStore(FS.DB_STORE_NAME); | |
| var ok = 0, fail = 0, total = paths.length; | |
| function finish() { | |
| if (fail == 0) onload(); else onerror(); | |
| } | |
| paths.forEach(function(path) { | |
| var getRequest = files.get(path); | |
| getRequest.onsuccess = function getRequest_onsuccess() { | |
| if (FS.analyzePath(path).exists) { | |
| FS.unlink(path); | |
| } | |
| FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true); | |
| ok++; | |
| if (ok + fail == total) finish(); | |
| }; | |
| getRequest.onerror = function getRequest_onerror() { fail++; if (ok + fail == total) finish() }; | |
| }); | |
| transaction.onerror = onerror; | |
| }; | |
| openRequest.onerror = onerror; | |
| }};var PATH={splitPath:function (filename) { | |
| var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; | |
| return splitPathRe.exec(filename).slice(1); | |
| },normalizeArray:function (parts, allowAboveRoot) { | |
| // if the path tries to go above the root, `up` ends up > 0 | |
| var up = 0; | |
| for (var i = parts.length - 1; i >= 0; i--) { | |
| var last = parts[i]; | |
| if (last === '.') { | |
| parts.splice(i, 1); | |
| } else if (last === '..') { | |
| parts.splice(i, 1); | |
| up++; | |
| } else if (up) { | |
| parts.splice(i, 1); | |
| up--; | |
| } | |
| } | |
| // if the path is allowed to go above the root, restore leading ..s | |
| if (allowAboveRoot) { | |
| for (; up--; up) { | |
| parts.unshift('..'); | |
| } | |
| } | |
| return parts; | |
| },normalize:function (path) { | |
| var isAbsolute = path.charAt(0) === '/', | |
| trailingSlash = path.substr(-1) === '/'; | |
| // Normalize the path | |
| path = PATH.normalizeArray(path.split('/').filter(function(p) { | |
| return !!p; | |
| }), !isAbsolute).join('/'); | |
| if (!path && !isAbsolute) { | |
| path = '.'; | |
| } | |
| if (path && trailingSlash) { | |
| path += '/'; | |
| } | |
| return (isAbsolute ? '/' : '') + path; | |
| },dirname:function (path) { | |
| var result = PATH.splitPath(path), | |
| root = result[0], | |
| dir = result[1]; | |
| if (!root && !dir) { | |
| // No dirname whatsoever | |
| return '.'; | |
| } | |
| if (dir) { | |
| // It has a dirname, strip trailing slash | |
| dir = dir.substr(0, dir.length - 1); | |
| } | |
| return root + dir; | |
| },basename:function (path) { | |
| // EMSCRIPTEN return '/'' for '/', not an empty string | |
| if (path === '/') return '/'; | |
| var lastSlash = path.lastIndexOf('/'); | |
| if (lastSlash === -1) return path; | |
| return path.substr(lastSlash+1); | |
| },extname:function (path) { | |
| return PATH.splitPath(path)[3]; | |
| },join:function () { | |
| var paths = Array.prototype.slice.call(arguments, 0); | |
| return PATH.normalize(paths.join('/')); | |
| },join2:function (l, r) { | |
| return PATH.normalize(l + '/' + r); | |
| },resolve:function () { | |
| var resolvedPath = '', | |
| resolvedAbsolute = false; | |
| for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { | |
| var path = (i >= 0) ? arguments[i] : FS.cwd(); | |
| // Skip empty and invalid entries | |
| if (typeof path !== 'string') { | |
| throw new TypeError('Arguments to path.resolve must be strings'); | |
| } else if (!path) { | |
| return ''; // an invalid portion invalidates the whole thing | |
| } | |
| resolvedPath = path + '/' + resolvedPath; | |
| resolvedAbsolute = path.charAt(0) === '/'; | |
| } | |
| // At this point the path should be resolved to a full absolute path, but | |
| // handle relative paths to be safe (might happen when process.cwd() fails) | |
| resolvedPath = PATH.normalizeArray(resolvedPath.split('/').filter(function(p) { | |
| return !!p; | |
| }), !resolvedAbsolute).join('/'); | |
| return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; | |
| },relative:function (from, to) { | |
| from = PATH.resolve(from).substr(1); | |
| to = PATH.resolve(to).substr(1); | |
| function trim(arr) { | |
| var start = 0; | |
| for (; start < arr.length; start++) { | |
| if (arr[start] !== '') break; | |
| } | |
| var end = arr.length - 1; | |
| for (; end >= 0; end--) { | |
| if (arr[end] !== '') break; | |
| } | |
| if (start > end) return []; | |
| return arr.slice(start, end - start + 1); | |
| } | |
| var fromParts = trim(from.split('/')); | |
| var toParts = trim(to.split('/')); | |
| var length = Math.min(fromParts.length, toParts.length); | |
| var samePartsLength = length; | |
| for (var i = 0; i < length; i++) { | |
| if (fromParts[i] !== toParts[i]) { | |
| samePartsLength = i; | |
| break; | |
| } | |
| } | |
| var outputParts = []; | |
| for (var i = samePartsLength; i < fromParts.length; i++) { | |
| outputParts.push('..'); | |
| } | |
| outputParts = outputParts.concat(toParts.slice(samePartsLength)); | |
| return outputParts.join('/'); | |
| }}; | |
| function _emscripten_set_main_loop_timing(mode, value) { | |
| Browser.mainLoop.timingMode = mode; | |
| Browser.mainLoop.timingValue = value; | |
| if (!Browser.mainLoop.func) { | |
| console.error('emscripten_set_main_loop_timing: Cannot set timing mode for main loop since a main loop does not exist! Call emscripten_set_main_loop first to set one up.'); | |
| return 1; // Return non-zero on failure, can't set timing mode when there is no main loop. | |
| } | |
| if (mode == 0 /*EM_TIMING_SETTIMEOUT*/) { | |
| Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler() { | |
| setTimeout(Browser.mainLoop.runner, value); // doing this each time means that on exception, we stop | |
| }; | |
| Browser.mainLoop.method = 'timeout'; | |
| } else if (mode == 1 /*EM_TIMING_RAF*/) { | |
| Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler() { | |
| Browser.requestAnimationFrame(Browser.mainLoop.runner); | |
| }; | |
| Browser.mainLoop.method = 'rAF'; | |
| } | |
| return 0; | |
| }function _emscripten_set_main_loop(func, fps, simulateInfiniteLoop, arg, noSetTiming) { | |
| Module['noExitRuntime'] = true; | |
| assert(!Browser.mainLoop.func, 'emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters.'); | |
| Browser.mainLoop.func = func; | |
| Browser.mainLoop.arg = arg; | |
| var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop; | |
| Browser.mainLoop.runner = function Browser_mainLoop_runner() { | |
| if (ABORT) return; | |
| if (Browser.mainLoop.queue.length > 0) { | |
| var start = Date.now(); | |
| var blocker = Browser.mainLoop.queue.shift(); | |
| blocker.func(blocker.arg); | |
| if (Browser.mainLoop.remainingBlockers) { | |
| var remaining = Browser.mainLoop.remainingBlockers; | |
| var next = remaining%1 == 0 ? remaining-1 : Math.floor(remaining); | |
| if (blocker.counted) { | |
| Browser.mainLoop.remainingBlockers = next; | |
| } else { | |
| // not counted, but move the progress along a tiny bit | |
| next = next + 0.5; // do not steal all the next one's progress | |
| Browser.mainLoop.remainingBlockers = (8*remaining + next)/9; | |
| } | |
| } | |
| console.log('main loop blocker "' + blocker.name + '" took ' + (Date.now() - start) + ' ms'); //, left: ' + Browser.mainLoop.remainingBlockers); | |
| Browser.mainLoop.updateStatus(); | |
| setTimeout(Browser.mainLoop.runner, 0); | |
| return; | |
| } | |
| // catch pauses from non-main loop sources | |
| if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return; | |
| // Implement very basic swap interval control | |
| Browser.mainLoop.currentFrameNumber = Browser.mainLoop.currentFrameNumber + 1 | 0; | |
| if (Browser.mainLoop.timingMode == 1/*EM_TIMING_RAF*/ && Browser.mainLoop.timingValue > 1 && Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue != 0) { | |
| // Not the scheduled time to render this frame - skip. | |
| Browser.mainLoop.scheduler(); | |
| return; | |
| } | |
| // Signal GL rendering layer that processing of a new frame is about to start. This helps it optimize | |
| // VBO double-buffering and reduce GPU stalls. | |
| if (Browser.mainLoop.method === 'timeout' && Module.ctx) { | |
| Module.printErr('Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!'); | |
| Browser.mainLoop.method = ''; // just warn once per call to set main loop | |
| } | |
| Browser.mainLoop.runIter(function() { | |
| if (typeof arg !== 'undefined') { | |
| Runtime.dynCall('vi', func, [arg]); | |
| } else { | |
| Runtime.dynCall('v', func); | |
| } | |
| }); | |
| // catch pauses from the main loop itself | |
| if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) return; | |
| // Queue new audio data. This is important to be right after the main loop invocation, so that we will immediately be able | |
| // to queue the newest produced audio samples. | |
| // TODO: Consider adding pre- and post- rAF callbacks so that GL.newRenderingFrameStarted() and SDL.audio.queueNewAudioData() | |
| // do not need to be hardcoded into this function, but can be more generic. | |
| if (typeof SDL === 'object' && SDL.audio && SDL.audio.queueNewAudioData) SDL.audio.queueNewAudioData(); | |
| Browser.mainLoop.scheduler(); | |
| } | |
| if (!noSetTiming) { | |
| if (fps && fps > 0) _emscripten_set_main_loop_timing(0/*EM_TIMING_SETTIMEOUT*/, 1000.0 / fps); | |
| else _emscripten_set_main_loop_timing(1/*EM_TIMING_RAF*/, 1); // Do rAF by rendering each frame (no decimating) | |
| Browser.mainLoop.scheduler(); | |
| } | |
| if (simulateInfiniteLoop) { | |
| throw 'SimulateInfiniteLoop'; | |
| } | |
| }var Browser={mainLoop:{scheduler:null,method:"",currentlyRunningMainloop:0,func:null,arg:0,timingMode:0,timingValue:0,currentFrameNumber:0,queue:[],pause:function () { | |
| Browser.mainLoop.scheduler = null; | |
| Browser.mainLoop.currentlyRunningMainloop++; // Incrementing this signals the previous main loop that it's now become old, and it must return. | |
| },resume:function () { | |
| Browser.mainLoop.currentlyRunningMainloop++; | |
| var timingMode = Browser.mainLoop.timingMode; | |
| var timingValue = Browser.mainLoop.timingValue; | |
| var func = Browser.mainLoop.func; | |
| Browser.mainLoop.func = null; | |
| _emscripten_set_main_loop(func, 0, false, Browser.mainLoop.arg, true /* do not set timing and call scheduler, we will do it on the next lines */); | |
| _emscripten_set_main_loop_timing(timingMode, timingValue); | |
| Browser.mainLoop.scheduler(); | |
| },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'](''); | |
| } | |
| } | |
| },runIter:function (func) { | |
| if (ABORT) return; | |
| if (Module['preMainLoop']) { | |
| var preRet = Module['preMainLoop'](); | |
| if (preRet === false) { | |
| return; // |return false| skips a frame | |
| } | |
| } | |
| try { | |
| func(); | |
| } catch (e) { | |
| if (e instanceof ExitStatus) { | |
| return; | |
| } else { | |
| if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]); | |
| throw e; | |
| } | |
| } | |
| if (Module['postMainLoop']) Module['postMainLoop'](); | |
| }},isFullScreen:false,pointerLock:false,moduleContextCreatedCallbacks:[],workers:[],init:function () { | |
| if (!Module["preloadPlugins"]) Module["preloadPlugins"] = []; // needs to exist even in workers | |
| if (Browser.initted) return; | |
| Browser.initted = 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) : undefined; | |
| if (!Module.noImageDecoding && typeof Browser.URLObject === 'undefined') { | |
| console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available."); | |
| Module.noImageDecoding = true; | |
| } | |
| // 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.). | |
| var imagePlugin = {}; | |
| imagePlugin['canHandle'] = function imagePlugin_canHandle(name) { | |
| return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name); | |
| }; | |
| imagePlugin['handle'] = function imagePlugin_handle(byteArray, name, onload, onerror) { | |
| var b = null; | |
| if (Browser.hasBlobConstructor) { | |
| try { | |
| b = new Blob([byteArray], { type: Browser.getMimetype(name) }); | |
| if (b.size !== byteArray.length) { // Safari bug #118630 | |
| // Safari's Blob can only take an ArrayBuffer | |
| b = new Blob([(new Uint8Array(byteArray)).buffer], { type: Browser.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 img_onload() { | |
| 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 img_onerror(event) { | |
| console.log('Image ' + url + ' could not be decoded'); | |
| if (onerror) onerror(); | |
| }; | |
| img.src = url; | |
| }; | |
| Module['preloadPlugins'].push(imagePlugin); | |
| var audioPlugin = {}; | |
| audioPlugin['canHandle'] = function audioPlugin_canHandle(name) { | |
| return !Module.noAudioDecoding && name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 }; | |
| }; | |
| audioPlugin['handle'] = function audioPlugin_handle(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: Browser.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 audio_onerror(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 | |
| Browser.safeSetTimeout(function() { | |
| finish(audio); // try to use it even though it is not necessarily ready to play | |
| }, 10000); | |
| } else { | |
| return fail(); | |
| } | |
| }; | |
| Module['preloadPlugins'].push(audioPlugin); | |
| // Canvas event setup | |
| var canvas = Module['canvas']; | |
| function pointerLockChange() { | |
| Browser.pointerLock = document['pointerLockElement'] === canvas || | |
| document['mozPointerLockElement'] === canvas || | |
| document['webkitPointerLockElement'] === canvas || | |
| document['msPointerLockElement'] === canvas; | |
| } | |
| if (canvas) { | |
| // forced aspect ratio can be enabled by defining 'forcedAspectRatio' on Module | |
| // Module['forcedAspectRatio'] = 4 / 3; | |
| canvas.requestPointerLock = canvas['requestPointerLock'] || | |
| canvas['mozRequestPointerLock'] || | |
| canvas['webkitRequestPointerLock'] || | |
| canvas['msRequestPointerLock'] || | |
| function(){}; | |
| canvas.exitPointerLock = document['exitPointerLock'] || | |
| document['mozExitPointerLock'] || | |
| document['webkitExitPointerLock'] || | |
| document['msExitPointerLock'] || | |
| function(){}; // no-op if function does not exist | |
| canvas.exitPointerLock = canvas.exitPointerLock.bind(document); | |
| document.addEventListener('pointerlockchange', pointerLockChange, false); | |
| document.addEventListener('mozpointerlockchange', pointerLockChange, false); | |
| document.addEventListener('webkitpointerlockchange', pointerLockChange, false); | |
| document.addEventListener('mspointerlockchange', pointerLockChange, false); | |
| if (Module['elementPointerLock']) { | |
| canvas.addEventListener("click", function(ev) { | |
| if (!Browser.pointerLock && canvas.requestPointerLock) { | |
| canvas.requestPointerLock(); | |
| ev.preventDefault(); | |
| } | |
| }, false); | |
| } | |
| } | |
| },createContext:function (canvas, useWebGL, setInModule, webGLContextAttributes) { | |
| if (useWebGL && Module.ctx && canvas == Module.canvas) return Module.ctx; // no need to recreate GL context if it's already been created for this canvas. | |
| var ctx; | |
| var contextHandle; | |
| if (useWebGL) { | |
| // For GLES2/desktop GL compatibility, adjust a few defaults to be different to WebGL defaults, so that they align better with the desktop defaults. | |
| var contextAttributes = { | |
| antialias: false, | |
| alpha: false | |
| }; | |
| if (webGLContextAttributes) { | |
| for (var attribute in webGLContextAttributes) { | |
| contextAttributes[attribute] = webGLContextAttributes[attribute]; | |
| } | |
| } | |
| contextHandle = GL.createContext(canvas, contextAttributes); | |
| if (contextHandle) { | |
| ctx = GL.getContext(contextHandle).GLctx; | |
| } | |
| // Set the background of the WebGL canvas to black | |
| canvas.style.backgroundColor = "black"; | |
| } else { | |
| ctx = canvas.getContext('2d'); | |
| } | |
| if (!ctx) return null; | |
| if (setInModule) { | |
| if (!useWebGL) assert(typeof GLctx === 'undefined', 'cannot set in module if GLctx is used, but we are a non-GL context that would replace it'); | |
| Module.ctx = ctx; | |
| if (useWebGL) GL.makeContextCurrent(contextHandle); | |
| Module.useWebGL = useWebGL; | |
| Browser.moduleContextCreatedCallbacks.forEach(function(callback) { callback() }); | |
| Browser.init(); | |
| } | |
| return ctx; | |
| },destroyContext:function (canvas, useWebGL, setInModule) {},fullScreenHandlersInstalled:false,lockPointer:undefined,resizeCanvas:undefined,requestFullScreen:function (lockPointer, resizeCanvas, vrDevice) { | |
| Browser.lockPointer = lockPointer; | |
| Browser.resizeCanvas = resizeCanvas; | |
| Browser.vrDevice = vrDevice; | |
| if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true; | |
| if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false; | |
| if (typeof Browser.vrDevice === 'undefined') Browser.vrDevice = null; | |
| var canvas = Module['canvas']; | |
| function fullScreenChange() { | |
| Browser.isFullScreen = false; | |
| var canvasContainer = canvas.parentNode; | |
| if ((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] || | |
| document['mozFullScreenElement'] || document['mozFullscreenElement'] || | |
| document['fullScreenElement'] || document['fullscreenElement'] || | |
| document['msFullScreenElement'] || document['msFullscreenElement'] || | |
| document['webkitCurrentFullScreenElement']) === canvasContainer) { | |
| canvas.cancelFullScreen = document['cancelFullScreen'] || | |
| document['mozCancelFullScreen'] || | |
| document['webkitCancelFullScreen'] || | |
| document['msExitFullscreen'] || | |
| document['exitFullscreen'] || | |
| function() {}; | |
| canvas.cancelFullScreen = canvas.cancelFullScreen.bind(document); | |
| if (Browser.lockPointer) canvas.requestPointerLock(); | |
| Browser.isFullScreen = true; | |
| if (Browser.resizeCanvas) Browser.setFullScreenCanvasSize(); | |
| } else { | |
| // remove the full screen specific parent of the canvas again to restore the HTML structure from before going full screen | |
| canvasContainer.parentNode.insertBefore(canvas, canvasContainer); | |
| canvasContainer.parentNode.removeChild(canvasContainer); | |
| if (Browser.resizeCanvas) Browser.setWindowedCanvasSize(); | |
| } | |
| if (Module['onFullScreen']) Module['onFullScreen'](Browser.isFullScreen); | |
| Browser.updateCanvasDimensions(canvas); | |
| } | |
| if (!Browser.fullScreenHandlersInstalled) { | |
| Browser.fullScreenHandlersInstalled = true; | |
| document.addEventListener('fullscreenchange', fullScreenChange, false); | |
| document.addEventListener('mozfullscreenchange', fullScreenChange, false); | |
| document.addEventListener('webkitfullscreenchange', fullScreenChange, false); | |
| document.addEventListener('MSFullscreenChange', fullScreenChange, false); | |
| } | |
| // create a new parent to ensure the canvas has no siblings. this allows browsers to optimize full screen performance when its parent is the full screen root | |
| var canvasContainer = document.createElement("div"); | |
| canvas.parentNode.insertBefore(canvasContainer, canvas); | |
| canvasContainer.appendChild(canvas); | |
| // use parent of canvas as full screen root to allow aspect ratio correction (Firefox stretches the root to screen size) | |
| canvasContainer.requestFullScreen = canvasContainer['requestFullScreen'] || | |
| canvasContainer['mozRequestFullScreen'] || | |
| canvasContainer['msRequestFullscreen'] || | |
| (canvasContainer['webkitRequestFullScreen'] ? function() { canvasContainer['webkitRequestFullScreen'](Element['ALLOW_KEYBOARD_INPUT']) } : null); | |
| if (vrDevice) { | |
| canvasContainer.requestFullScreen({ vrDisplay: vrDevice }); | |
| } else { | |
| canvasContainer.requestFullScreen(); | |
| } | |
| },nextRAF:0,fakeRequestAnimationFrame:function (func) { | |
| // try to keep 60fps between calls to here | |
| var now = Date.now(); | |
| if (Browser.nextRAF === 0) { | |
| Browser.nextRAF = now + 1000/60; | |
| } else { | |
| while (now + 2 >= Browser.nextRAF) { // fudge a little, to avoid timer jitter causing us to do lots of delay:0 | |
| Browser.nextRAF += 1000/60; | |
| } | |
| } | |
| var delay = Math.max(Browser.nextRAF - now, 0); | |
| setTimeout(func, delay); | |
| },requestAnimationFrame:function requestAnimationFrame(func) { | |
| if (typeof window === 'undefined') { // Provide fallback to setTimeout if window is undefined (e.g. in Node.js) | |
| Browser.fakeRequestAnimationFrame(func); | |
| } else { | |
| if (!window.requestAnimationFrame) { | |
| window.requestAnimationFrame = window['requestAnimationFrame'] || | |
| window['mozRequestAnimationFrame'] || | |
| window['webkitRequestAnimationFrame'] || | |
| window['msRequestAnimationFrame'] || | |
| window['oRequestAnimationFrame'] || | |
| Browser.fakeRequestAnimationFrame; | |
| } | |
| window.requestAnimationFrame(func); | |
| } | |
| },safeCallback:function (func) { | |
| return function() { | |
| if (!ABORT) return func.apply(null, arguments); | |
| }; | |
| },allowAsyncCallbacks:true,queuedAsyncCallbacks:[],pauseAsyncCallbacks:function () { | |
| Browser.allowAsyncCallbacks = false; | |
| },resumeAsyncCallbacks:function () { // marks future callbacks as ok to execute, and synchronously runs any remaining ones right now | |
| Browser.allowAsyncCallbacks = true; | |
| if (Browser.queuedAsyncCallbacks.length > 0) { | |
| var callbacks = Browser.queuedAsyncCallbacks; | |
| Browser.queuedAsyncCallbacks = []; | |
| callbacks.forEach(function(func) { | |
| func(); | |
| }); | |
| } | |
| },safeRequestAnimationFrame:function (func) { | |
| return Browser.requestAnimationFrame(function() { | |
| if (ABORT) return; | |
| if (Browser.allowAsyncCallbacks) { | |
| func(); | |
| } else { | |
| Browser.queuedAsyncCallbacks.push(func); | |
| } | |
| }); | |
| },safeSetTimeout:function (func, timeout) { | |
| Module['noExitRuntime'] = true; | |
| return setTimeout(function() { | |
| if (ABORT) return; | |
| if (Browser.allowAsyncCallbacks) { | |
| func(); | |
| } else { | |
| Browser.queuedAsyncCallbacks.push(func); | |
| } | |
| }, timeout); | |
| },safeSetInterval:function (func, timeout) { | |
| Module['noExitRuntime'] = true; | |
| return setInterval(function() { | |
| if (ABORT) return; | |
| if (Browser.allowAsyncCallbacks) { | |
| func(); | |
| } // drop it on the floor otherwise, next interval will kick in | |
| }, timeout); | |
| },getMimetype:function (name) { | |
| return { | |
| 'jpg': 'image/jpeg', | |
| 'jpeg': 'image/jpeg', | |
| 'png': 'image/png', | |
| 'bmp': 'image/bmp', | |
| 'ogg': 'audio/ogg', | |
| 'wav': 'audio/wav', | |
| 'mp3': 'audio/mpeg' | |
| }[name.substr(name.lastIndexOf('.')+1)]; | |
| },getUserMedia:function (func) { | |
| if(!window.getUserMedia) { | |
| window.getUserMedia = navigator['getUserMedia'] || | |
| navigator['mozGetUserMedia']; | |
| } | |
| window.getUserMedia(func); | |
| },getMovementX:function (event) { | |
| return event['movementX'] || | |
| event['mozMovementX'] || | |
| event['webkitMovementX'] || | |
| 0; | |
| },getMovementY:function (event) { | |
| return event['movementY'] || | |
| event['mozMovementY'] || | |
| event['webkitMovementY'] || | |
| 0; | |
| },getMouseWheelDelta:function (event) { | |
| var delta = 0; | |
| switch (event.type) { | |
| case 'DOMMouseScroll': | |
| delta = event.detail; | |
| break; | |
| case 'mousewheel': | |
| delta = event.wheelDelta; | |
| break; | |
| case 'wheel': | |
| delta = event['deltaY']; | |
| break; | |
| default: | |
| throw 'unrecognized mouse wheel event: ' + event.type; | |
| } | |
| return delta; | |
| },mouseX:0,mouseY:0,mouseMovementX:0,mouseMovementY:0,touches:{},lastTouches:{},calculateMouseEvent:function (event) { // event should be mousemove, mousedown or mouseup | |
| if (Browser.pointerLock) { | |
| // When the pointer is locked, calculate the coordinates | |
| // based on the movement of the mouse. | |
| // Workaround for Firefox bug 764498 | |
| if (event.type != 'mousemove' && | |
| ('mozMovementX' in event)) { | |
| Browser.mouseMovementX = Browser.mouseMovementY = 0; | |
| } else { | |
| Browser.mouseMovementX = Browser.getMovementX(event); | |
| Browser.mouseMovementY = Browser.getMovementY(event); | |
| } | |
| // check if SDL is available | |
| if (typeof SDL != "undefined") { | |
| Browser.mouseX = SDL.mouseX + Browser.mouseMovementX; | |
| Browser.mouseY = SDL.mouseY + Browser.mouseMovementY; | |
| } else { | |
| // just add the mouse delta to the current absolut mouse position | |
| // FIXME: ideally this should be clamped against the canvas size and zero | |
| Browser.mouseX += Browser.mouseMovementX; | |
| Browser.mouseY += Browser.mouseMovementY; | |
| } | |
| } else { | |
| // Otherwise, calculate the movement based on the changes | |
| // in the coordinates. | |
| var rect = Module["canvas"].getBoundingClientRect(); | |
| var cw = Module["canvas"].width; | |
| var ch = Module["canvas"].height; | |
| // Neither .scrollX or .pageXOffset are defined in a spec, but | |
| // we prefer .scrollX because it is currently in a spec draft. | |
| // (see: http://www.w3.org/TR/2013/WD-cssom-view-20131217/) | |
| var scrollX = ((typeof window.scrollX !== 'undefined') ? window.scrollX : window.pageXOffset); | |
| var scrollY = ((typeof window.scrollY !== 'undefined') ? window.scrollY : window.pageYOffset); | |
| // If this assert lands, it's likely because the browser doesn't support scrollX or pageXOffset | |
| // and we have no viable fallback. | |
| assert((typeof scrollX !== 'undefined') && (typeof scrollY !== 'undefined'), 'Unable to retrieve scroll position, mouse positions likely broken.'); | |
| if (event.type === 'touchstart' || event.type === 'touchend' || event.type === 'touchmove') { | |
| var touch = event.touch; | |
| if (touch === undefined) { | |
| return; // the "touch" property is only defined in SDL | |
| } | |
| var adjustedX = touch.pageX - (scrollX + rect.left); | |
| var adjustedY = touch.pageY - (scrollY + rect.top); | |
| adjustedX = adjustedX * (cw / rect.width); | |
| adjustedY = adjustedY * (ch / rect.height); | |
| var coords = { x: adjustedX, y: adjustedY }; | |
| if (event.type === 'touchstart') { | |
| Browser.lastTouches[touch.identifier] = coords; | |
| Browser.touches[touch.identifier] = coords; | |
| } else if (event.type === 'touchend' || event.type === 'touchmove') { | |
| Browser.lastTouches[touch.identifier] = Browser.touches[touch.identifier]; | |
| Browser.touches[touch.identifier] = { x: adjustedX, y: adjustedY }; | |
| } | |
| return; | |
| } | |
| var x = event.pageX - (scrollX + rect.left); | |
| var y = event.pageY - (scrollY + rect.top); | |
| // the canvas might be CSS-scaled compared to its backbuffer; | |
| // SDL-using content will want mouse coordinates in terms | |
| // of backbuffer units. | |
| x = x * (cw / rect.width); | |
| y = y * (ch / rect.height); | |
| Browser.mouseMovementX = x - Browser.mouseX; | |
| Browser.mouseMovementY = y - Browser.mouseY; | |
| Browser.mouseX = x; | |
| Browser.mouseY = y; | |
| } | |
| },xhrLoad:function (url, onload, onerror) { | |
| var xhr = new XMLHttpRequest(); | |
| xhr.open('GET', url, true); | |
| xhr.responseType = 'arraybuffer'; | |
| xhr.onload = function xhr_onload() { | |
| if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 | |
| onload(xhr.response); | |
| } else { | |
| onerror(); | |
| } | |
| }; | |
| xhr.onerror = onerror; | |
| xhr.send(null); | |
| },asyncLoad:function (url, onload, onerror, noRunDep) { | |
| Browser.xhrLoad(url, function(arrayBuffer) { | |
| assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).'); | |
| onload(new Uint8Array(arrayBuffer)); | |
| if (!noRunDep) removeRunDependency('al ' + url); | |
| }, function(event) { | |
| if (onerror) { | |
| onerror(); | |
| } else { | |
| throw 'Loading data file "' + url + '" failed.'; | |
| } | |
| }); | |
| if (!noRunDep) 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']; | |
| Browser.updateCanvasDimensions(canvas, width, height); | |
| if (!noUpdates) Browser.updateResizeListeners(); | |
| },windowedWidth:0,windowedHeight:0,setFullScreenCanvasSize:function () { | |
| // check if SDL is available | |
| if (typeof SDL != "undefined") { | |
| var flags = ((SAFE_HEAP_LOAD(((SDL.screen+Runtime.QUANTUM_SIZE*0)|0), 4, 0, 1))|0); | |
| flags = flags | 0x00800000; // set SDL_FULLSCREEN flag | |
| ((SAFE_HEAP_STORE(((SDL.screen+Runtime.QUANTUM_SIZE*0)|0), ((flags)|0), 4, 0))|0) | |
| } | |
| Browser.updateResizeListeners(); | |
| },setWindowedCanvasSize:function () { | |
| // check if SDL is available | |
| if (typeof SDL != "undefined") { | |
| var flags = ((SAFE_HEAP_LOAD(((SDL.screen+Runtime.QUANTUM_SIZE*0)|0), 4, 0, 1))|0); | |
| flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag | |
| ((SAFE_HEAP_STORE(((SDL.screen+Runtime.QUANTUM_SIZE*0)|0), ((flags)|0), 4, 0))|0) | |
| } | |
| Browser.updateResizeListeners(); | |
| },updateCanvasDimensions:function (canvas, wNative, hNative) { | |
| if (wNative && hNative) { | |
| canvas.widthNative = wNative; | |
| canvas.heightNative = hNative; | |
| } else { | |
| wNative = canvas.widthNative; | |
| hNative = canvas.heightNative; | |
| } | |
| var w = wNative; | |
| var h = hNative; | |
| if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) { | |
| if (w/h < Module['forcedAspectRatio']) { | |
| w = Math.round(h * Module['forcedAspectRatio']); | |
| } else { | |
| h = Math.round(w / Module['forcedAspectRatio']); | |
| } | |
| } | |
| if (((document['webkitFullScreenElement'] || document['webkitFullscreenElement'] || | |
| document['mozFullScreenElement'] || document['mozFullscreenElement'] || | |
| document['fullScreenElement'] || document['fullscreenElement'] || | |
| document['msFullScreenElement'] || document['msFullscreenElement'] || | |
| document['webkitCurrentFullScreenElement']) === canvas.parentNode) && (typeof screen != 'undefined')) { | |
| var factor = Math.min(screen.width / w, screen.height / h); | |
| w = Math.round(w * factor); | |
| h = Math.round(h * factor); | |
| } | |
| if (Browser.resizeCanvas) { | |
| if (canvas.width != w) canvas.width = w; | |
| if (canvas.height != h) canvas.height = h; | |
| if (typeof canvas.style != 'undefined') { | |
| canvas.style.removeProperty( "width"); | |
| canvas.style.removeProperty("height"); | |
| } | |
| } else { | |
| if (canvas.width != wNative) canvas.width = wNative; | |
| if (canvas.height != hNative) canvas.height = hNative; | |
| if (typeof canvas.style != 'undefined') { | |
| if (w != wNative || h != hNative) { | |
| canvas.style.setProperty( "width", w + "px", "important"); | |
| canvas.style.setProperty("height", h + "px", "important"); | |
| } else { | |
| canvas.style.removeProperty( "width"); | |
| canvas.style.removeProperty("height"); | |
| } | |
| } | |
| } | |
| },wgetRequests:{},nextWgetRequestHandle:0,getNextWgetRequestHandle:function () { | |
| var handle = Browser.nextWgetRequestHandle; | |
| Browser.nextWgetRequestHandle++; | |
| return handle; | |
| }};var EmterpreterAsync={initted:false,state:0,saveStack:"",yieldCallbacks:[],postAsync:null,ensureInit:function () { | |
| if (this.initted) return; | |
| this.initted = true; | |
| abortDecorators.push(function(output, what) { | |
| if (EmterpreterAsync.state !== 0) { | |
| return output + '\nThis error happened during an emterpreter-async save or load of the stack. Was there non-emterpreted code on the stack during save (which is unallowed)? You may want to adjust EMTERPRETIFY_BLACKLIST, EMTERPRETIFY_WHITELIST, or EMTERPRETIFY_YIELDLIST (to consider certain functions ok to run during an emscripten_sleep_with_yield).\nThis is what the stack looked like when we tried to save it: ' + [EmterpreterAsync.state, EmterpreterAsync.saveStack]; | |
| } | |
| return output; | |
| }); | |
| },setState:function (s) { | |
| this.ensureInit(); | |
| this.state = s; | |
| asm.setAsyncState(s); | |
| },handle:function (doAsyncOp, yieldDuring) { | |
| Module['noExitRuntime'] = true; | |
| if (EmterpreterAsync.state === 0) { | |
| // save the stack we want to resume. this lets other code run in between | |
| // XXX this assumes that this stack top never ever leak! exceptions might violate that | |
| var stack = new Int32Array(HEAP32.subarray(EMTSTACKTOP>>2, asm.emtStackSave()>>2)); | |
| var stacktop = asm.stackSave(); | |
| var resumedCallbacksForYield = false; | |
| function resumeCallbacksForYield() { | |
| if (resumedCallbacksForYield) return; | |
| resumedCallbacksForYield = true; | |
| // allow async callbacks, and also make sure to call the specified yield callbacks. we must | |
| // do this when nothing is on the stack, i.e. after it unwound | |
| EmterpreterAsync.yieldCallbacks.forEach(function(func) { | |
| func(); | |
| }); | |
| Browser.resumeAsyncCallbacks(); // if we were paused (e.g. we are after a sleep), then since we are now yielding, it is safe to call callbacks | |
| } | |
| doAsyncOp(function resume(post) { | |
| assert(EmterpreterAsync.state === 1 || EmterpreterAsync.state === 3); | |
| EmterpreterAsync.setState(3); | |
| if (yieldDuring) { | |
| resumeCallbacksForYield(); | |
| } | |
| // copy the stack back in and resume | |
| HEAP32.set(stack, EMTSTACKTOP>>2); | |
| assert(stacktop === asm.stackSave()); // nothing should have modified the stack meanwhile | |
| EmterpreterAsync.setState(2); | |
| // Resume the main loop | |
| if (Browser.mainLoop.func) { | |
| Browser.mainLoop.resume(); | |
| } | |
| assert(!EmterpreterAsync.postAsync); | |
| EmterpreterAsync.postAsync = post || null; | |
| asm.emterpret(stack[0]); // pc of the first function, from which we can reconstruct the rest, is at position 0 on the stack | |
| if (!yieldDuring && EmterpreterAsync.state === 0) { | |
| // if we did *not* do another async operation, then we know that nothing is conceptually on the stack now, and we can re-allow async callbacks as well as run the queued ones right now | |
| Browser.resumeAsyncCallbacks(); | |
| } | |
| }); | |
| EmterpreterAsync.setState(1); | |
| EmterpreterAsync.saveStack = new Error().stack; // we can't call stackTrace() as it calls compiled code | |
| // Pause the main loop, until we resume | |
| if (Browser.mainLoop.func) { | |
| Browser.mainLoop.pause(); | |
| } | |
| if (yieldDuring) { | |
| // do this when we are not on the stack, i.e., the stack unwound. we might be too late, in which case we do it in resume() | |
| setTimeout(function() { | |
| resumeCallbacksForYield(); | |
| }, 0); | |
| } else { | |
| Browser.pauseAsyncCallbacks(); | |
| } | |
| } else { | |
| // nothing to do here, the stack was just recreated. reset the state. | |
| assert(EmterpreterAsync.state === 2); | |
| EmterpreterAsync.setState(0); | |
| if (EmterpreterAsync.postAsync) { | |
| EmterpreterAsync.postAsync(); | |
| EmterpreterAsync.postAsync = null; | |
| } | |
| } | |
| }};function _emscripten_sleep(ms) { | |
| EmterpreterAsync.handle(function(resume) { | |
| setTimeout(function() { | |
| if (ABORT) return; // do this manually; we can't call into Browser.safeSetTimeout, because that is paused/resumed! | |
| resume(); | |
| }, ms); | |
| }); | |
| } | |
| 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]; | |
| writeAsciiToMemory(msg, strerrbuf); | |
| 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; | |
| } | |
| Module["_strlen"] = _strlen; | |
| function _emscripten_memcpy_big(dest, src, num) { | |
| HEAPU8.set(HEAPU8.subarray(src, src+num), dest); | |
| return dest; | |
| } | |
| Module["_memcpy"] = _memcpy; | |
| function _emscripten_asm_const(code) { | |
| Runtime.asmConsts[code](); | |
| } | |
| Module["_bitshift64Lshr"] = _bitshift64Lshr; | |
| function ___assert_fail(condition, filename, line, func) { | |
| ABORT = true; | |
| throw 'Assertion failed: ' + Pointer_stringify(condition) + ', at: ' + [filename ? Pointer_stringify(filename) : 'unknown filename', line, func ? Pointer_stringify(func) : 'unknown function'] + ' at ' + stackTrace(); | |
| } | |
| var _emscripten_postinvoke=true; | |
| Module["_memmove"] = _memmove; | |
| function ___errno_location() { | |
| return ___errno_state; | |
| } | |
| function __ZSt18uncaught_exceptionv() { // std::uncaught_exception() | |
| return !!__ZSt18uncaught_exceptionv.uncaught_exception; | |
| } | |
| var EXCEPTIONS={last:0,caught:[],infos:{},deAdjust:function (adjusted) { | |
| if (!adjusted || EXCEPTIONS.infos[adjusted]) return adjusted; | |
| for (var ptr in EXCEPTIONS.infos) { | |
| var info = EXCEPTIONS.infos[ptr]; | |
| if (info.adjusted === adjusted) { | |
| return ptr; | |
| } | |
| } | |
| return adjusted; | |
| },addRef:function (ptr) { | |
| if (!ptr) return; | |
| var info = EXCEPTIONS.infos[ptr]; | |
| info.refcount++; | |
| },decRef:function (ptr) { | |
| if (!ptr) return; | |
| var info = EXCEPTIONS.infos[ptr]; | |
| assert(info.refcount > 0); | |
| info.refcount--; | |
| if (info.refcount === 0) { | |
| if (info.destructor) { | |
| Runtime.dynCall('vi', info.destructor, [ptr]); | |
| } | |
| delete EXCEPTIONS.infos[ptr]; | |
| ___cxa_free_exception(ptr); | |
| } | |
| },clearRef:function (ptr) { | |
| if (!ptr) return; | |
| var info = EXCEPTIONS.infos[ptr]; | |
| info.refcount = 0; | |
| }}; | |
| function ___resumeException(ptr) { | |
| if (!EXCEPTIONS.last) { EXCEPTIONS.last = ptr; } | |
| EXCEPTIONS.clearRef(EXCEPTIONS.deAdjust(ptr)); // exception refcount should be cleared, but don't free it | |
| throw ptr; | |
| }function ___cxa_find_matching_catch() { | |
| var thrown = EXCEPTIONS.last; | |
| if (!thrown) { | |
| // just pass through the null ptr | |
| return ((asm["setTempRet0"](0),0)|0); | |
| } | |
| var info = EXCEPTIONS.infos[thrown]; | |
| var throwntype = info.type; | |
| if (!throwntype) { | |
| // just pass through the thrown ptr | |
| return ((asm["setTempRet0"](0),thrown)|0); | |
| } | |
| var typeArray = Array.prototype.slice.call(arguments); | |
| var pointer = Module['___cxa_is_pointer_type'](throwntype); | |
| // can_catch receives a **, add indirection | |
| if (!___cxa_find_matching_catch.buffer) ___cxa_find_matching_catch.buffer = _malloc(4); | |
| ((SAFE_HEAP_STORE(((___cxa_find_matching_catch.buffer)|0), ((thrown)|0), 4, 0))|0); | |
| thrown = ___cxa_find_matching_catch.buffer; | |
| // The different catch blocks are denoted by different types. | |
| // Due to inheritance, those types may not precisely match the | |
| // type of the thrown object. Find one which matches, and | |
| // return the type of the catch block which should be called. | |
| for (var i = 0; i < typeArray.length; i++) { | |
| if (typeArray[i] && Module['___cxa_can_catch'](typeArray[i], throwntype, thrown)) { | |
| thrown = ((SAFE_HEAP_LOAD(((thrown)|0), 4, 0, 0))|0); // undo indirection | |
| info.adjusted = thrown; | |
| return ((asm["setTempRet0"](typeArray[i]),thrown)|0); | |
| } | |
| } | |
| // Shouldn't happen unless we have bogus data in typeArray | |
| // or encounter a type for which emscripten doesn't have suitable | |
| // typeinfo defined. Best-efforts match just in case. | |
| thrown = ((SAFE_HEAP_LOAD(((thrown)|0), 4, 0, 0))|0); // undo indirection | |
| return ((asm["setTempRet0"](throwntype),thrown)|0); | |
| }function ___gxx_personality_v0() { | |
| } | |
| function _emscripten_asm_const_int(code) { | |
| var args = Array.prototype.slice.call(arguments, 1); | |
| return Runtime.asmConsts[code].apply(null, args) | 0; | |
| } | |
| 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 control the "dynamic" memory - DYNAMIC_BASE to DYNAMICTOP | |
| var self = _sbrk; | |
| if (!self.called) { | |
| DYNAMICTOP = alignMemoryPage(DYNAMICTOP); // make sure we start out aligned | |
| self.called = true; | |
| assert(Runtime.dynamicAlloc); | |
| self.alloc = Runtime.dynamicAlloc; | |
| Runtime.dynamicAlloc = function() { abort('cannot dynamically allocate, sbrk now has control') }; | |
| } | |
| var ret = DYNAMICTOP; | |
| if (bytes != 0) { | |
| var success = self.alloc(bytes); | |
| if (!success) return -1 >>> 0; // sbrk failure code | |
| } | |
| return ret; // Previous break location. | |
| } | |
| function _time(ptr) { | |
| var ret = (Date.now()/1000)|0; | |
| if (ptr) { | |
| ((SAFE_HEAP_STORE(((ptr)|0), ((ret)|0), 4, 0))|0); | |
| } | |
| return ret; | |
| } | |
| ___errno_state = Runtime.staticAlloc(4); ((SAFE_HEAP_STORE(((___errno_state)|0), ((0)|0), 4, 0))|0); | |
| Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas, vrDevice) { Browser.requestFullScreen(lockPointer, resizeCanvas, vrDevice) }; | |
| Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) { Browser.requestAnimationFrame(func) }; | |
| Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) { Browser.setCanvasSize(width, height, noUpdates) }; | |
| Module["pauseMainLoop"] = function Module_pauseMainLoop() { Browser.mainLoop.pause() }; | |
| Module["resumeMainLoop"] = function Module_resumeMainLoop() { Browser.mainLoop.resume() }; | |
| Module["getUserMedia"] = function Module_getUserMedia() { Browser.getUserMedia() } | |
| Module["createContext"] = function Module_createContext(canvas, useWebGL, setInModule, webGLContextAttributes) { return Browser.createContext(canvas, useWebGL, setInModule, webGLContextAttributes) } | |
| FS.staticInit();__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; | |
| __ATINIT__.unshift({ func: function() { TTY.init() } });__ATEXIT__.push({ func: function() { TTY.shutdown() } }); | |
| if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); var NODEJS_PATH = require("path"); NODEFS.staticInit(); } | |
| STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP); | |
| staticSealed = true; // seal the static portion of memory | |
| STACK_MAX = STACK_BASE + TOTAL_STACK; | |
| DYNAMIC_BASE = DYNAMICTOP = Runtime.alignMemory(STACK_MAX); | |
| assert(DYNAMIC_BASE < TOTAL_MEMORY, "TOTAL_MEMORY not big enough for stack"); | |
| var cttz_i8 = allocate([8,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0], "i8", ALLOC_DYNAMIC); | |
| function nullFunc_iiiii(x) { Module["printErr"]("Invalid function pointer called with signature 'iiiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"); Module["printErr"]("Build with ASSERTIONS=2 for more info."); abort(x) } | |
| function nullFunc_vi(x) { Module["printErr"]("Invalid function pointer called with signature 'vi'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"); Module["printErr"]("Build with ASSERTIONS=2 for more info."); abort(x) } | |
| function nullFunc_vii(x) { Module["printErr"]("Invalid function pointer called with signature 'vii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"); Module["printErr"]("Build with ASSERTIONS=2 for more info."); abort(x) } | |
| function nullFunc_iiii(x) { Module["printErr"]("Invalid function pointer called with signature 'iiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"); Module["printErr"]("Build with ASSERTIONS=2 for more info."); abort(x) } | |
| function nullFunc_viii(x) { Module["printErr"]("Invalid function pointer called with signature 'viii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"); Module["printErr"]("Build with ASSERTIONS=2 for more info."); abort(x) } | |
| function nullFunc_iii(x) { Module["printErr"]("Invalid function pointer called with signature 'iii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"); Module["printErr"]("Build with ASSERTIONS=2 for more info."); abort(x) } | |
| function nullFunc_viiii(x) { Module["printErr"]("Invalid function pointer called with signature 'viiii'. Perhaps this is an invalid value (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an incorrect type, which will fail? (it is worth building your source files with -Werror (warnings are errors), as warnings can indicate undefined behavior which can cause this)"); Module["printErr"]("Build with ASSERTIONS=2 for more info."); abort(x) } | |
| function invoke_iiiii(index,a1,a2,a3,a4) { | |
| try { | |
| return Module["dynCall_iiiii"](index,a1,a2,a3,a4); | |
| } catch(e) { | |
| if (typeof e !== 'number' && e !== 'longjmp') throw e; | |
| asm["setThrew"](1, 0); | |
| } | |
| } | |
| function invoke_vi(index,a1) { | |
| try { | |
| Module["dynCall_vi"](index,a1); | |
| } catch(e) { | |
| if (typeof e !== 'number' && e !== 'longjmp') throw e; | |
| asm["setThrew"](1, 0); | |
| } | |
| } | |
| function invoke_vii(index,a1,a2) { | |
| try { | |
| Module["dynCall_vii"](index,a1,a2); | |
| } catch(e) { | |
| if (typeof e !== 'number' && e !== 'longjmp') throw e; | |
| asm["setThrew"](1, 0); | |
| } | |
| } | |
| function invoke_iiii(index,a1,a2,a3) { | |
| try { | |
| return Module["dynCall_iiii"](index,a1,a2,a3); | |
| } catch(e) { | |
| if (typeof e !== 'number' && e !== 'longjmp') throw e; | |
| asm["setThrew"](1, 0); | |
| } | |
| } | |
| function invoke_viii(index,a1,a2,a3) { | |
| try { | |
| Module["dynCall_viii"](index,a1,a2,a3); | |
| } catch(e) { | |
| if (typeof e !== 'number' && e !== 'longjmp') throw e; | |
| asm["setThrew"](1, 0); | |
| } | |
| } | |
| function invoke_iii(index,a1,a2) { | |
| try { | |
| return Module["dynCall_iii"](index,a1,a2); | |
| } catch(e) { | |
| if (typeof e !== 'number' && e !== 'longjmp') throw e; | |
| asm["setThrew"](1, 0); | |
| } | |
| } | |
| function invoke_viiii(index,a1,a2,a3,a4) { | |
| try { | |
| Module["dynCall_viiii"](index,a1,a2,a3,a4); | |
| } catch(e) { | |
| if (typeof e !== 'number' && e !== 'longjmp') throw e; | |
| asm["setThrew"](1, 0); | |
| } | |
| } | |
| Module.asmGlobalArg = { "Math": Math, "Int8Array": Int8Array, "Int16Array": Int16Array, "Int32Array": Int32Array, "Uint8Array": Uint8Array, "Uint16Array": Uint16Array, "Uint32Array": Uint32Array, "Float32Array": Float32Array, "Float64Array": Float64Array, "NaN": NaN, "Infinity": Infinity, "byteLength": byteLength }; | |
| Module.asmLibraryArg = { "abort": abort, "assert": assert, "SAFE_HEAP_LOAD": SAFE_HEAP_LOAD, "SAFE_HEAP_STORE": SAFE_HEAP_STORE, "SAFE_FT_MASK": SAFE_FT_MASK, "nullFunc_iiiii": nullFunc_iiiii, "nullFunc_vi": nullFunc_vi, "nullFunc_vii": nullFunc_vii, "nullFunc_iiii": nullFunc_iiii, "nullFunc_viii": nullFunc_viii, "nullFunc_iii": nullFunc_iii, "nullFunc_viiii": nullFunc_viiii, "invoke_iiiii": invoke_iiiii, "invoke_vi": invoke_vi, "invoke_vii": invoke_vii, "invoke_iiii": invoke_iiii, "invoke_viii": invoke_viii, "invoke_iii": invoke_iii, "invoke_viiii": invoke_viiii, "_emscripten_sleep": _emscripten_sleep, "_fflush": _fflush, "_emscripten_asm_const": _emscripten_asm_const, "___assert_fail": ___assert_fail, "_strerror_r": _strerror_r, "_emscripten_set_main_loop": _emscripten_set_main_loop, "_abort": _abort, "_emscripten_set_main_loop_timing": _emscripten_set_main_loop_timing, "_sbrk": _sbrk, "_time": _time, "_strerror": _strerror, "___setErrNo": ___setErrNo, "_emscripten_memcpy_big": _emscripten_memcpy_big, "___gxx_personality_v0": ___gxx_personality_v0, "___resumeException": ___resumeException, "_emscripten_asm_const_int": _emscripten_asm_const_int, "___cxa_find_matching_catch": ___cxa_find_matching_catch, "_sysconf": _sysconf, "___errno_location": ___errno_location, "__ZSt18uncaught_exceptionv": __ZSt18uncaught_exceptionv, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "cttz_i8": cttz_i8 }; | |
| Module.asmLibraryArg['EMTSTACKTOP'] = EMTSTACKTOP; Module.asmLibraryArg['EMT_STACK_MAX'] = EMT_STACK_MAX; | |
| // EMSCRIPTEN_START_ASM | |
| var asm = (function(global, env, buffer) { | |
| 'almost asm'; | |
| var Int8View = global.Int8Array; | |
| var Int16View = global.Int16Array; | |
| var Int32View = global.Int32Array; | |
| var Uint8View = global.Uint8Array; | |
| var Uint16View = global.Uint16Array; | |
| var Uint32View = global.Uint32Array; | |
| var Float32View = global.Float32Array; | |
| var Float64View = global.Float64Array; | |
| var HEAP8 = new Int8View(buffer); | |
| var HEAP16 = new Int16View(buffer); | |
| var HEAP32 = new Int32View(buffer); | |
| var HEAPU8 = new Uint8View(buffer); | |
| var HEAPU16 = new Uint16View(buffer); | |
| var HEAPU32 = new Uint32View(buffer); | |
| var HEAPF32 = new Float32View(buffer); | |
| var HEAPF64 = new Float64View(buffer); | |
| var byteLength = global.byteLength; | |
| var STACKTOP=env.STACKTOP|0; | |
| var STACK_MAX=env.STACK_MAX|0; | |
| var tempDoublePtr=env.tempDoublePtr|0; | |
| var ABORT=env.ABORT|0; | |
| var cttz_i8=env.cttz_i8|0; | |
| var __THREW__ = 0; | |
| var threwValue = 0; | |
| var setjmpId = 0; | |
| var undef = 0; | |
| var nan = global.NaN, inf = global.Infinity; | |
| var tempInt = 0, tempBigInt = 0, tempBigIntP = 0, tempBigIntS = 0, tempBigIntR = 0.0, tempBigIntI = 0, tempBigIntD = 0, tempValue = 0, tempDouble = 0.0; | |
| var tempRet0 = 0; | |
| var tempRet1 = 0; | |
| var tempRet2 = 0; | |
| var tempRet3 = 0; | |
| var tempRet4 = 0; | |
| var tempRet5 = 0; | |
| var tempRet6 = 0; | |
| var tempRet7 = 0; | |
| var tempRet8 = 0; | |
| var tempRet9 = 0; | |
| var Math_floor=global.Math.floor; | |
| var Math_abs=global.Math.abs; | |
| var Math_sqrt=global.Math.sqrt; | |
| var Math_pow=global.Math.pow; | |
| var Math_cos=global.Math.cos; | |
| var Math_sin=global.Math.sin; | |
| var Math_tan=global.Math.tan; | |
| var Math_acos=global.Math.acos; | |
| var Math_asin=global.Math.asin; | |
| var Math_atan=global.Math.atan; | |
| var Math_atan2=global.Math.atan2; | |
| var Math_exp=global.Math.exp; | |
| var Math_log=global.Math.log; | |
| var Math_ceil=global.Math.ceil; | |
| var Math_imul=global.Math.imul; | |
| var Math_min=global.Math.min; | |
| var Math_clz32=global.Math.clz32; | |
| var abort=env.abort; | |
| var assert=env.assert; | |
| var SAFE_HEAP_LOAD=env.SAFE_HEAP_LOAD; | |
| var SAFE_HEAP_STORE=env.SAFE_HEAP_STORE; | |
| var SAFE_FT_MASK=env.SAFE_FT_MASK; | |
| var nullFunc_iiiii=env.nullFunc_iiiii; | |
| var nullFunc_vi=env.nullFunc_vi; | |
| var nullFunc_vii=env.nullFunc_vii; | |
| var nullFunc_iiii=env.nullFunc_iiii; | |
| var nullFunc_viii=env.nullFunc_viii; | |
| var nullFunc_iii=env.nullFunc_iii; | |
| var nullFunc_viiii=env.nullFunc_viiii; | |
| var invoke_iiiii=env.invoke_iiiii; | |
| var invoke_vi=env.invoke_vi; | |
| var invoke_vii=env.invoke_vii; | |
| var invoke_iiii=env.invoke_iiii; | |
| var invoke_viii=env.invoke_viii; | |
| var invoke_iii=env.invoke_iii; | |
| var invoke_viiii=env.invoke_viiii; | |
| var _emscripten_sleep=env._emscripten_sleep; | |
| var _fflush=env._fflush; | |
| var _emscripten_asm_const=env._emscripten_asm_const; | |
| var ___assert_fail=env.___assert_fail; | |
| var _strerror_r=env._strerror_r; | |
| var _emscripten_set_main_loop=env._emscripten_set_main_loop; | |
| var _abort=env._abort; | |
| var _emscripten_set_main_loop_timing=env._emscripten_set_main_loop_timing; | |
| var _sbrk=env._sbrk; | |
| var _time=env._time; | |
| var _strerror=env._strerror; | |
| var ___setErrNo=env.___setErrNo; | |
| var _emscripten_memcpy_big=env._emscripten_memcpy_big; | |
| var ___gxx_personality_v0=env.___gxx_personality_v0; | |
| var ___resumeException=env.___resumeException; | |
| var _emscripten_asm_const_int=env._emscripten_asm_const_int; | |
| var ___cxa_find_matching_catch=env.___cxa_find_matching_catch; | |
| var _sysconf=env._sysconf; | |
| var ___errno_location=env.___errno_location; | |
| var __ZSt18uncaught_exceptionv=env.__ZSt18uncaught_exceptionv; | |
| var tempFloat = 0.0; | |
| var asyncState = 0; | |
| var EMTSTACKTOP = env.EMTSTACKTOP|0; | |
| var EMT_STACK_MAX = env.EMT_STACK_MAX|0; | |
| function _emscripten_replace_memory(newBuffer) { | |
| if ((byteLength(newBuffer) & 0xffffff || byteLength(newBuffer) <= 0xffffff) || byteLength(newBuffer) > 0x80000000) return false; | |
| HEAP8 = new Int8View(newBuffer); | |
| HEAP16 = new Int16View(newBuffer); | |
| HEAP32 = new Int32View(newBuffer); | |
| HEAPU8 = new Uint8View(newBuffer); | |
| HEAPU16 = new Uint16View(newBuffer); | |
| HEAPU32 = new Uint32View(newBuffer); | |
| HEAPF32 = new Float32View(newBuffer); | |
| HEAPF64 = new Float64View(newBuffer); | |
| buffer = newBuffer; | |
| return true; | |
| } | |
| // EMSCRIPTEN_START_FUNCS | |
| function __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($first, $last, $db) { | |
| $first = $first | 0; | |
| $last = $last | 0; | |
| $db = $db | 0; | |
| var $$0 = 0, $$0$i = 0, $$0$i$i$i = 0, $$0$i$i$i$i = 0, $$0$i$i$i$i308 = 0, $$0$i$i$i$i362 = 0, $$0$i261 = 0, $$0$i320 = 0, $$0$i328 = 0, $$01$i = 0, $$01$i319 = 0, $$01$i327 = 0, $$019$i = 0, $$02$i = 0, $$02$i321 = 0, $$02$i329 = 0, $$03$i = 0, $$03$i177 = 0, $$03$i193 = 0, $$03$i204 = 0, $$03$i215 = 0, $$03$i272 = 0, $$03$i305 = 0, $$03$i471 = 0, $$03$i501 = 0, $$06$i = 0, $$06$i254 = 0, $$06$i358 = 0, $$06$i441 = 0, $$07$i = 0, $$1 = 0, $$1$i = 0, $$1$i176 = 0, $$1$i192 = 0, $$1$i203 = 0, $$1$i214 = 0, $$1$i225 = 0, $$1$i247 = 0, $$1$i271 = 0, $$1$i351 = 0, $$1$i375 = 0, $$1$i434 = 0, $$1$i470 = 0, $$1$i500 = 0, $$10 = 0, $$1019 = 0, $$110 = 0, $$12 = 0, $$12$i = 0, $$12$i175 = 0, $$12$i191 = 0, $$12$i202 = 0, $$12$i213 = 0, $$12$i224 = 0, $$12$i246 = 0, $$12$i270 = 0, $$12$i350 = 0, $$12$i433 = 0, $$12$i469 = 0, $$12$i499 = 0, $$1221 = 0, $$13$i = 0, $$14 = 0, $$14$i = 0, $$1423 = 0, $$16 = 0, $$1625 = 0, $$17 = 0, $$1726 = 0, $$18 = 0, $$18$i = 0, $$1827 = 0, $$19 = 0, $$1928 = 0, $$2 = 0, $$2$i = 0, $$2$i249 = 0, $$2$i312 = 0, $$2$i353 = 0, $$2$i376 = 0, $$2$i412 = 0, $$2$i436 = 0, $$20 = 0, $$2029 = 0, $$21 = 0, $$211 = 0, $$2130 = 0, $$22 = 0, $$221$i = 0, $$2231 = 0, $$23 = 0, $$23$i = 0, $$23$i248 = 0, $$23$i352 = 0, $$23$i435 = 0, $$2332 = 0, $$24$i = 0, $$25$i = 0, $$29$i = 0, $$3$i = 0, $$3$i251 = 0, $$3$i355 = 0, $$3$i377 = 0, $$3$i438 = 0, $$310$i = 0, $$311$i = 0, $$34$i = 0, $$34$i250 = 0, $$34$i354 = 0, $$34$i437 = 0, $$35$i = 0, $$36$i = 0, $$4 = 0, $$4$i = 0, $$4$i253 = 0, $$4$i314 = 0, $$4$i357 = 0, $$4$i378 = 0, $$4$i440 = 0, $$411$i = 0, $$413 = 0, $$45$i = 0, $$45$i252 = 0, $$45$i356 = 0, $$45$i439 = 0, $$46$i = 0, $$5 = 0, $$514 = 0, $$7 = 0, $$716 = 0, $$8 = 0, $$817 = 0, $$9 = 0, $$9$i = 0, $$918 = 0, $$first = 0, $$first$i = 0, $$ph532 = 0, $$ph534538 = 0, $$phi$trans$insert = 0, $$pre = 0, $$pre$i = 0, $$pre$i$i = 0, $$pre$i$i$i = 0, $$pre$i$i$i$i = 0, $$pre$i$i$i$i385 = 0, $$pre$i$i$i$i451 = 0, $$pre$i$i$i$i481 = 0, $$pre$i$i$i88 = 0, $$pre$i$i216 = 0, $$pre$i$i227 = 0, $$pre$i$i256 = 0, $$pre$i$i296 = 0, $$pre$i$i315 = 0, $$pre$i$i323 = 0, $$pre$i$i331 = 0, $$pre$i$i361 = 0, $$pre$i$i406 = 0, $$pre$i$i414 = 0, $$pre$i118 = 0, $$pre$i135 = 0, $$pre$i137 = 0, $$pre$i14$i = 0, $$pre$i161 = 0, $$pre$i163 = 0, $$pre$i165 = 0, $$pre$i178 = 0, $$pre$i24$i = 0, $$pre$i48$i = 0, $$pre$i67$i = 0, $$pre$i8$i = 0, $$pre$phiZ2D = 0, $$pre521 = 0, $$pre524 = 0, $0 = 0, $1 = 0, $10 = 0, $100 = 0, $1000 = 0, $1001 = 0, $1002 = 0, $1003 = 0, $1004 = 0, $1005 = 0, $1006 = 0, $1007 = 0, $1008 = 0, $1009 = 0, $101 = 0, $1010 = 0, $1011 = 0, $1012 = 0, $1013 = 0, $1014 = 0, $1015 = 0, $1016 = 0, $1017 = 0, $1018 = 0, $1019 = 0, $102 = 0, $1020 = 0, $1021 = 0, $1022 = 0, $1023 = 0, $1024 = 0, $1025 = 0, $1026 = 0, $1027 = 0, $1028 = 0, $1029 = 0, $103 = 0, $1030 = 0, $1031 = 0, $1032 = 0, $1033 = 0, $1034 = 0, $1035 = 0, $1036 = 0, $1037 = 0, $1038 = 0, $1039 = 0, $104 = 0, $1040 = 0, $1041 = 0, $1042 = 0, $1043 = 0, $1044 = 0, $1045 = 0, $1046 = 0, $1047 = 0, $1048 = 0, $1049 = 0, $105 = 0, $1050 = 0, $1051 = 0, $1052 = 0, $1053 = 0, $1054 = 0, $1055 = 0, $1056 = 0, $1057 = 0, $1058 = 0, $1059 = 0, $106 = 0, $1060 = 0, $1061 = 0, $1062 = 0, $1063 = 0, $1064 = 0, $1065 = 0, $1066 = 0, $1067 = 0, $1068 = 0, $1069 = 0, $107 = 0, $1070 = 0, $1071 = 0, $1072 = 0, $1073 = 0, $1074 = 0, $1075 = 0, $1076 = 0, $1077 = 0, $1078 = 0, $1079 = 0, $108 = 0, $1080 = 0, $1081 = 0, $1082 = 0, $1083 = 0, $1084 = 0, $1085 = 0, $1086 = 0, $1087 = 0, $1088 = 0, $1089 = 0, $109 = 0, $1090 = 0, $1091 = 0, $1092 = 0, $1093 = 0, $1094 = 0, $1095 = 0, $1096 = 0, $1097 = 0, $1098 = 0, $1099 = 0, $11 = 0, $110 = 0, $1100 = 0, $1101 = 0, $1102 = 0, $1103 = 0, $1104 = 0, $1105 = 0, $1106 = 0, $1107 = 0, $1108 = 0, $1109 = 0, $111 = 0, $1110 = 0, $1111 = 0, $1112 = 0, $1113 = 0, $1114 = 0, $1115 = 0, $1116 = 0, $1117 = 0, $1118 = 0, $1119 = 0, $112 = 0, $1120 = 0, $1121 = 0, $1122 = 0, $1123 = 0, $1124 = 0, $1125 = 0, $1126 = 0, $1127 = 0, $1128 = 0, $1129 = 0, $113 = 0, $1130 = 0, $1131 = 0, $1132 = 0, $1133 = 0, $1134 = 0, $1135 = 0, $1136 = 0, $1137 = 0, $1138 = 0, $1139 = 0, $114 = 0, $1140 = 0, $1141 = 0, $1142 = 0, $1143 = 0, $1144 = 0, $1145 = 0, $1146 = 0, $1147 = 0, $1148 = 0, $1149 = 0, $115 = 0, $1150 = 0, $1151 = 0, $1152 = 0, $1153 = 0, $1154 = 0, $1155 = 0, $1156 = 0, $1157 = 0, $1158 = 0, $1159 = 0, $116 = 0, $1160 = 0, $1161 = 0, $1162 = 0, $1163 = 0, $1164 = 0, $1165 = 0, $1166 = 0, $1167 = 0, $1168 = 0, $1169 = 0, $117 = 0, $1170 = 0, $1171 = 0, $1172 = 0, $1173 = 0, $1174 = 0, $1175 = 0, $1176 = 0, $1177 = 0, $1178 = 0, $1179 = 0, $118 = 0, $1180 = 0, $1181 = 0, $1182 = 0, $1183 = 0, $1184 = 0, $1185 = 0, $1186 = 0, $1187 = 0, $1188 = 0, $1189 = 0, $119 = 0, $1190 = 0, $1191 = 0, $1192 = 0, $1193 = 0, $1194 = 0, $1195 = 0, $1196 = 0, $1197 = 0, $1198 = 0, $1199 = 0, $12 = 0, $120 = 0, $1200 = 0, $1201 = 0, $1202 = 0, $1203 = 0, $1204 = 0, $1205 = 0, $1206 = 0, $1207 = 0, $1208 = 0, $1209 = 0, $121 = 0, $1210 = 0, $1211 = 0, $1212 = 0, $1213 = 0, $1214 = 0, $1215 = 0, $1216 = 0, $1217 = 0, $1218 = 0, $1219 = 0, $122 = 0, $1220 = 0, $1221 = 0, $1222 = 0, $1223 = 0, $1224 = 0, $1225 = 0, $1226 = 0, $1227 = 0, $1228 = 0, $1229 = 0, $123 = 0, $1230 = 0, $1231 = 0, $1232 = 0, $1233 = 0, $1234 = 0, $1235 = 0, $1236 = 0, $1237 = 0, $1238 = 0, $1239 = 0, $124 = 0, $1240 = 0, $1241 = 0, $1242 = 0, $1243 = 0, $1244 = 0, $1245 = 0, $1246 = 0, $1247 = 0, $1248 = 0, $1249 = 0, $125 = 0, $1250 = 0, $1251 = 0, $1252 = 0, $1253 = 0, $1254 = 0, $1255 = 0, $1256 = 0, $1257 = 0, $1258 = 0, $1259 = 0, $126 = 0, $1260 = 0, $1261 = 0, $1262 = 0, $1263 = 0, $1264 = 0, $1265 = 0, $1266 = 0, $1267 = 0, $1268 = 0, $1269 = 0, $127 = 0, $1270 = 0, $1271 = 0, $1272 = 0, $1273 = 0, $1274 = 0, $1275 = 0, $1276 = 0, $1277 = 0, $1278 = 0, $1279 = 0, $128 = 0, $1280 = 0, $1281 = 0, $1282 = 0, $1283 = 0, $1284 = 0, $1285 = 0, $1286 = 0, $1287 = 0, $1288 = 0, $1289 = 0, $129 = 0, $1290 = 0, $1291 = 0, $1292 = 0, $1293 = 0, $1294 = 0, $1295 = 0, $1296 = 0, $1297 = 0, $1298 = 0, $1299 = 0, $13 = 0, $130 = 0, $1300 = 0, $1301 = 0, $1302 = 0, $1303 = 0, $1304 = 0, $1305 = 0, $1306 = 0, $1307 = 0, $1308 = 0, $1309 = 0, $131 = 0, $1310 = 0, $1311 = 0, $1312 = 0, $1313 = 0, $1314 = 0, $1315 = 0, $1316 = 0, $1317 = 0, $1318 = 0, $1319 = 0, $132 = 0, $1320 = 0, $1321 = 0, $1322 = 0, $1323 = 0, $1324 = 0, $1325 = 0, $1326 = 0, $1327 = 0, $1328 = 0, $1329 = 0, $133 = 0, $1330 = 0, $1331 = 0, $1332 = 0, $1333 = 0, $1334 = 0, $1335 = 0, $1336 = 0, $1337 = 0, $1338 = 0, $1339 = 0, $134 = 0, $1340 = 0, $1341 = 0, $1342 = 0, $1343 = 0, $1344 = 0, $1345 = 0, $1346 = 0, $1347 = 0, $1348 = 0, $1349 = 0, $135 = 0, $1350 = 0, $1351 = 0, $1352 = 0, $1353 = 0, $1354 = 0, $1355 = 0, $1356 = 0, $1357 = 0, $1358 = 0, $1359 = 0, $136 = 0, $1360 = 0, $1361 = 0, $1362 = 0, $1363 = 0, $1364 = 0, $1365 = 0, $1366 = 0, $1367 = 0, $1368 = 0, $1369 = 0, $137 = 0, $1370 = 0, $1371 = 0, $1372 = 0, $1373 = 0, $1374 = 0, $1375 = 0, $1376 = 0, $1377 = 0, $1378 = 0, $1379 = 0, $138 = 0, $1380 = 0, $1381 = 0, $1382 = 0, $1383 = 0, $1384 = 0, $1385 = 0, $1386 = 0, $1387 = 0, $1388 = 0, $1389 = 0, $139 = 0, $1390 = 0, $1391 = 0, $1392 = 0, $1393 = 0, $1394 = 0, $1395 = 0, $1396 = 0, $1397 = 0, $1398 = 0, $1399 = 0, $14 = 0, $140 = 0, $1400 = 0, $1401 = 0, $1402 = 0, $1403 = 0, $1404 = 0, $1405 = 0, $1406 = 0, $1407 = 0, $1408 = 0, $1409 = 0, $141 = 0, $1410 = 0, $1411 = 0, $1412 = 0, $1413 = 0, $1414 = 0, $1415 = 0, $1416 = 0, $1417 = 0, $1418 = 0, $1419 = 0, $142 = 0, $1420 = 0, $1421 = 0, $1422 = 0, $1423 = 0, $1424 = 0, $1425 = 0, $1426 = 0, $1427 = 0, $1428 = 0, $1429 = 0, $143 = 0, $1430 = 0, $1431 = 0, $1432 = 0, $1433 = 0, $1434 = 0, $1435 = 0, $1436 = 0, $1437 = 0, $1438 = 0, $1439 = 0, $144 = 0, $1440 = 0, $1441 = 0, $1442 = 0, $1443 = 0, $1444 = 0, $1445 = 0, $1446 = 0, $1447 = 0, $1448 = 0, $1449 = 0, $145 = 0, $1450 = 0, $1451 = 0, $1452 = 0, $1453 = 0, $1454 = 0, $1455 = 0, $1456 = 0, $1457 = 0, $1458 = 0, $1459 = 0, $146 = 0, $1460 = 0, $1461 = 0, $1462 = 0, $1463 = 0, $1464 = 0, $1465 = 0, $1466 = 0, $1467 = 0, $1468 = 0, $1469 = 0, $147 = 0, $1470 = 0, $1471 = 0, $1472 = 0, $1473 = 0, $1474 = 0, $1475 = 0, $1476 = 0, $1477 = 0, $1478 = 0, $1479 = 0, $148 = 0, $1480 = 0, $1481 = 0, $1482 = 0, $1483 = 0, $1484 = 0, $1485 = 0, $1486 = 0, $1487 = 0, $1488 = 0, $1489 = 0, $149 = 0, $1490 = 0, $1491 = 0, $1492 = 0, $1493 = 0, $1494 = 0, $1495 = 0, $1496 = 0, $1497 = 0, $1498 = 0, $1499 = 0, $15 = 0, $150 = 0, $1500 = 0, $1501 = 0, $1502 = 0, $1503 = 0, $1504 = 0, $1505 = 0, $1506 = 0, $1507 = 0, $1508 = 0, $1509 = 0, $151 = 0, $1510 = 0, $1511 = 0, $1512 = 0, $1513 = 0, $1514 = 0, $1515 = 0, $1516 = 0, $1517 = 0, $1518 = 0, $1519 = 0, $152 = 0, $1520 = 0, $1521 = 0, $1522 = 0, $1523 = 0, $1524 = 0, $1525 = 0, $1526 = 0, $1527 = 0, $1528 = 0, $1529 = 0, $153 = 0, $1530 = 0, $1531 = 0, $1532 = 0, $1533 = 0, $1534 = 0, $1535 = 0, $1536 = 0, $1537 = 0, $1538 = 0, $1539 = 0, $154 = 0, $1540 = 0, $1541 = 0, $1542 = 0, $1543 = 0, $1544 = 0, $1545 = 0, $1546 = 0, $1547 = 0, $1548 = 0, $1549 = 0, $155 = 0, $1550 = 0, $1551 = 0, $1552 = 0, $1553 = 0, $1554 = 0, $1555 = 0, $1556 = 0, $1557 = 0, $1558 = 0, $1559 = 0, $156 = 0, $1560 = 0, $1561 = 0, $1562 = 0, $1563 = 0, $1564 = 0, $1565 = 0, $1566 = 0, $1567 = 0, $1568 = 0, $1569 = 0, $157 = 0, $1570 = 0, $1571 = 0, $1572 = 0, $1573 = 0, $1574 = 0, $1575 = 0, $1576 = 0, $1577 = 0, $1578 = 0, $1579 = 0, $158 = 0, $1580 = 0, $1581 = 0, $1582 = 0, $1583 = 0, $1584 = 0, $1585 = 0, $1586 = 0, $1587 = 0, $1588 = 0, $1589 = 0, $159 = 0, $1590 = 0, $1591 = 0, $1592 = 0, $1593 = 0, $1594 = 0, $1595 = 0, $1596 = 0, $1597 = 0, $1598 = 0, $1599 = 0, $16 = 0, $160 = 0, $1600 = 0, $1601 = 0, $1602 = 0, $1603 = 0, $1604 = 0, $1605 = 0, $1606 = 0, $1607 = 0, $1608 = 0, $1609 = 0, $161 = 0, $1610 = 0, $1611 = 0, $1612 = 0, $1613 = 0, $1614 = 0, $1615 = 0, $1616 = 0, $1617 = 0, $1618 = 0, $1619 = 0, $162 = 0, $1620 = 0, $1621 = 0, $1622 = 0, $1623 = 0, $1624 = 0, $1625 = 0, $1626 = 0, $1627 = 0, $1628 = 0, $1629 = 0, $163 = 0, $1630 = 0, $1631 = 0, $1632 = 0, $1633 = 0, $1634 = 0, $1635 = 0, $1636 = 0, $1637 = 0, $1638 = 0, $1639 = 0, $164 = 0, $1640 = 0, $1641 = 0, $1642 = 0, $1643 = 0, $1644 = 0, $1645 = 0, $1646 = 0, $1647 = 0, $1648 = 0, $1649 = 0, $165 = 0, $1650 = 0, $1651 = 0, $1652 = 0, $1653 = 0, $1654 = 0, $1655 = 0, $1656 = 0, $1657 = 0, $1658 = 0, $1659 = 0, $166 = 0, $1660 = 0, $1661 = 0, $1662 = 0, $1663 = 0, $1664 = 0, $1665 = 0, $1666 = 0, $1667 = 0, $1668 = 0, $1669 = 0, $167 = 0, $1670 = 0, $1671 = 0, $1672 = 0, $1673 = 0, $1674 = 0, $1675 = 0, $1676 = 0, $1677 = 0, $1678 = 0, $1679 = 0, $168 = 0, $1680 = 0, $1681 = 0, $1682 = 0, $1683 = 0, $1684 = 0, $1685 = 0, $1686 = 0, $1687 = 0, $1688 = 0, $1689 = 0, $169 = 0, $1690 = 0, $1691 = 0, $1692 = 0, $1693 = 0, $1694 = 0, $1695 = 0, $1696 = 0, $1697 = 0, $1698 = 0, $1699 = 0, $17 = 0, $170 = 0, $1700 = 0, $1701 = 0, $1702 = 0, $1703 = 0, $1704 = 0, $1705 = 0, $1706 = 0, $1707 = 0, $1708 = 0, $1709 = 0, $171 = 0, $1710 = 0, $1711 = 0, $1712 = 0, $1713 = 0, $1714 = 0, $1715 = 0, $1716 = 0, $1717 = 0, $1718 = 0, $1719 = 0, $172 = 0, $1720 = 0, $1721 = 0, $1722 = 0, $1723 = 0, $1724 = 0, $1725 = 0, $1726 = 0, $1727 = 0, $1728 = 0, $1729 = 0, $173 = 0, $1730 = 0, $1731 = 0, $1732 = 0, $1733 = 0, $1734 = 0, $1735 = 0, $1736 = 0, $1737 = 0, $1738 = 0, $1739 = 0, $174 = 0, $1740 = 0, $1741 = 0, $1742 = 0, $1743 = 0, $1744 = 0, $1745 = 0, $1746 = 0, $1747 = 0, $1748 = 0, $1749 = 0, $175 = 0, $1750 = 0, $1751 = 0, $1752 = 0, $1753 = 0, $1754 = 0, $1755 = 0, $1756 = 0, $1757 = 0, $1758 = 0, $1759 = 0, $176 = 0, $1760 = 0, $1761 = 0, $1762 = 0, $1763 = 0, $1764 = 0, $1765 = 0, $1766 = 0, $1767 = 0, $1768 = 0, $1769 = 0, $177 = 0, $1770 = 0, $1771 = 0, $1772 = 0, $1773 = 0, $1774 = 0, $1775 = 0, $1776 = 0, $1777 = 0, $1778 = 0, $1779 = 0, $178 = 0, $1780 = 0, $1781 = 0, $1782 = 0, $1783 = 0, $1784 = 0, $1785 = 0, $1786 = 0, $1787 = 0, $1788 = 0, $1789 = 0, $179 = 0, $1790 = 0, $1791 = 0, $1792 = 0, $1793 = 0, $1794 = 0, $1795 = 0, $1796 = 0, $1797 = 0, $1798 = 0, $1799 = 0, $18 = 0, $180 = 0, $1800 = 0, $1801 = 0, $1802 = 0, $1803 = 0, $1804 = 0, $1805 = 0, $1806 = 0, $1807 = 0, $1808 = 0, $1809 = 0, $181 = 0, $1810 = 0, $1811 = 0, $1812 = 0, $1813 = 0, $1814 = 0, $1815 = 0, $1816 = 0, $1817 = 0, $1818 = 0, $1819 = 0, $182 = 0, $1820 = 0, $1821 = 0, $1822 = 0, $1823 = 0, $1824 = 0, $1825 = 0, $1826 = 0, $1827 = 0, $1828 = 0, $1829 = 0, $183 = 0, $1830 = 0, $1831 = 0, $1832 = 0, $1833 = 0, $1834 = 0, $1835 = 0, $1836 = 0, $1837 = 0, $1838 = 0, $1839 = 0, $184 = 0, $1840 = 0, $1841 = 0, $1842 = 0, $1843 = 0, $1844 = 0, $1845 = 0, $1846 = 0, $1847 = 0, $1848 = 0, $1849 = 0, $185 = 0, $1850 = 0, $1851 = 0, $1852 = 0, $1853 = 0, $1854 = 0, $1855 = 0, $1856 = 0, $1857 = 0, $1858 = 0, $1859 = 0, $186 = 0, $1860 = 0, $1861 = 0, $1862 = 0, $1863 = 0, $1864 = 0, $1865 = 0, $1866 = 0, $1867 = 0, $1868 = 0, $1869 = 0, $187 = 0, $1870 = 0, $1871 = 0, $1872 = 0, $1873 = 0, $1874 = 0, $1875 = 0, $1876 = 0, $1877 = 0, $1878 = 0, $1879 = 0, $188 = 0, $1880 = 0, $1881 = 0, $1882 = 0, $1883 = 0, $1884 = 0, $1885 = 0, $1886 = 0, $1887 = 0, $1888 = 0, $1889 = 0, $189 = 0, $1890 = 0, $1891 = 0, $1892 = 0, $1893 = 0, $1894 = 0, $1895 = 0, $1896 = 0, $1897 = 0, $1898 = 0, $1899 = 0, $19 = 0, $190 = 0, $1900 = 0, $1901 = 0, $1902 = 0, $1903 = 0, $1904 = 0, $1905 = 0, $1906 = 0, $1907 = 0, $1908 = 0, $1909 = 0, $191 = 0, $1910 = 0, $1911 = 0, $1912 = 0, $1913 = 0, $1914 = 0, $1915 = 0, $1916 = 0, $1917 = 0, $1918 = 0, $1919 = 0, $192 = 0, $1920 = 0, $1921 = 0, $1922 = 0, $1923 = 0, $1924 = 0, $1925 = 0, $1926 = 0, $1927 = 0, $1928 = 0, $1929 = 0, $193 = 0, $1930 = 0, $1931 = 0, $1932 = 0, $1933 = 0, $1934 = 0, $1935 = 0, $1936 = 0, $1937 = 0, $1938 = 0, $1939 = 0, $194 = 0, $1940 = 0, $1941 = 0, $1942 = 0, $1943 = 0, $1944 = 0, $1945 = 0, $1946 = 0, $1947 = 0, $1948 = 0, $1949 = 0, $195 = 0, $1950 = 0, $1951 = 0, $1952 = 0, $1953 = 0, $1954 = 0, $1955 = 0, $1956 = 0, $1957 = 0, $1958 = 0, $1959 = 0, $196 = 0, $1960 = 0, $1961 = 0, $1962 = 0, $1963 = 0, $1964 = 0, $1965 = 0, $1966 = 0, $1967 = 0, $1968 = 0, $1969 = 0, $197 = 0, $1970 = 0, $1971 = 0, $1972 = 0, $1973 = 0, $1974 = 0, $1975 = 0, $1976 = 0, $1977 = 0, $1978 = 0, $1979 = 0, $198 = 0, $1980 = 0, $1981 = 0, $1982 = 0, $1983 = 0, $1984 = 0, $1985 = 0, $1986 = 0, $1987 = 0, $1988 = 0, $1989 = 0, $199 = 0, $1990 = 0, $1991 = 0, $1992 = 0, $1993 = 0, $1994 = 0, $1995 = 0, $1996 = 0, $1997 = 0, $1998 = 0, $1999 = 0, $2 = 0, $20 = 0, $200 = 0, $2000 = 0, $2001 = 0, $2002 = 0, $2003 = 0, $2004 = 0, $2005 = 0, $2006 = 0, $2007 = 0, $2008 = 0, $2009 = 0, $201 = 0, $2010 = 0, $2011 = 0, $2012 = 0, $2013 = 0, $2014 = 0, $2015 = 0, $2016 = 0, $2017 = 0, $2018 = 0, $2019 = 0, $202 = 0, $2020 = 0, $2021 = 0, $2022 = 0, $2023 = 0, $2024 = 0, $2025 = 0, $2026 = 0, $2027 = 0, $2028 = 0, $2029 = 0, $203 = 0, $2030 = 0, $2031 = 0, $2032 = 0, $2033 = 0, $2034 = 0, $2035 = 0, $2036 = 0, $2037 = 0, $2038 = 0, $2039 = 0, $204 = 0, $2040 = 0, $2041 = 0, $2042 = 0, $2043 = 0, $2044 = 0, $2045 = 0, $2046 = 0, $2047 = 0, $2048 = 0, $2049 = 0, $205 = 0, $2050 = 0, $2051 = 0, $2052 = 0, $2053 = 0, $2054 = 0, $2055 = 0, $2056 = 0, $2057 = 0, $2058 = 0, $2059 = 0, $206 = 0, $2060 = 0, $2061 = 0, $2062 = 0, $2063 = 0, $2064 = 0, $2065 = 0, $2066 = 0, $2067 = 0, $2068 = 0, $2069 = 0, $207 = 0, $2070 = 0, $2071 = 0, $2072 = 0, $2073 = 0, $2074 = 0, $2075 = 0, $2076 = 0, $2077 = 0, $2078 = 0, $2079 = 0, $208 = 0, $2080 = 0, $2081 = 0, $2082 = 0, $2083 = 0, $2084 = 0, $2085 = 0, $2086 = 0, $2087 = 0, $2088 = 0, $2089 = 0, $209 = 0, $2090 = 0, $2091 = 0, $2092 = 0, $2093 = 0, $2094 = 0, $2095 = 0, $2096 = 0, $2097 = 0, $2098 = 0, $2099 = 0, $21 = 0, $210 = 0, $2100 = 0, $2101 = 0, $2102 = 0, $2103 = 0, $2104 = 0, $2105 = 0, $2106 = 0, $2107 = 0, $2108 = 0, $2109 = 0, $211 = 0, $2110 = 0, $2111 = 0, $2112 = 0, $2113 = 0, $2114 = 0, $2115 = 0, $2116 = 0, $2117 = 0, $2118 = 0, $2119 = 0, $212 = 0, $2120 = 0, $2121 = 0, $2122 = 0, $2123 = 0, $2124 = 0, $2125 = 0, $2126 = 0, $2127 = 0, $2128 = 0, $2129 = 0, $213 = 0, $2130 = 0, $2131 = 0, $2132 = 0, $2133 = 0, $2134 = 0, $2135 = 0, $2136 = 0, $2137 = 0, $2138 = 0, $2139 = 0, $214 = 0, $2140 = 0, $2141 = 0, $2142 = 0, $2143 = 0, $2144 = 0, $2145 = 0, $2146 = 0, $2147 = 0, $2148 = 0, $2149 = 0, $215 = 0, $2150 = 0, $2151 = 0, $2152 = 0, $2153 = 0, $2154 = 0, $2155 = 0, $2156 = 0, $2157 = 0, $2158 = 0, $2159 = 0, $216 = 0, $2160 = 0, $2161 = 0, $2162 = 0, $2163 = 0, $2164 = 0, $2165 = 0, $2166 = 0, $2167 = 0, $2168 = 0, $2169 = 0, $217 = 0, $2170 = 0, $2171 = 0, $2172 = 0, $2173 = 0, $2174 = 0, $2175 = 0, $2176 = 0, $2177 = 0, $2178 = 0, $2179 = 0, $218 = 0, $2180 = 0, $2181 = 0, $2182 = 0, $2183 = 0, $2184 = 0, $2185 = 0, $2186 = 0, $2187 = 0, $2188 = 0, $2189 = 0, $219 = 0, $2190 = 0, $2191 = 0, $2192 = 0, $2193 = 0, $2194 = 0, $2195 = 0, $2196 = 0, $2197 = 0, $2198 = 0, $2199 = 0, $22 = 0, $220 = 0, $2200 = 0, $2201 = 0, $2202 = 0, $2203 = 0, $2204 = 0, $2205 = 0, $2206 = 0, $2207 = 0, $2208 = 0, $2209 = 0, $221 = 0, $2210 = 0, $2211 = 0, $2212 = 0, $2213 = 0, $2214 = 0, $2215 = 0, $2216 = 0, $2217 = 0, $2218 = 0, $2219 = 0, $222 = 0, $2220 = 0, $2221 = 0, $2222 = 0, $2223 = 0, $2224 = 0, $2225 = 0, $2226 = 0, $2227 = 0, $2228 = 0, $2229 = 0, $223 = 0, $2230 = 0, $2231 = 0, $2232 = 0, $2233 = 0, $2234 = 0, $2235 = 0, $2236 = 0, $2237 = 0, $2238 = 0, $2239 = 0, $224 = 0, $2240 = 0, $2241 = 0, $2242 = 0, $2243 = 0, $2244 = 0, $2245 = 0, $2246 = 0, $2247 = 0, $2248 = 0, $2249 = 0, $225 = 0, $2250 = 0, $2251 = 0, $2252 = 0, $2253 = 0, $2254 = 0, $2255 = 0, $2256 = 0, $2257 = 0, $2258 = 0, $2259 = 0, $226 = 0, $2260 = 0, $2261 = 0, $2262 = 0, $2263 = 0, $2264 = 0, $2265 = 0, $2266 = 0, $2267 = 0, $2268 = 0, $2269 = 0, $227 = 0, $2270 = 0, $2271 = 0, $2272 = 0, $2273 = 0, $2274 = 0, $2275 = 0, $2276 = 0, $2277 = 0, $2278 = 0, $2279 = 0, $228 = 0, $2280 = 0, $2281 = 0, $2282 = 0, $2283 = 0, $2284 = 0, $2285 = 0, $2286 = 0, $2287 = 0, $2288 = 0, $2289 = 0, $229 = 0, $2290 = 0, $2291 = 0, $2292 = 0, $2293 = 0, $2294 = 0, $2295 = 0, $2296 = 0, $2297 = 0, $2298 = 0, $2299 = 0, $23 = 0, $230 = 0, $2300 = 0, $2301 = 0, $2302 = 0, $2303 = 0, $2304 = 0, $2305 = 0, $2306 = 0, $2307 = 0, $2308 = 0, $2309 = 0, $231 = 0, $2310 = 0, $2311 = 0, $2312 = 0, $2313 = 0, $2314 = 0, $2315 = 0, $2316 = 0, $2317 = 0, $2318 = 0, $2319 = 0, $232 = 0, $2320 = 0, $2321 = 0, $2322 = 0, $2323 = 0, $2324 = 0, $2325 = 0, $2326 = 0, $2327 = 0, $2328 = 0, $2329 = 0, $233 = 0, $2330 = 0, $234 = 0, $235 = 0, $236 = 0, $237 = 0, $238 = 0, $239 = 0, $24 = 0, $240 = 0, $241 = 0, $242 = 0, $243 = 0, $244 = 0, $245 = 0, $246 = 0, $247 = 0, $248 = 0, $249 = 0, $25 = 0, $250 = 0, $251 = 0, $252 = 0, $253 = 0, $254 = 0, $255 = 0, $256 = 0, $257 = 0, $258 = 0, $259 = 0, $26 = 0, $260 = 0, $261 = 0, $262 = 0, $263 = 0, $264 = 0, $265 = 0, $266 = 0, $267 = 0, $268 = 0, $269 = 0, $27 = 0, $270 = 0, $271 = 0, $272 = 0, $273 = 0, $274 = 0, $275 = 0, $276 = 0, $277 = 0, $278 = 0, $279 = 0, $28 = 0, $280 = 0, $281 = 0, $282 = 0, $283 = 0, $284 = 0, $285 = 0, $286 = 0, $287 = 0, $288 = 0, $289 = 0, $29 = 0, $290 = 0, $291 = 0, $292 = 0, $293 = 0, $294 = 0, $295 = 0, $296 = 0, $297 = 0, $298 = 0, $299 = 0, $3 = 0, $30 = 0, $300 = 0, $301 = 0, $302 = 0, $303 = 0, $304 = 0, $305 = 0, $306 = 0, $307 = 0, $308 = 0, $309 = 0, $31 = 0, $310 = 0, $311 = 0, $312 = 0, $313 = 0, $314 = 0, $315 = 0, $316 = 0, $317 = 0, $318 = 0, $319 = 0, $32 = 0, $320 = 0, $321 = 0, $322 = 0, $323 = 0, $324 = 0, $325 = 0, $326 = 0, $327 = 0, $328 = 0, $329 = 0, $33 = 0, $330 = 0, $331 = 0, $332 = 0, $333 = 0, $334 = 0, $335 = 0, $336 = 0, $337 = 0, $338 = 0, $339 = 0, $34 = 0, $340 = 0, $341 = 0, $342 = 0, $343 = 0, $344 = 0, $345 = 0, $346 = 0, $347 = 0, $348 = 0, $349 = 0, $35 = 0, $350 = 0, $351 = 0, $352 = 0, $353 = 0, $354 = 0, $355 = 0, $356 = 0, $357 = 0, $358 = 0, $359 = 0, $36 = 0, $360 = 0, $361 = 0, $362 = 0, $363 = 0, $364 = 0, $365 = 0, $366 = 0, $367 = 0, $368 = 0, $369 = 0, $37 = 0, $370 = 0, $371 = 0, $372 = 0, $373 = 0, $374 = 0, $375 = 0, $376 = 0, $377 = 0, $378 = 0, $379 = 0, $38 = 0, $380 = 0, $381 = 0, $382 = 0, $383 = 0, $384 = 0, $385 = 0, $386 = 0, $387 = 0, $388 = 0, $389 = 0, $39 = 0, $390 = 0, $391 = 0, $392 = 0, $393 = 0, $394 = 0, $395 = 0, $396 = 0, $397 = 0, $398 = 0, $399 = 0, $4 = 0, $40 = 0, $400 = 0, $401 = 0, $402 = 0, $403 = 0, $404 = 0, $405 = 0, $406 = 0, $407 = 0, $408 = 0, $409 = 0, $41 = 0, $410 = 0, $411 = 0, $412 = 0, $413 = 0, $414 = 0, $415 = 0, $416 = 0, $417 = 0, $418 = 0, $419 = 0, $42 = 0, $420 = 0, $421 = 0, $422 = 0, $423 = 0, $424 = 0, $425 = 0, $426 = 0, $427 = 0, $428 = 0, $429 = 0, $43 = 0, $430 = 0, $431 = 0, $432 = 0, $433 = 0, $434 = 0, $435 = 0, $436 = 0, $437 = 0, $438 = 0, $439 = 0, $44 = 0, $440 = 0, $441 = 0, $442 = 0, $443 = 0, $444 = 0, $445 = 0, $446 = 0, $447 = 0, $448 = 0, $449 = 0, $45 = 0, $450 = 0, $451 = 0, $452 = 0, $453 = 0, $454 = 0, $455 = 0, $456 = 0, $457 = 0, $458 = 0, $459 = 0, $46 = 0, $460 = 0, $461 = 0, $462 = 0, $463 = 0, $464 = 0, $465 = 0, $466 = 0, $467 = 0, $468 = 0, $469 = 0, $47 = 0, $470 = 0, $471 = 0, $472 = 0, $473 = 0, $474 = 0, $475 = 0, $476 = 0, $477 = 0, $478 = 0, $479 = 0, $48 = 0, $480 = 0, $481 = 0, $482 = 0, $483 = 0, $484 = 0, $485 = 0, $486 = 0, $487 = 0, $488 = 0, $489 = 0, $49 = 0, $490 = 0, $491 = 0, $492 = 0, $493 = 0, $494 = 0, $495 = 0, $496 = 0, $497 = 0, $498 = 0, $499 = 0, $5 = 0, $50 = 0, $500 = 0, $501 = 0, $502 = 0, $503 = 0, $504 = 0, $505 = 0, $506 = 0, $507 = 0, $508 = 0, $509 = 0, $51 = 0, $510 = 0, $511 = 0, $512 = 0, $513 = 0, $514 = 0, $515 = 0, $516 = 0, $517 = 0, $518 = 0, $519 = 0, $52 = 0, $520 = 0, $521 = 0, $522 = 0, $523 = 0, $524 = 0, $525 = 0, $526 = 0, $527 = 0, $528 = 0, $529 = 0, $53 = 0, $530 = 0, $531 = 0, $532 = 0, $533 = 0, $534 = 0, $535 = 0, $536 = 0, $537 = 0, $538 = 0, $539 = 0, $54 = 0, $540 = 0, $541 = 0, $542 = 0, $543 = 0, $544 = 0, $545 = 0, $546 = 0, $547 = 0, $548 = 0, $549 = 0, $55 = 0, $550 = 0, $551 = 0, $552 = 0, $553 = 0, $554 = 0, $555 = 0, $556 = 0, $557 = 0, $558 = 0, $559 = 0, $56 = 0, $560 = 0, $561 = 0, $562 = 0, $563 = 0, $564 = 0, $565 = 0, $566 = 0, $567 = 0, $568 = 0, $569 = 0, $57 = 0, $570 = 0, $571 = 0, $572 = 0, $573 = 0, $574 = 0, $575 = 0, $576 = 0, $577 = 0, $578 = 0, $579 = 0, $58 = 0, $580 = 0, $581 = 0, $582 = 0, $583 = 0, $584 = 0, $585 = 0, $586 = 0, $587 = 0, $588 = 0, $589 = 0, $59 = 0, $590 = 0, $591 = 0, $592 = 0, $593 = 0, $594 = 0, $595 = 0, $596 = 0, $597 = 0, $598 = 0, $599 = 0, $6 = 0, $60 = 0, $600 = 0, $601 = 0, $602 = 0, $603 = 0, $604 = 0, $605 = 0, $606 = 0, $607 = 0, $608 = 0, $609 = 0, $61 = 0, $610 = 0, $611 = 0, $612 = 0, $613 = 0, $614 = 0, $615 = 0, $616 = 0, $617 = 0, $618 = 0, $619 = 0, $62 = 0, $620 = 0, $621 = 0, $622 = 0, $623 = 0, $624 = 0, $625 = 0, $626 = 0, $627 = 0, $628 = 0, $629 = 0, $63 = 0, $630 = 0, $631 = 0, $632 = 0, $633 = 0, $634 = 0, $635 = 0, $636 = 0, $637 = 0, $638 = 0, $639 = 0, $64 = 0, $640 = 0, $641 = 0, $642 = 0, $643 = 0, $644 = 0, $645 = 0, $646 = 0, $647 = 0, $648 = 0, $649 = 0, $65 = 0, $650 = 0, $651 = 0, $652 = 0, $653 = 0, $654 = 0, $655 = 0, $656 = 0, $657 = 0, $658 = 0, $659 = 0, $66 = 0, $660 = 0, $661 = 0, $662 = 0, $663 = 0, $664 = 0, $665 = 0, $666 = 0, $667 = 0, $668 = 0, $669 = 0, $67 = 0, $670 = 0, $671 = 0, $672 = 0, $673 = 0, $674 = 0, $675 = 0, $676 = 0, $677 = 0, $678 = 0, $679 = 0, $68 = 0, $680 = 0, $681 = 0, $682 = 0, $683 = 0, $684 = 0, $685 = 0, $686 = 0, $687 = 0, $688 = 0, $689 = 0, $69 = 0, $690 = 0, $691 = 0, $692 = 0, $693 = 0, $694 = 0, $695 = 0, $696 = 0, $697 = 0, $698 = 0, $699 = 0, $7 = 0, $70 = 0, $700 = 0, $701 = 0, $702 = 0, $703 = 0, $704 = 0, $705 = 0, $706 = 0, $707 = 0, $708 = 0, $709 = 0, $71 = 0, $710 = 0, $711 = 0, $712 = 0, $713 = 0, $714 = 0, $715 = 0, $716 = 0, $717 = 0, $718 = 0, $719 = 0, $72 = 0, $720 = 0, $721 = 0, $722 = 0, $723 = 0, $724 = 0, $725 = 0, $726 = 0, $727 = 0, $728 = 0, $729 = 0, $73 = 0, $730 = 0, $731 = 0, $732 = 0, $733 = 0, $734 = 0, $735 = 0, $736 = 0, $737 = 0, $738 = 0, $739 = 0, $74 = 0, $740 = 0, $741 = 0, $742 = 0, $743 = 0, $744 = 0, $745 = 0, $746 = 0, $747 = 0, $748 = 0, $749 = 0, $75 = 0, $750 = 0, $751 = 0, $752 = 0, $753 = 0, $754 = 0, $755 = 0, $756 = 0, $757 = 0, $758 = 0, $759 = 0, $76 = 0, $760 = 0, $761 = 0, $762 = 0, $763 = 0, $764 = 0, $765 = 0, $766 = 0, $767 = 0, $768 = 0, $769 = 0, $77 = 0, $770 = 0, $771 = 0, $772 = 0, $773 = 0, $774 = 0, $775 = 0, $776 = 0, $777 = 0, $778 = 0, $779 = 0, $78 = 0, $780 = 0, $781 = 0, $782 = 0, $783 = 0, $784 = 0, $785 = 0, $786 = 0, $787 = 0, $788 = 0, $789 = 0, $79 = 0, $790 = 0, $791 = 0, $792 = 0, $793 = 0, $794 = 0, $795 = 0, $796 = 0, $797 = 0, $798 = 0, $799 = 0, $8 = 0, $80 = 0, $800 = 0, $801 = 0, $802 = 0, $803 = 0, $804 = 0, $805 = 0, $806 = 0, $807 = 0, $808 = 0, $809 = 0, $81 = 0, $810 = 0, $811 = 0, $812 = 0, $813 = 0, $814 = 0, $815 = 0, $816 = 0, $817 = 0, $818 = 0, $819 = 0, $82 = 0, $820 = 0, $821 = 0, $822 = 0, $823 = 0, $824 = 0, $825 = 0, $826 = 0, $827 = 0, $828 = 0, $829 = 0, $83 = 0, $830 = 0, $831 = 0, $832 = 0, $833 = 0, $834 = 0, $835 = 0, $836 = 0, $837 = 0, $838 = 0, $839 = 0, $84 = 0, $840 = 0, $841 = 0, $842 = 0, $843 = 0, $844 = 0, $845 = 0, $846 = 0, $847 = 0, $848 = 0, $849 = 0, $85 = 0, $850 = 0, $851 = 0, $852 = 0, $853 = 0, $854 = 0, $855 = 0, $856 = 0, $857 = 0, $858 = 0, $859 = 0, $86 = 0, $860 = 0, $861 = 0, $862 = 0, $863 = 0, $864 = 0, $865 = 0, $866 = 0, $867 = 0, $868 = 0, $869 = 0, $87 = 0, $870 = 0, $871 = 0, $872 = 0, $873 = 0, $874 = 0, $875 = 0, $876 = 0, $877 = 0, $878 = 0, $879 = 0, $88 = 0, $880 = 0, $881 = 0, $882 = 0, $883 = 0, $884 = 0, $885 = 0, $886 = 0, $887 = 0, $888 = 0, $889 = 0, $89 = 0, $890 = 0, $891 = 0, $892 = 0, $893 = 0, $894 = 0, $895 = 0, $896 = 0, $897 = 0, $898 = 0, $899 = 0, $9 = 0, $90 = 0, $900 = 0, $901 = 0, $902 = 0, $903 = 0, $904 = 0, $905 = 0, $906 = 0, $907 = 0, $908 = 0, $909 = 0, $91 = 0, $910 = 0, $911 = 0, $912 = 0, $913 = 0, $914 = 0, $915 = 0, $916 = 0, $917 = 0, $918 = 0, $919 = 0, $92 = 0, $920 = 0, $921 = 0, $922 = 0, $923 = 0, $924 = 0, $925 = 0, $926 = 0, $927 = 0, $928 = 0, $929 = 0, $93 = 0, $930 = 0, $931 = 0, $932 = 0, $933 = 0, $934 = 0, $935 = 0, $936 = 0, $937 = 0, $938 = 0, $939 = 0, $94 = 0, $940 = 0, $941 = 0, $942 = 0, $943 = 0, $944 = 0, $945 = 0, $946 = 0, $947 = 0, $948 = 0, $949 = 0, $95 = 0, $950 = 0, $951 = 0, $952 = 0, $953 = 0, $954 = 0, $955 = 0, $956 = 0, $957 = 0, $958 = 0, $959 = 0, $96 = 0, $960 = 0, $961 = 0, $962 = 0, $963 = 0, $964 = 0, $965 = 0, $966 = 0, $967 = 0, $968 = 0, $969 = 0, $97 = 0, $970 = 0, $971 = 0, $972 = 0, $973 = 0, $974 = 0, $975 = 0, $976 = 0, $977 = 0, $978 = 0, $979 = 0, $98 = 0, $980 = 0, $981 = 0, $982 = 0, $983 = 0, $984 = 0, $985 = 0, $986 = 0, $987 = 0, $988 = 0, $989 = 0, $99 = 0, $990 = 0, $991 = 0, $992 = 0, $993 = 0, $994 = 0, $995 = 0, $996 = 0, $997 = 0, $998 = 0, $999 = 0, $__i$0$i$i = 0, $__i$0$i$i$i = 0, $__i$0$i$i$i$i = 0, $__i$0$i$i$i$i$i = 0, $__i$0$i$i$i$i$i$i$i = 0, $__i$0$i$i$i$i$i$i$i$i = 0, $__i$0$i$i$i$i$i293 = 0, $__i$0$i$i$i$i$i400 = 0, $__i$0$i$i$i$i$i466 = 0, $__i$0$i$i$i$i$i496 = 0, $__i$0$i$i$i$i103 = 0, $__i$0$i$i$i$i167 = 0, $__i$0$i$i$i$i172 = 0, $__i$0$i$i$i$i181 = 0, $__i$0$i$i$i$i185 = 0, $__i$0$i$i$i$i195 = 0, $__i$0$i$i$i$i206 = 0, $__i$0$i$i$i$i219 = 0, $__i$0$i$i$i$i230 = 0, $__i$0$i$i$i$i263 = 0, $__i$0$i$i$i$i300 = 0, $__i$0$i$i$i$i334 = 0, $__i$0$i$i$i$i369 = 0, $__i$0$i$i$i$i417 = 0, $__i$0$i$i$i$i443 = 0, $__i$0$i$i$i$i45$i = 0, $__i$0$i$i$i$i473 = 0, $__i$0$i$i$i106 = 0, $__i$0$i$i$i11$i = 0, $__i$0$i$i$i11$i239 = 0, $__i$0$i$i$i11$i343 = 0, $__i$0$i$i$i11$i426 = 0, $__i$0$i$i$i111 = 0, $__i$0$i$i$i114 = 0, $__i$0$i$i$i120 = 0, $__i$0$i$i$i123 = 0, $__i$0$i$i$i127 = 0, $__i$0$i$i$i131 = 0, $__i$0$i$i$i139 = 0, $__i$0$i$i$i14$i = 0, $__i$0$i$i$i14$i243 = 0, $__i$0$i$i$i14$i347 = 0, $__i$0$i$i$i14$i430 = 0, $__i$0$i$i$i144 = 0, $__i$0$i$i$i148 = 0, $__i$0$i$i$i15$i = 0, $__i$0$i$i$i153 = 0, $__i$0$i$i$i157 = 0, $__i$0$i$i$i169 = 0, $__i$0$i$i$i18$i = 0, $__i$0$i$i$i21$i = 0, $__i$0$i$i$i275 = 0, $__i$0$i$i$i381 = 0, $__i$0$i$i$i5$i = 0, $__i$0$i$i$i5$i189 = 0, $__i$0$i$i$i5$i199 = 0, $__i$0$i$i$i5$i210 = 0, $__i$0$i$i$i5$i267 = 0, $__i$0$i$i$i5$i447 = 0, $__i$0$i$i$i5$i477 = 0, $__i$0$i$i$i58$i = 0, $__i$0$i$i$i72 = 0, $__i$0$i$i$i78 = 0, $__i$0$i$i$i8$i = 0, $__i$0$i$i$i8$i234 = 0, $__i$0$i$i$i8$i338 = 0, $__i$0$i$i$i8$i421 = 0, $__i$0$i$i$i83 = 0, $__i$0$i$i1$i$i$i$i$i = 0, $__i$0$i$i1$i$i$i$i$i$i = 0, $__i$0$i$i26$i = 0, $__i$0$i$i50$i = 0, $__i$0$i$i65$i = 0, $__i$0$i$i75 = 0, $__v$i$i = 0, $__v$i$i$i = 0, $__v$i$i$i273 = 0, $__v$i$i$i359 = 0, $exitcond$i$i = 0, $exitcond$i$i$i = 0, $exitcond$i$i$i$i = 0, $exitcond$i$i$i$i$i = 0, $exitcond$i$i$i$i$i$i$i = 0, $exitcond$i$i$i$i$i$i$i$i = 0, $exitcond$i$i$i$i$i294 = 0, $exitcond$i$i$i$i$i401 = 0, $exitcond$i$i$i$i$i467 = 0, $exitcond$i$i$i$i$i497 = 0, $exitcond$i$i$i$i104 = 0, $exitcond$i$i$i$i168 = 0, $exitcond$i$i$i$i173 = 0, $exitcond$i$i$i$i182 = 0, $exitcond$i$i$i$i186 = 0, $exitcond$i$i$i$i196 = 0, $exitcond$i$i$i$i207 = 0, $exitcond$i$i$i$i220 = 0, $exitcond$i$i$i$i231 = 0, $exitcond$i$i$i$i264 = 0, $exitcond$i$i$i$i301 = 0, $exitcond$i$i$i$i335 = 0, $exitcond$i$i$i$i370 = 0, $exitcond$i$i$i$i418 = 0, $exitcond$i$i$i$i444 = 0, $exitcond$i$i$i$i46$i = 0, $exitcond$i$i$i$i474 = 0, $exitcond$i$i$i107 = 0, $exitcond$i$i$i112 = 0, $exitcond$i$i$i115 = 0, $exitcond$i$i$i12$i = 0, $exitcond$i$i$i12$i240 = 0, $exitcond$i$i$i12$i344 = 0, $exitcond$i$i$i12$i427 = 0, $exitcond$i$i$i121 = 0, $exitcond$i$i$i124 = 0, $exitcond$i$i$i128 = 0, $exitcond$i$i$i132 = 0, $exitcond$i$i$i140 = 0, $exitcond$i$i$i145 = 0, $exitcond$i$i$i149 = 0, $exitcond$i$i$i15$i = 0, $exitcond$i$i$i15$i244 = 0, $exitcond$i$i$i15$i348 = 0, $exitcond$i$i$i15$i431 = 0, $exitcond$i$i$i154 = 0, $exitcond$i$i$i158 = 0, $exitcond$i$i$i16$i = 0, $exitcond$i$i$i170 = 0, $exitcond$i$i$i19$i = 0, $exitcond$i$i$i22$i = 0, $exitcond$i$i$i276 = 0, $exitcond$i$i$i382 = 0, $exitcond$i$i$i59$i = 0, $exitcond$i$i$i6$i = 0, $exitcond$i$i$i6$i190 = 0, $exitcond$i$i$i6$i200 = 0, $exitcond$i$i$i6$i211 = 0, $exitcond$i$i$i6$i268 = 0, $exitcond$i$i$i6$i448 = 0, $exitcond$i$i$i6$i478 = 0, $exitcond$i$i$i73 = 0, $exitcond$i$i$i79 = 0, $exitcond$i$i$i84 = 0, $exitcond$i$i$i9$i = 0, $exitcond$i$i$i9$i235 = 0, $exitcond$i$i$i9$i339 = 0, $exitcond$i$i$i9$i422 = 0, $exitcond$i$i2$i$i$i$i$i = 0, $exitcond$i$i2$i$i$i$i$i$i = 0, $exitcond$i$i27$i = 0, $exitcond$i$i51$i = 0, $exitcond$i$i66$i = 0, $exitcond$i$i76 = 0, $expr$i = 0, $expr$i226 = 0, $expr$i322 = 0, $expr$i330 = 0, $expr$i413 = 0, $expr_list$i = 0, $first$ = 0, $first$$i = 0, $first$33 = 0, $first$34 = 0, $first$35 = 0, $first$36 = 0, $first$37 = 0, $first$38 = 0, $first$39 = 0, $first$40 = 0, $first$41 = 0, $first$42 = 0, $first$43 = 0, $first$44 = 0, $first$45 = 0, $first$46 = 0, $first$47 = 0, $first$48 = 0, $first$49 = 0, $first$50 = 0, $first$51 = 0, $first$52 = 0, $first$53 = 0, $first$54 = 0, $first$55 = 0, $first$56 = 0, $first$57 = 0, $first$58 = 0, $first$59 = 0, $first$60 = 0, $first$61 = 0, $first$62 = 0, $first$63 = 0, $first$64 = 0, $first$65 = 0, $first$66 = 0, $first$67 = 0, $first$68 = 0, $first$69 = 0, $first$70 = 0, $first$71 = 0, $has_expr_list$0$off0$i = 0, $has_expr_list$0$off0$i$lcssa = 0, $has_init$0$off0$i527 = 0, $init_list$i = 0, $k$0$i = 0, $k$0$in$i = 0, $k1$0$i = 0, $lpad$phi$i$index = 0, $lpad$phi$i$index2 = 0, $name$i = 0, $op1 = 0, $op18 = 0, $op2 = 0, $op27 = 0, $op3 = 0, $or$cond = 0, $or$cond$i = 0, $or$cond$i$i$i$i$i = 0, $or$cond$i$i$i$i$i$i = 0, $or$cond$i$i$i$i$i$i285 = 0, $or$cond$i$i$i$i$i$i392 = 0, $or$cond$i$i$i$i$i$i458 = 0, $or$cond$i$i$i$i$i$i488 = 0, $or$cond$i$i$i$i$i37$i = 0, $or$cond$i$i$i$i$i95 = 0, $or$cond$i360 = 0, $or$cond$i405 = 0, $or$cond13$i = 0, $or$cond22$i = 0, $or$cond23$i = 0, $or$cond5$i = 0, $parsed_gs$0$off0 = 0, $parsed_gs$0$off0$i = 0, $phitmp$i$i$i$i$i$i = 0, $phitmp$i$i$i$i$i$i$i = 0, $phitmp$i$i$i$i$i$i$i280 = 0, $phitmp$i$i$i$i$i$i$i387 = 0, $phitmp$i$i$i$i$i$i$i453 = 0, $phitmp$i$i$i$i$i$i$i483 = 0, $phitmp$i$i$i$i$i$i32$i = 0, $phitmp$i$i$i$i$i$i90 = 0, $phitmp$i2$i$i$i$i$i = 0, $phitmp$i2$i$i$i$i$i$i = 0, $phitmp$i2$i$i$i$i$i$i283 = 0, $phitmp$i2$i$i$i$i$i$i390 = 0, $phitmp$i2$i$i$i$i$i$i456 = 0, $phitmp$i2$i$i$i$i$i$i486 = 0, $phitmp$i2$i$i$i$i$i35$i = 0, $phitmp$i2$i$i$i$i$i93 = 0, $r$i = 0, $t$0 = 0, $t$0$i = 0, $t$0$i274 = 0, $t$0$i364 = 0, $t$0$i364$lcssa = 0, $t$0$i403 = 0, $t$0$i403$lcssa = 0, $t$1$i = 0, $t$1$i$lcssa = 0, $t$1$i365 = 0, $t$2$i = 0, $t$2$i$lcssa = 0, $t$2$i366 = 0, $t$3$i526 = 0, $tmp$i = 0, $tmp$i255 = 0, $tmp$i379 = 0, $tmp2$i = 0, $type$i = 0, dest = 0, label = 0, sp = 0, src = 0, stop = 0; | |
| label = 0; | |
| sp = STACKTOP; | |
| STACKTOP = STACKTOP + 2240 | 0; | |
| asyncState ? abort(-12) | 0 : 0; | |
| if ((STACKTOP | 0) >= (STACK_MAX | 0)) abort(), asyncState ? abort(-12) | 0 : 0; | |
| $0 = sp + 2216 | 0; | |
| $1 = sp + 2180 | 0; | |
| $2 = sp + 2148 | 0; | |
| $3 = sp + 2088 | 0; | |
| $4 = sp + 2012 | 0; | |
| $5 = sp + 944 | 0; | |
| $expr$i413 = sp + 980 | 0; | |
| $6 = sp + 1008 | 0; | |
| $7 = sp + 1032 | 0; | |
| $8 = sp + 992 | 0; | |
| $9 = sp + 72 | 0; | |
| $10 = sp + 84 | 0; | |
| $11 = sp + 96 | 0; | |
| $12 = sp + 108 | 0; | |
| $tmp$i379 = sp + 120 | 0; | |
| $__v$i$i$i359 = sp + 1944 | 0; | |
| $tmp2$i = sp + 132 | 0; | |
| $13 = sp + 144 | 0; | |
| $14 = sp + 168 | 0; | |
| $15 = sp + 180 | 0; | |
| $16 = sp + 192 | 0; | |
| $17 = sp + 204 | 0; | |
| $18 = sp + 216 | 0; | |
| $expr$i330 = sp + 228 | 0; | |
| $19 = sp + 240 | 0; | |
| $20 = sp + 264 | 0; | |
| $21 = sp + 276 | 0; | |
| $22 = sp + 288 | 0; | |
| $23 = sp + 300 | 0; | |
| $24 = sp + 312 | 0; | |
| $expr$i322 = sp + 324 | 0; | |
| $25 = sp + 1932 | 0; | |
| $name$i = sp + 336 | 0; | |
| $26 = sp + 348 | 0; | |
| $__v$i$i$i273 = sp + 360 | 0; | |
| $init_list$i = sp + 380 | 0; | |
| $27 = sp + 392 | 0; | |
| $type$i = sp + 404 | 0; | |
| $expr_list$i = sp + 416 | 0; | |
| $28 = sp + 428 | 0; | |
| $r$i = sp + 440 | 0; | |
| $29 = sp + 452 | 0; | |
| $30 = sp + 464 | 0; | |
| $31 = sp + 476 | 0; | |
| $32 = sp + 488 | 0; | |
| $33 = sp + 504 | 0; | |
| $34 = sp + 528 | 0; | |
| $35 = sp + 540 | 0; | |
| $36 = sp + 552 | 0; | |
| $37 = sp + 564 | 0; | |
| $tmp$i255 = sp + 576 | 0; | |
| $expr$i226 = sp + 588 | 0; | |
| $38 = sp + 600 | 0; | |
| $39 = sp + 624 | 0; | |
| $40 = sp + 636 | 0; | |
| $41 = sp + 648 | 0; | |
| $42 = sp + 660 | 0; | |
| $43 = sp + 672 | 0; | |
| $expr$i = sp + 684 | 0; | |
| $44 = sp + 696 | 0; | |
| $45 = sp + 720 | 0; | |
| $46 = sp + 732 | 0; | |
| $47 = sp + 744 | 0; | |
| $48 = sp + 1920 | 0; | |
| $49 = sp + 756 | 0; | |
| $50 = sp + 768 | 0; | |
| $51 = sp + 792 | 0; | |
| $52 = sp + 804 | 0; | |
| $53 = sp + 816 | 0; | |
| $54 = sp + 832 | 0; | |
| $55 = sp + 856 | 0; | |
| $56 = sp + 868 | 0; | |
| $57 = sp + 880 | 0; | |
| $58 = sp + 896 | 0; | |
| $59 = sp + 920 | 0; | |
| $60 = sp + 932 | 0; | |
| $61 = sp + 2036 | 0; | |
| $62 = sp + 2064 | 0; | |
| $63 = sp + 2100 | 0; | |
| $64 = sp + 2136 | 0; | |
| $__v$i$i = sp + 2160 | 0; | |
| $65 = sp + 2192 | 0; | |
| $66 = sp + 2228 | 0; | |
| $67 = sp + 1044 | 0; | |
| $68 = sp + 1056 | 0; | |
| $__v$i$i$i = sp + 1068 | 0; | |
| $tmp$i = sp + 1088 | 0; | |
| $69 = sp + 1100 | 0; | |
| $70 = sp + 1112 | 0; | |
| $71 = sp + 1124 | 0; | |
| $72 = sp + 1136 | 0; | |
| $73 = sp + 1160 | 0; | |
| $74 = sp + 1172 | 0; | |
| $75 = sp + 1184 | 0; | |
| $76 = sp + 1196 | 0; | |
| $77 = sp + 1208 | 0; | |
| $78 = sp + 1220 | 0; | |
| $79 = sp + 1232 | 0; | |
| $80 = sp + 1244 | 0; | |
| $81 = sp + 1256 | 0; | |
| $82 = sp + 1268 | 0; | |
| $83 = sp + 1280 | 0; | |
| $84 = sp + 1292 | 0; | |
| $85 = sp + 1304 | 0; | |
| $86 = sp + 1316 | 0; | |
| $87 = sp + 1328 | 0; | |
| $88 = sp + 1340 | 0; | |
| $89 = sp + 1352 | 0; | |
| $90 = sp + 1364 | 0; | |
| $91 = sp + 1376 | 0; | |
| $92 = sp + 1388 | 0; | |
| $93 = sp + 1400 | 0; | |
| $94 = sp + 1412 | 0; | |
| $95 = sp + 1424 | 0; | |
| $96 = sp + 1436 | 0; | |
| $op2 = sp + 1448 | 0; | |
| $op1 = sp + 1460 | 0; | |
| $97 = sp + 1472 | 0; | |
| $98 = sp + 1496 | 0; | |
| $99 = sp + 1508 | 0; | |
| $100 = sp + 1520 | 0; | |
| $101 = sp + 1532 | 0; | |
| $102 = sp + 1544 | 0; | |
| $103 = sp + 1556 | 0; | |
| $104 = sp + 1568 | 0; | |
| $105 = sp + 1580 | 0; | |
| $106 = sp + 1592 | 0; | |
| $107 = sp + 1908 | 0; | |
| $108 = sp + 1604 | 0; | |
| $109 = sp + 1616 | 0; | |
| $110 = sp + 1628 | 0; | |
| $111 = sp + 1640 | 0; | |
| $112 = sp + 1664 | 0; | |
| $113 = sp + 1676 | 0; | |
| $114 = sp + 1688 | 0; | |
| $115 = sp + 1700 | 0; | |
| $116 = sp + 1712 | 0; | |
| $117 = sp + 1724 | 0; | |
| $118 = sp + 1736 | 0; | |
| $119 = sp + 1748 | 0; | |
| $120 = sp + 1760 | 0; | |
| $121 = sp + 1772 | 0; | |
| $122 = sp + 1784 | 0; | |
| $123 = sp + 1796 | 0; | |
| $124 = sp + 1808 | 0; | |
| $125 = sp + 1824 | 0; | |
| $126 = sp + 1848 | 0; | |
| $127 = sp + 1860 | 0; | |
| $128 = sp + 1872 | 0; | |
| $129 = sp + 1884 | 0; | |
| $op3 = sp + 1896 | 0; | |
| $op27 = sp + 60 | 0; | |
| $op18 = sp + 24 | 0; | |
| $130 = sp + 1976 | 0; | |
| $131 = sp + 36 | 0; | |
| $132 = sp; | |
| $133 = sp + 12 | 0; | |
| $134 = sp + 1964 | 0; | |
| $135 = sp + 2e3 | 0; | |
| $136 = sp + 48 | 0; | |
| $137 = sp + 2024 | 0; | |
| $138 = sp + 956 | 0; | |
| $139 = sp + 2048 | 0; | |
| $140 = sp + 968 | 0; | |
| $141 = sp + 2112 | 0; | |
| $142 = $last; | |
| $143 = $first; | |
| $144 = $142 - $143 | 0; | |
| $145 = ($144 | 0) > 1; | |
| L1 : do { | |
| if ($145) { | |
| $146 = ($144 | 0) > 3; | |
| if ($146) { | |
| $147 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $148 = $147 << 24 >> 24 == 103; | |
| if ($148) { | |
| $149 = $first + 1 | 0; | |
| $150 = (tempInt = SAFE_HEAP_LOAD($149 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $151 = $150 << 24 >> 24 == 115; | |
| $152 = $first + 2 | 0; | |
| $$first = $151 ? $152 : $first; | |
| $parsed_gs$0$off0 = $151; | |
| $t$0 = $$first; | |
| } else { | |
| $parsed_gs$0$off0 = 0; | |
| $t$0 = $first; | |
| } | |
| } else { | |
| $parsed_gs$0$off0 = 0; | |
| $t$0 = $first; | |
| } | |
| $153 = (tempInt = SAFE_HEAP_LOAD($t$0 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $154 = $153 << 24 >> 24; | |
| L7 : do { | |
| switch ($154 | 0) { | |
| case 100: | |
| { | |
| $675 = $t$0 + 1 | 0; | |
| $676 = (tempInt = SAFE_HEAP_LOAD($675 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $677 = $676 << 24 >> 24; | |
| switch ($677 | 0) { | |
| case 97: | |
| { | |
| $678 = $t$0 + 2 | 0; | |
| $679 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($678, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $680 = ($679 | 0) == ($678 | 0); | |
| if ($680) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $681 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $682 = $db + 4 | 0; | |
| $683 = (tempInt = SAFE_HEAP_LOAD($682 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $684 = ($681 | 0) == ($683 | 0); | |
| if ($684) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $685 = $683 + -24 | 0; | |
| if ($parsed_gs$0$off0) { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($83, 2936, 2), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $__i$0$i$i = 0; | |
| while (1) { | |
| $exitcond$i$i = ($__i$0$i$i | 0) == 3; | |
| if ($exitcond$i$i) { | |
| break; | |
| } | |
| $686 = $83 + ($__i$0$i$i << 2) | 0; | |
| SAFE_HEAP_STORE($686 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $687 = $__i$0$i$i + 1 | 0; | |
| $__i$0$i$i = $687; | |
| } | |
| } | |
| __THREW__ = 0; | |
| $688 = (tempInt = invoke_iii(5, $83 | 0, 2944 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $689 = __THREW__; | |
| __THREW__ = 0; | |
| $690 = $689 & 1; | |
| if ($690) { | |
| $760 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $761 = tempRet0; | |
| $$2 = $760; | |
| $$211 = $761; | |
| } else { | |
| SAFE_HEAP_STORE($82 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($688 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($82 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($688 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($82 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($688 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i = ($__i$0$i$i$i | 0) == 3; | |
| if ($exitcond$i$i$i) { | |
| break; | |
| } | |
| $691 = $688 + ($__i$0$i$i$i << 2) | 0; | |
| SAFE_HEAP_STORE($691 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $692 = $__i$0$i$i$i + 1 | 0; | |
| $__i$0$i$i$i = $692; | |
| } | |
| $693 = (tempInt = SAFE_HEAP_LOAD($682 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $694 = $693 + -24 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $84 | 0, $694 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $695 = __THREW__; | |
| __THREW__ = 0; | |
| $696 = $695 & 1; | |
| do { | |
| if ($696) { | |
| $762 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $763 = tempRet0; | |
| $$1 = $762; | |
| $$110 = $763; | |
| } else { | |
| $697 = (tempInt = SAFE_HEAP_LOAD($84 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $698 = $697 & 1; | |
| $699 = $698 << 24 >> 24 == 0; | |
| if ($699) { | |
| $704 = $84 + 1 | 0; | |
| $705 = $697 & 255; | |
| $706 = $705 >>> 1; | |
| $707 = $704; | |
| $708 = $706; | |
| } else { | |
| $700 = $84 + 8 | 0; | |
| $701 = (tempInt = SAFE_HEAP_LOAD($700 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $702 = $84 + 4 | 0; | |
| $703 = (tempInt = SAFE_HEAP_LOAD($702 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $707 = $701; | |
| $708 = $703; | |
| } | |
| __THREW__ = 0; | |
| $709 = (tempInt = invoke_iiii(3, $82 | 0, $707 | 0, $708 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $710 = __THREW__; | |
| __THREW__ = 0; | |
| $711 = $710 & 1; | |
| if ($711) { | |
| $764 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $765 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($84), asyncState ? abort(-12) | 0 : 0; | |
| $$1 = $764; | |
| $$110 = $765; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($81 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($709 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($81 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($709 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($81 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($709 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i72 = 0; | |
| while (1) { | |
| $exitcond$i$i$i73 = ($__i$0$i$i$i72 | 0) == 3; | |
| if ($exitcond$i$i$i73) { | |
| break; | |
| } | |
| $712 = $709 + ($__i$0$i$i$i72 << 2) | 0; | |
| SAFE_HEAP_STORE($712 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $713 = $__i$0$i$i$i72 + 1 | 0; | |
| $__i$0$i$i$i72 = $713; | |
| } | |
| $714 = (tempInt = SAFE_HEAP_LOAD($685 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $715 = $714 & 1; | |
| $716 = $715 << 24 >> 24 == 0; | |
| do { | |
| if ($716) { | |
| $717 = $685 + 1 | 0; | |
| SAFE_HEAP_STORE($717 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($685 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $718 = $683 + -16 | 0; | |
| $719 = (tempInt = SAFE_HEAP_LOAD($718 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($719 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $720 = $683 + -20 | 0; | |
| SAFE_HEAP_STORE($720 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i$i = (tempInt = SAFE_HEAP_LOAD($685 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $721 = $$pre$i$i$i & 1; | |
| $722 = $721 << 24 >> 24 == 0; | |
| if ($722) { | |
| $727 = $$pre$i$i$i; | |
| $736 = 10; | |
| } else { | |
| $723 = (tempInt = SAFE_HEAP_LOAD($685 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $724 = $723 & -2; | |
| $phitmp$i$i$i$i$i$i = $724 + -1 | 0; | |
| $725 = $723 & 255; | |
| $727 = $725; | |
| $736 = $phitmp$i$i$i$i$i$i; | |
| } | |
| $726 = $727 & 1; | |
| $728 = $726 << 24 >> 24 == 0; | |
| if ($728) { | |
| $729 = $727 & 255; | |
| $730 = $729 >>> 1; | |
| $731 = ($727 & 255) < 22; | |
| if ($731) { | |
| $2328 = 1; | |
| $735 = 10; | |
| $755 = $730; | |
| } else { | |
| $732 = $730 + 16 | 0; | |
| $733 = $732 & 240; | |
| $phitmp$i2$i$i$i$i$i = $733 + -1 | 0; | |
| $2328 = 1; | |
| $735 = $phitmp$i2$i$i$i$i$i; | |
| $755 = $730; | |
| } | |
| } else { | |
| $2328 = 0; | |
| $735 = 10; | |
| $755 = 0; | |
| } | |
| $734 = ($735 | 0) == ($736 | 0); | |
| if (!$734) { | |
| $737 = ($735 | 0) == 10; | |
| if ($737) { | |
| $742 = $685 + 1 | 0; | |
| $743 = (tempInt = SAFE_HEAP_LOAD($718 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2328) { | |
| $744 = $727 & 255; | |
| $745 = $744 >>> 1; | |
| $746 = $745 + 1 | 0; | |
| (tempInt = _memcpy($742 | 0, $743 | 0, $746 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($743), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $751 = (tempInt = SAFE_HEAP_LOAD($743 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($742 >> 0 | 0, $751 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($743), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $756 = $755 << 1; | |
| $757 = $756 & 255; | |
| SAFE_HEAP_STORE($685 >> 0 | 0, $757 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $738 = $735 >>> 0 <= $736 >>> 0; | |
| $739 = $735 + 1 | 0; | |
| $740 = (tempInt = _malloc($739) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $741 = ($740 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i = $738 & $741; | |
| if ($or$cond$i$i$i$i$i) { | |
| break; | |
| } | |
| if ($2328) { | |
| $747 = $685 + 1 | 0; | |
| $748 = $727 & 255; | |
| $749 = $748 >>> 1; | |
| $750 = $749 + 1 | 0; | |
| (tempInt = _memcpy($740 | 0, $747 | 0, $750 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } else { | |
| $752 = (tempInt = SAFE_HEAP_LOAD($718 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $753 = (tempInt = SAFE_HEAP_LOAD($752 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($740 >> 0 | 0, $753 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($752), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $754 = $739 | 1; | |
| SAFE_HEAP_STORE($685 | 0, $754 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($720 | 0, $755 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($718 | 0, $740 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($685 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($81 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($685 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($81 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($685 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($81 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i = ($__i$0$i$i$i$i | 0) == 3; | |
| if ($exitcond$i$i$i$i) { | |
| break; | |
| } | |
| $758 = $81 + ($__i$0$i$i$i$i << 2) | 0; | |
| SAFE_HEAP_STORE($758 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $759 = $__i$0$i$i$i$i + 1 | 0; | |
| $__i$0$i$i$i$i = $759; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($81), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($84), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($82), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($83), asyncState ? abort(-12) | 0 : 0; | |
| $$0 = $679; | |
| break L1; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($82), asyncState ? abort(-12) | 0 : 0; | |
| $$2 = $$1; | |
| $$211 = $$110; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($83), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $$2; | |
| $$2332 = $$211; | |
| break L7; | |
| break; | |
| } | |
| case 99: | |
| { | |
| $766 = ($144 | 0) > 2; | |
| L73 : do { | |
| if ($766) { | |
| $767 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $768 = $767 << 24 >> 24 == 100; | |
| if ($768) { | |
| $769 = $first + 1 | 0; | |
| $770 = (tempInt = SAFE_HEAP_LOAD($769 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $771 = $770 << 24 >> 24 == 99; | |
| if ($771) { | |
| $772 = $first + 2 | 0; | |
| $773 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($772, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $774 = ($773 | 0) == ($772 | 0); | |
| if ($774) { | |
| $$06$i358 = $first; | |
| } else { | |
| $775 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($773, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $776 = ($775 | 0) == ($773 | 0); | |
| if ($776) { | |
| $$06$i358 = $first; | |
| } else { | |
| $777 = $db + 4 | 0; | |
| $778 = (tempInt = SAFE_HEAP_LOAD($777 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $779 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $780 = $778; | |
| $781 = $779; | |
| $782 = $780 - $781 | 0; | |
| $783 = ($782 | 0) / 24 & -1; | |
| $784 = $783 >>> 0 < 2; | |
| if ($784) { | |
| $$06$i358 = $first; | |
| } else { | |
| $785 = $778 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($expr$i330, $785), asyncState ? abort(-12) | 0 : 0; | |
| $786 = (tempInt = SAFE_HEAP_LOAD($777 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $787 = $786 + -24 | 0; | |
| $789 = $786; | |
| while (1) { | |
| $788 = ($789 | 0) == ($787 | 0); | |
| if ($788) { | |
| break; | |
| } | |
| $790 = $789 + -24 | 0; | |
| SAFE_HEAP_STORE($777 | 0, $790 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($790), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i331 = (tempInt = SAFE_HEAP_LOAD($777 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $789 = $$pre$i$i331; | |
| } | |
| $791 = $786 + -48 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $24 | 0, $791 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $792 = __THREW__; | |
| __THREW__ = 0; | |
| $793 = $792 & 1; | |
| if ($793) { | |
| $826 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $827 = tempRet0; | |
| $$4$i357 = $827; | |
| $$45$i356 = $826; | |
| } else { | |
| __THREW__ = 0; | |
| $794 = (tempInt = invoke_iiii(4, $24 | 0, 0, 4512 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $795 = __THREW__; | |
| __THREW__ = 0; | |
| $796 = $795 & 1; | |
| if ($796) { | |
| $828 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $829 = tempRet0; | |
| $$3$i355 = $829; | |
| $$34$i354 = $828; | |
| } else { | |
| SAFE_HEAP_STORE($23 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($794 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($23 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($794 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($23 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($794 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i334 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i335 = ($__i$0$i$i$i$i334 | 0) == 3; | |
| if ($exitcond$i$i$i$i335) { | |
| break; | |
| } | |
| $797 = $794 + ($__i$0$i$i$i$i334 << 2) | 0; | |
| SAFE_HEAP_STORE($797 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $798 = $__i$0$i$i$i$i334 + 1 | 0; | |
| $__i$0$i$i$i$i334 = $798; | |
| } | |
| __THREW__ = 0; | |
| $799 = (tempInt = invoke_iii(5, $23 | 0, 3296 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $800 = __THREW__; | |
| __THREW__ = 0; | |
| $801 = $800 & 1; | |
| if ($801) { | |
| $830 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $831 = tempRet0; | |
| $$2$i353 = $831; | |
| $$23$i352 = $830; | |
| } else { | |
| SAFE_HEAP_STORE($22 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($799 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($22 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($799 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($22 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($799 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i8$i338 = 0; | |
| while (1) { | |
| $exitcond$i$i$i9$i339 = ($__i$0$i$i$i8$i338 | 0) == 3; | |
| if ($exitcond$i$i$i9$i339) { | |
| break; | |
| } | |
| $802 = $799 + ($__i$0$i$i$i8$i338 << 2) | 0; | |
| SAFE_HEAP_STORE($802 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $803 = $__i$0$i$i$i8$i338 + 1 | 0; | |
| $__i$0$i$i$i8$i338 = $803; | |
| } | |
| $804 = (tempInt = SAFE_HEAP_LOAD($expr$i330 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $805 = $804 & 1; | |
| $806 = $805 << 24 >> 24 == 0; | |
| if ($806) { | |
| $811 = $expr$i330 + 1 | 0; | |
| $812 = $804 & 255; | |
| $813 = $812 >>> 1; | |
| $814 = $811; | |
| $815 = $813; | |
| } else { | |
| $807 = $expr$i330 + 8 | 0; | |
| $808 = (tempInt = SAFE_HEAP_LOAD($807 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $809 = $expr$i330 + 4 | 0; | |
| $810 = (tempInt = SAFE_HEAP_LOAD($809 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $814 = $808; | |
| $815 = $810; | |
| } | |
| __THREW__ = 0; | |
| $816 = (tempInt = invoke_iiii(3, $22 | 0, $814 | 0, $815 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $817 = __THREW__; | |
| __THREW__ = 0; | |
| $818 = $817 & 1; | |
| do { | |
| if ($818) { | |
| $832 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $833 = tempRet0; | |
| $$1$i351 = $833; | |
| $$12$i350 = $832; | |
| } else { | |
| SAFE_HEAP_STORE($21 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($816 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($21 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($816 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($21 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($816 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i11$i343 = 0; | |
| while (1) { | |
| $exitcond$i$i$i12$i344 = ($__i$0$i$i$i11$i343 | 0) == 3; | |
| if ($exitcond$i$i$i12$i344) { | |
| break; | |
| } | |
| $819 = $816 + ($__i$0$i$i$i11$i343 << 2) | 0; | |
| SAFE_HEAP_STORE($819 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $820 = $__i$0$i$i$i11$i343 + 1 | 0; | |
| $__i$0$i$i$i11$i343 = $820; | |
| } | |
| __THREW__ = 0; | |
| $821 = (tempInt = invoke_iii(5, $21 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $822 = __THREW__; | |
| __THREW__ = 0; | |
| $823 = $822 & 1; | |
| if ($823) { | |
| $834 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $835 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($21), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i351 = $835; | |
| $$12$i350 = $834; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($20 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($821 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($20 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($821 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($20 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($821 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i14$i347 = 0; | |
| while (1) { | |
| $exitcond$i$i$i15$i348 = ($__i$0$i$i$i14$i347 | 0) == 3; | |
| if ($exitcond$i$i$i15$i348) { | |
| break; | |
| } | |
| $824 = $821 + ($__i$0$i$i$i14$i347 << 2) | 0; | |
| SAFE_HEAP_STORE($824 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $825 = $__i$0$i$i$i14$i347 + 1 | 0; | |
| $__i$0$i$i$i14$i347 = $825; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($19, $20), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($791, $19), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($19), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($20), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($21), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($22), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($23), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($24), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($expr$i330), asyncState ? abort(-12) | 0 : 0; | |
| $$06$i358 = $775; | |
| break L73; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($22), asyncState ? abort(-12) | 0 : 0; | |
| $$2$i353 = $$1$i351; | |
| $$23$i352 = $$12$i350; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($23), asyncState ? abort(-12) | 0 : 0; | |
| $$3$i355 = $$2$i353; | |
| $$34$i354 = $$23$i352; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($24), asyncState ? abort(-12) | 0 : 0; | |
| $$4$i357 = $$3$i355; | |
| $$45$i356 = $$34$i354; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($expr$i330), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$45$i356 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } | |
| } else { | |
| $$06$i358 = $first; | |
| } | |
| } else { | |
| $$06$i358 = $first; | |
| } | |
| } else { | |
| $$06$i358 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$06$i358; | |
| break L1; | |
| break; | |
| } | |
| case 101: | |
| { | |
| $836 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($85, 2800, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $837 = (tempInt = invoke_iiiii(22, $836 | 0, $last | 0, $85 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $838 = __THREW__; | |
| __THREW__ = 0; | |
| $839 = $838 & 1; | |
| if ($839) { | |
| $841 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $842 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($85), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $841; | |
| $$2332 = $842; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($85), asyncState ? abort(-12) | 0 : 0; | |
| $840 = ($837 | 0) == ($836 | 0); | |
| $first$39 = $840 ? $first : $837; | |
| $$0 = $first$39; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 108: | |
| { | |
| $843 = $t$0 + 2 | 0; | |
| $844 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($843, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $845 = ($844 | 0) == ($843 | 0); | |
| if ($845) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $846 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $847 = $db + 4 | 0; | |
| $848 = (tempInt = SAFE_HEAP_LOAD($847 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $849 = ($846 | 0) == ($848 | 0); | |
| if ($849) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $850 = $848 + -24 | 0; | |
| if ($parsed_gs$0$off0) { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($88, 2936, 2), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $__i$0$i$i75 = 0; | |
| while (1) { | |
| $exitcond$i$i76 = ($__i$0$i$i75 | 0) == 3; | |
| if ($exitcond$i$i76) { | |
| break; | |
| } | |
| $851 = $88 + ($__i$0$i$i75 << 2) | 0; | |
| SAFE_HEAP_STORE($851 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $852 = $__i$0$i$i75 + 1 | 0; | |
| $__i$0$i$i75 = $852; | |
| } | |
| } | |
| __THREW__ = 0; | |
| $853 = (tempInt = invoke_iii(5, $88 | 0, 2960 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $854 = __THREW__; | |
| __THREW__ = 0; | |
| $855 = $854 & 1; | |
| if ($855) { | |
| $925 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $926 = tempRet0; | |
| $$5 = $925; | |
| $$514 = $926; | |
| } else { | |
| SAFE_HEAP_STORE($87 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($853 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($87 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($853 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($87 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($853 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i78 = 0; | |
| while (1) { | |
| $exitcond$i$i$i79 = ($__i$0$i$i$i78 | 0) == 3; | |
| if ($exitcond$i$i$i79) { | |
| break; | |
| } | |
| $856 = $853 + ($__i$0$i$i$i78 << 2) | 0; | |
| SAFE_HEAP_STORE($856 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $857 = $__i$0$i$i$i78 + 1 | 0; | |
| $__i$0$i$i$i78 = $857; | |
| } | |
| $858 = (tempInt = SAFE_HEAP_LOAD($847 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $859 = $858 + -24 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $89 | 0, $859 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $860 = __THREW__; | |
| __THREW__ = 0; | |
| $861 = $860 & 1; | |
| do { | |
| if ($861) { | |
| $927 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $928 = tempRet0; | |
| $$4 = $927; | |
| $$413 = $928; | |
| } else { | |
| $862 = (tempInt = SAFE_HEAP_LOAD($89 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $863 = $862 & 1; | |
| $864 = $863 << 24 >> 24 == 0; | |
| if ($864) { | |
| $869 = $89 + 1 | 0; | |
| $870 = $862 & 255; | |
| $871 = $870 >>> 1; | |
| $872 = $869; | |
| $873 = $871; | |
| } else { | |
| $865 = $89 + 8 | 0; | |
| $866 = (tempInt = SAFE_HEAP_LOAD($865 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $867 = $89 + 4 | 0; | |
| $868 = (tempInt = SAFE_HEAP_LOAD($867 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $872 = $866; | |
| $873 = $868; | |
| } | |
| __THREW__ = 0; | |
| $874 = (tempInt = invoke_iiii(3, $87 | 0, $872 | 0, $873 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $875 = __THREW__; | |
| __THREW__ = 0; | |
| $876 = $875 & 1; | |
| if ($876) { | |
| $929 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $930 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($89), asyncState ? abort(-12) | 0 : 0; | |
| $$4 = $929; | |
| $$413 = $930; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($86 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($874 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($86 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($874 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($86 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($874 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i83 = 0; | |
| while (1) { | |
| $exitcond$i$i$i84 = ($__i$0$i$i$i83 | 0) == 3; | |
| if ($exitcond$i$i$i84) { | |
| break; | |
| } | |
| $877 = $874 + ($__i$0$i$i$i83 << 2) | 0; | |
| SAFE_HEAP_STORE($877 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $878 = $__i$0$i$i$i83 + 1 | 0; | |
| $__i$0$i$i$i83 = $878; | |
| } | |
| $879 = (tempInt = SAFE_HEAP_LOAD($850 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $880 = $879 & 1; | |
| $881 = $880 << 24 >> 24 == 0; | |
| do { | |
| if ($881) { | |
| $882 = $850 + 1 | 0; | |
| SAFE_HEAP_STORE($882 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($850 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $883 = $848 + -16 | 0; | |
| $884 = (tempInt = SAFE_HEAP_LOAD($883 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($884 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $885 = $848 + -20 | 0; | |
| SAFE_HEAP_STORE($885 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i$i88 = (tempInt = SAFE_HEAP_LOAD($850 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $886 = $$pre$i$i$i88 & 1; | |
| $887 = $886 << 24 >> 24 == 0; | |
| if ($887) { | |
| $892 = $$pre$i$i$i88; | |
| $901 = 10; | |
| } else { | |
| $888 = (tempInt = SAFE_HEAP_LOAD($850 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $889 = $888 & -2; | |
| $phitmp$i$i$i$i$i$i90 = $889 + -1 | 0; | |
| $890 = $888 & 255; | |
| $892 = $890; | |
| $901 = $phitmp$i$i$i$i$i$i90; | |
| } | |
| $891 = $892 & 1; | |
| $893 = $891 << 24 >> 24 == 0; | |
| if ($893) { | |
| $894 = $892 & 255; | |
| $895 = $894 >>> 1; | |
| $896 = ($892 & 255) < 22; | |
| if ($896) { | |
| $2329 = 1; | |
| $900 = 10; | |
| $920 = $895; | |
| } else { | |
| $897 = $895 + 16 | 0; | |
| $898 = $897 & 240; | |
| $phitmp$i2$i$i$i$i$i93 = $898 + -1 | 0; | |
| $2329 = 1; | |
| $900 = $phitmp$i2$i$i$i$i$i93; | |
| $920 = $895; | |
| } | |
| } else { | |
| $2329 = 0; | |
| $900 = 10; | |
| $920 = 0; | |
| } | |
| $899 = ($900 | 0) == ($901 | 0); | |
| if (!$899) { | |
| $902 = ($900 | 0) == 10; | |
| if ($902) { | |
| $907 = $850 + 1 | 0; | |
| $908 = (tempInt = SAFE_HEAP_LOAD($883 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2329) { | |
| $909 = $892 & 255; | |
| $910 = $909 >>> 1; | |
| $911 = $910 + 1 | 0; | |
| (tempInt = _memcpy($907 | 0, $908 | 0, $911 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($908), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $916 = (tempInt = SAFE_HEAP_LOAD($908 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($907 >> 0 | 0, $916 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($908), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $921 = $920 << 1; | |
| $922 = $921 & 255; | |
| SAFE_HEAP_STORE($850 >> 0 | 0, $922 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $903 = $900 >>> 0 <= $901 >>> 0; | |
| $904 = $900 + 1 | 0; | |
| $905 = (tempInt = _malloc($904) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $906 = ($905 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i95 = $903 & $906; | |
| if ($or$cond$i$i$i$i$i95) { | |
| break; | |
| } | |
| if ($2329) { | |
| $912 = $850 + 1 | 0; | |
| $913 = $892 & 255; | |
| $914 = $913 >>> 1; | |
| $915 = $914 + 1 | 0; | |
| (tempInt = _memcpy($905 | 0, $912 | 0, $915 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } else { | |
| $917 = (tempInt = SAFE_HEAP_LOAD($883 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $918 = (tempInt = SAFE_HEAP_LOAD($917 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($905 >> 0 | 0, $918 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($917), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $919 = $904 | 1; | |
| SAFE_HEAP_STORE($850 | 0, $919 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($885 | 0, $920 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($883 | 0, $905 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($850 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($86 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($850 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($86 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($850 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($86 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i103 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i104 = ($__i$0$i$i$i$i103 | 0) == 3; | |
| if ($exitcond$i$i$i$i104) { | |
| break; | |
| } | |
| $923 = $86 + ($__i$0$i$i$i$i103 << 2) | 0; | |
| SAFE_HEAP_STORE($923 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $924 = $__i$0$i$i$i$i103 + 1 | 0; | |
| $__i$0$i$i$i$i103 = $924; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($86), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($89), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($87), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($88), asyncState ? abort(-12) | 0 : 0; | |
| $$0 = $844; | |
| break L1; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($87), asyncState ? abort(-12) | 0 : 0; | |
| $$5 = $$4; | |
| $$514 = $$413; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($88), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $$5; | |
| $$2332 = $$514; | |
| break L7; | |
| break; | |
| } | |
| case 110: | |
| { | |
| $931 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_121parse_unresolved_nameINS0_2DbEEEPKcS4_S4_RT_($first, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $$0 = $931; | |
| break L1; | |
| break; | |
| } | |
| case 115: | |
| { | |
| $932 = ($144 | 0) > 2; | |
| L192 : do { | |
| if ($932) { | |
| $933 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $934 = $933 << 24 >> 24 == 100; | |
| if ($934) { | |
| $935 = $first + 1 | 0; | |
| $936 = (tempInt = SAFE_HEAP_LOAD($935 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $937 = $936 << 24 >> 24 == 115; | |
| if ($937) { | |
| $938 = $first + 2 | 0; | |
| $939 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($938, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $940 = ($939 | 0) == ($938 | 0); | |
| if ($940) { | |
| $$02$i329 = $first; | |
| } else { | |
| $941 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($939, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $942 = ($941 | 0) == ($939 | 0); | |
| if ($942) { | |
| $$02$i329 = $first; | |
| } else { | |
| $943 = $db + 4 | 0; | |
| $944 = (tempInt = SAFE_HEAP_LOAD($943 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $945 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $946 = $944; | |
| $947 = $945; | |
| $948 = $946 - $947 | 0; | |
| $949 = ($948 | 0) / 24 & -1; | |
| $950 = $949 >>> 0 < 2; | |
| if ($950) { | |
| $$02$i329 = $first; | |
| } else { | |
| $951 = $944 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($expr$i322, $951), asyncState ? abort(-12) | 0 : 0; | |
| $952 = (tempInt = SAFE_HEAP_LOAD($943 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $953 = $952 + -24 | 0; | |
| $955 = $952; | |
| while (1) { | |
| $954 = ($955 | 0) == ($953 | 0); | |
| if ($954) { | |
| break; | |
| } | |
| $956 = $955 + -24 | 0; | |
| SAFE_HEAP_STORE($943 | 0, $956 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($956), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i323 = (tempInt = SAFE_HEAP_LOAD($943 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $955 = $$pre$i$i323; | |
| } | |
| __THREW__ = 0; | |
| invoke_viii(19, $25 | 0, 3368 | 0, $expr$i322 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $957 = __THREW__; | |
| __THREW__ = 0; | |
| $958 = $957 & 1; | |
| do { | |
| if ($958) { | |
| $974 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $975 = tempRet0; | |
| $$0$i328 = $975; | |
| $$01$i327 = $974; | |
| } else { | |
| $959 = $952 + -48 | 0; | |
| $960 = (tempInt = SAFE_HEAP_LOAD($25 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $961 = $960 & 1; | |
| $962 = $961 << 24 >> 24 == 0; | |
| if ($962) { | |
| $967 = $25 + 1 | 0; | |
| $968 = $960 & 255; | |
| $969 = $968 >>> 1; | |
| $970 = $967; | |
| $971 = $969; | |
| } else { | |
| $963 = $25 + 8 | 0; | |
| $964 = (tempInt = SAFE_HEAP_LOAD($963 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $965 = $25 + 4 | 0; | |
| $966 = (tempInt = SAFE_HEAP_LOAD($965 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $970 = $964; | |
| $971 = $966; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiii(3, $959 | 0, $970 | 0, $971 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $972 = __THREW__; | |
| __THREW__ = 0; | |
| $973 = $972 & 1; | |
| if ($973) { | |
| $976 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $977 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($25), asyncState ? abort(-12) | 0 : 0; | |
| $$0$i328 = $977; | |
| $$01$i327 = $976; | |
| break; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($25), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($expr$i322), asyncState ? abort(-12) | 0 : 0; | |
| $$02$i329 = $941; | |
| break L192; | |
| } | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($expr$i322), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$01$i327 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } | |
| } else { | |
| $$02$i329 = $first; | |
| } | |
| } else { | |
| $$02$i329 = $first; | |
| } | |
| } else { | |
| $$02$i329 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$02$i329; | |
| break L1; | |
| break; | |
| } | |
| case 116: | |
| { | |
| $978 = ($144 | 0) > 2; | |
| L216 : do { | |
| if ($978) { | |
| $979 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $980 = $979 << 24 >> 24 == 100; | |
| if ($980) { | |
| $981 = $first + 1 | 0; | |
| $982 = (tempInt = SAFE_HEAP_LOAD($981 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $983 = $982 << 24 >> 24 == 116; | |
| if ($983) { | |
| $984 = $first + 2 | 0; | |
| $985 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($984, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $986 = ($985 | 0) == ($984 | 0); | |
| if ($986) { | |
| $$02$i321 = $first; | |
| } else { | |
| $987 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_121parse_unresolved_nameINS0_2DbEEEPKcS4_S4_RT_($985, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $988 = ($987 | 0) == ($985 | 0); | |
| if ($988) { | |
| $$02$i321 = $first; | |
| } else { | |
| $989 = $db + 4 | 0; | |
| $990 = (tempInt = SAFE_HEAP_LOAD($989 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $991 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $992 = $990; | |
| $993 = $991; | |
| $994 = $992 - $993 | 0; | |
| $995 = ($994 | 0) / 24 & -1; | |
| $996 = $995 >>> 0 < 2; | |
| if ($996) { | |
| $$02$i321 = $first; | |
| } else { | |
| $997 = $990 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($name$i, $997), asyncState ? abort(-12) | 0 : 0; | |
| $998 = (tempInt = SAFE_HEAP_LOAD($989 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $999 = $998 + -24 | 0; | |
| $1001 = $998; | |
| while (1) { | |
| $1000 = ($1001 | 0) == ($999 | 0); | |
| if ($1000) { | |
| break; | |
| } | |
| $1002 = $1001 + -24 | 0; | |
| SAFE_HEAP_STORE($989 | 0, $1002 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1002), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i315 = (tempInt = SAFE_HEAP_LOAD($989 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1001 = $$pre$i$i315; | |
| } | |
| __THREW__ = 0; | |
| invoke_viii(19, $26 | 0, 6744 | 0, $name$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1003 = __THREW__; | |
| __THREW__ = 0; | |
| $1004 = $1003 & 1; | |
| do { | |
| if ($1004) { | |
| $1020 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1021 = tempRet0; | |
| $$0$i320 = $1021; | |
| $$01$i319 = $1020; | |
| } else { | |
| $1005 = $998 + -48 | 0; | |
| $1006 = (tempInt = SAFE_HEAP_LOAD($26 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1007 = $1006 & 1; | |
| $1008 = $1007 << 24 >> 24 == 0; | |
| if ($1008) { | |
| $1013 = $26 + 1 | 0; | |
| $1014 = $1006 & 255; | |
| $1015 = $1014 >>> 1; | |
| $1016 = $1013; | |
| $1017 = $1015; | |
| } else { | |
| $1009 = $26 + 8 | 0; | |
| $1010 = (tempInt = SAFE_HEAP_LOAD($1009 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1011 = $26 + 4 | 0; | |
| $1012 = (tempInt = SAFE_HEAP_LOAD($1011 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1016 = $1010; | |
| $1017 = $1012; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiii(3, $1005 | 0, $1016 | 0, $1017 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1018 = __THREW__; | |
| __THREW__ = 0; | |
| $1019 = $1018 & 1; | |
| if ($1019) { | |
| $1022 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1023 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($26), asyncState ? abort(-12) | 0 : 0; | |
| $$0$i320 = $1023; | |
| $$01$i319 = $1022; | |
| break; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($26), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($name$i), asyncState ? abort(-12) | 0 : 0; | |
| $$02$i321 = $987; | |
| break L216; | |
| } | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($name$i), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$01$i319 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } | |
| } else { | |
| $$02$i321 = $first; | |
| } | |
| } else { | |
| $$02$i321 = $first; | |
| } | |
| } else { | |
| $$02$i321 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$02$i321; | |
| break L1; | |
| break; | |
| } | |
| case 118: | |
| { | |
| $1024 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($90, 2968, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1025 = (tempInt = invoke_iiiii(21, $1024 | 0, $last | 0, $90 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1026 = __THREW__; | |
| __THREW__ = 0; | |
| $1027 = $1026 & 1; | |
| if ($1027) { | |
| $1029 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1030 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($90), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1029; | |
| $$2332 = $1030; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($90), asyncState ? abort(-12) | 0 : 0; | |
| $1028 = ($1025 | 0) == ($1024 | 0); | |
| $first$40 = $1028 ? $first : $1025; | |
| $$0 = $first$40; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 86: | |
| { | |
| $1031 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($91, 2976, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1032 = (tempInt = invoke_iiiii(21, $1031 | 0, $last | 0, $91 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1033 = __THREW__; | |
| __THREW__ = 0; | |
| $1034 = $1033 & 1; | |
| if ($1034) { | |
| $1036 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1037 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($91), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1036; | |
| $$2332 = $1037; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($91), asyncState ? abort(-12) | 0 : 0; | |
| $1035 = ($1032 | 0) == ($1031 | 0); | |
| $first$41 = $1035 ? $first : $1032; | |
| $$0 = $first$41; | |
| break L1; | |
| } | |
| break; | |
| } | |
| default: | |
| { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| } | |
| break; | |
| } | |
| case 101: | |
| { | |
| $1038 = $t$0 + 1 | 0; | |
| $1039 = (tempInt = SAFE_HEAP_LOAD($1038 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1040 = $1039 << 24 >> 24; | |
| if (($1040 | 0) == 111) { | |
| $1041 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($92, 2984, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1042 = (tempInt = invoke_iiiii(21, $1041 | 0, $last | 0, $92 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1043 = __THREW__; | |
| __THREW__ = 0; | |
| $1044 = $1043 & 1; | |
| if ($1044) { | |
| $1046 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1047 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($92), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1046; | |
| $$2332 = $1047; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($92), asyncState ? abort(-12) | 0 : 0; | |
| $1045 = ($1042 | 0) == ($1041 | 0); | |
| $first$42 = $1045 ? $first : $1042; | |
| $$0 = $first$42; | |
| break L1; | |
| } | |
| } else if (($1040 | 0) == 79) { | |
| $1048 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($93, 2992, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1049 = (tempInt = invoke_iiiii(21, $1048 | 0, $last | 0, $93 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1050 = __THREW__; | |
| __THREW__ = 0; | |
| $1051 = $1050 & 1; | |
| if ($1051) { | |
| $1053 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1054 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($93), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1053; | |
| $$2332 = $1054; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($93), asyncState ? abort(-12) | 0 : 0; | |
| $1052 = ($1049 | 0) == ($1048 | 0); | |
| $first$43 = $1052 ? $first : $1049; | |
| $$0 = $first$43; | |
| break L1; | |
| } | |
| } else if (($1040 | 0) == 113) { | |
| $1055 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($94, 3e3, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1056 = (tempInt = invoke_iiiii(21, $1055 | 0, $last | 0, $94 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1057 = __THREW__; | |
| __THREW__ = 0; | |
| $1058 = $1057 & 1; | |
| if ($1058) { | |
| $1060 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1061 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($94), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1060; | |
| $$2332 = $1061; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($94), asyncState ? abort(-12) | 0 : 0; | |
| $1059 = ($1056 | 0) == ($1055 | 0); | |
| $first$44 = $1059 ? $first : $1056; | |
| $$0 = $first$44; | |
| break L1; | |
| } | |
| } else { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 103: | |
| { | |
| $1062 = $t$0 + 1 | 0; | |
| $1063 = (tempInt = SAFE_HEAP_LOAD($1062 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1064 = $1063 << 24 >> 24; | |
| if (($1064 | 0) == 101) { | |
| $1065 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($95, 3008, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1066 = (tempInt = invoke_iiiii(21, $1065 | 0, $last | 0, $95 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1067 = __THREW__; | |
| __THREW__ = 0; | |
| $1068 = $1067 & 1; | |
| if ($1068) { | |
| $1070 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1071 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($95), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1070; | |
| $$2332 = $1071; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($95), asyncState ? abort(-12) | 0 : 0; | |
| $1069 = ($1066 | 0) == ($1065 | 0); | |
| $first$45 = $1069 ? $first : $1066; | |
| $$0 = $first$45; | |
| break L1; | |
| } | |
| } else if (($1064 | 0) == 116) { | |
| $1072 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($96, 2856, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1073 = (tempInt = invoke_iiiii(21, $1072 | 0, $last | 0, $96 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1074 = __THREW__; | |
| __THREW__ = 0; | |
| $1075 = $1074 & 1; | |
| if ($1075) { | |
| $1077 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1078 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($96), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1077; | |
| $$2332 = $1078; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($96), asyncState ? abort(-12) | 0 : 0; | |
| $1076 = ($1073 | 0) == ($1072 | 0); | |
| $first$46 = $1076 ? $first : $1073; | |
| $$0 = $first$46; | |
| break L1; | |
| } | |
| } else { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 105: | |
| { | |
| $1079 = $t$0 + 1 | 0; | |
| $1080 = (tempInt = SAFE_HEAP_LOAD($1079 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1081 = $1080 << 24 >> 24 == 120; | |
| if (!$1081) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1082 = $first + 2 | 0; | |
| $1083 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($1082, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1084 = ($1083 | 0) == ($1082 | 0); | |
| if ($1084) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1085 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($1083, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1086 = ($1085 | 0) == ($1083 | 0); | |
| $1087 = $db + 4 | 0; | |
| $1088 = (tempInt = SAFE_HEAP_LOAD($1087 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($1086) { | |
| $1145 = $1088 + -24 | 0; | |
| $1147 = $1088; | |
| while (1) { | |
| $1146 = ($1147 | 0) == ($1145 | 0); | |
| if ($1146) { | |
| break; | |
| } | |
| $1148 = $1147 + -24 | 0; | |
| SAFE_HEAP_STORE($1087 | 0, $1148 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1148), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i118 = (tempInt = SAFE_HEAP_LOAD($1087 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1147 = $$pre$i118; | |
| } | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1089 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1090 = $1088; | |
| $1091 = $1089; | |
| $1092 = $1090 - $1091 | 0; | |
| $1093 = ($1092 | 0) / 24 & -1; | |
| $1094 = $1093 >>> 0 < 2; | |
| if ($1094) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1095 = $1088 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($op2, $1095), asyncState ? abort(-12) | 0 : 0; | |
| $1096 = (tempInt = SAFE_HEAP_LOAD($1087 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1097 = $1096 + -24 | 0; | |
| $1099 = $1096; | |
| while (1) { | |
| $1098 = ($1099 | 0) == ($1097 | 0); | |
| if ($1098) { | |
| break; | |
| } | |
| $1100 = $1099 + -24 | 0; | |
| SAFE_HEAP_STORE($1087 | 0, $1100 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1100), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i = (tempInt = SAFE_HEAP_LOAD($1087 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1099 = $$pre$i; | |
| } | |
| $1101 = $1096 + -48 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $op1 | 0, $1101 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1102 = __THREW__; | |
| __THREW__ = 0; | |
| $1103 = $1102 & 1; | |
| if ($1103) { | |
| $1135 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1136 = tempRet0; | |
| $$10 = $1135; | |
| $$1019 = $1136; | |
| } else { | |
| $1104 = (tempInt = SAFE_HEAP_LOAD($1087 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1105 = $1104 + -24 | 0; | |
| __THREW__ = 0; | |
| invoke_viii(19, $101 | 0, 2768 | 0, $op1 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1106 = __THREW__; | |
| __THREW__ = 0; | |
| $1107 = $1106 & 1; | |
| if ($1107) { | |
| $1137 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1138 = tempRet0; | |
| $$9 = $1137; | |
| $$918 = $1138; | |
| } else { | |
| __THREW__ = 0; | |
| $1108 = (tempInt = invoke_iii(5, $101 | 0, 3016 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1109 = __THREW__; | |
| __THREW__ = 0; | |
| $1110 = $1109 & 1; | |
| if ($1110) { | |
| $1139 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1140 = tempRet0; | |
| $$8 = $1139; | |
| $$817 = $1140; | |
| } else { | |
| SAFE_HEAP_STORE($100 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1108 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($100 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1108 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($100 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1108 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i106 = 0; | |
| while (1) { | |
| $exitcond$i$i$i107 = ($__i$0$i$i$i106 | 0) == 3; | |
| if ($exitcond$i$i$i107) { | |
| break; | |
| } | |
| $1111 = $1108 + ($__i$0$i$i$i106 << 2) | 0; | |
| SAFE_HEAP_STORE($1111 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1112 = $__i$0$i$i$i106 + 1 | 0; | |
| $__i$0$i$i$i106 = $1112; | |
| } | |
| $1113 = (tempInt = SAFE_HEAP_LOAD($op2 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1114 = $1113 & 1; | |
| $1115 = $1114 << 24 >> 24 == 0; | |
| if ($1115) { | |
| $1120 = $op2 + 1 | 0; | |
| $1121 = $1113 & 255; | |
| $1122 = $1121 >>> 1; | |
| $1123 = $1120; | |
| $1124 = $1122; | |
| } else { | |
| $1116 = $op2 + 8 | 0; | |
| $1117 = (tempInt = SAFE_HEAP_LOAD($1116 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1118 = $op2 + 4 | 0; | |
| $1119 = (tempInt = SAFE_HEAP_LOAD($1118 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1123 = $1117; | |
| $1124 = $1119; | |
| } | |
| __THREW__ = 0; | |
| $1125 = (tempInt = invoke_iiii(3, $100 | 0, $1123 | 0, $1124 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1126 = __THREW__; | |
| __THREW__ = 0; | |
| $1127 = $1126 & 1; | |
| do { | |
| if ($1127) { | |
| $1141 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1142 = tempRet0; | |
| $$7 = $1141; | |
| $$716 = $1142; | |
| } else { | |
| SAFE_HEAP_STORE($99 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1125 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($99 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1125 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($99 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1125 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i111 = 0; | |
| while (1) { | |
| $exitcond$i$i$i112 = ($__i$0$i$i$i111 | 0) == 3; | |
| if ($exitcond$i$i$i112) { | |
| break; | |
| } | |
| $1128 = $1125 + ($__i$0$i$i$i111 << 2) | 0; | |
| SAFE_HEAP_STORE($1128 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1129 = $__i$0$i$i$i111 + 1 | 0; | |
| $__i$0$i$i$i111 = $1129; | |
| } | |
| __THREW__ = 0; | |
| $1130 = (tempInt = invoke_iii(5, $99 | 0, 2880 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1131 = __THREW__; | |
| __THREW__ = 0; | |
| $1132 = $1131 & 1; | |
| if ($1132) { | |
| $1143 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1144 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($99), asyncState ? abort(-12) | 0 : 0; | |
| $$7 = $1143; | |
| $$716 = $1144; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($98 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1130 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($98 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1130 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($98 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1130 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i114 = 0; | |
| while (1) { | |
| $exitcond$i$i$i115 = ($__i$0$i$i$i114 | 0) == 3; | |
| if ($exitcond$i$i$i115) { | |
| break; | |
| } | |
| $1133 = $1130 + ($__i$0$i$i$i114 << 2) | 0; | |
| SAFE_HEAP_STORE($1133 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1134 = $__i$0$i$i$i114 + 1 | 0; | |
| $__i$0$i$i$i114 = $1134; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($97, $98), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($1105, $97), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($97), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($98), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($99), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($100), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($101), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($op1), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($op2), asyncState ? abort(-12) | 0 : 0; | |
| $$0 = $1085; | |
| break L1; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($100), asyncState ? abort(-12) | 0 : 0; | |
| $$8 = $$7; | |
| $$817 = $$716; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($101), asyncState ? abort(-12) | 0 : 0; | |
| $$9 = $$8; | |
| $$918 = $$817; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($op1), asyncState ? abort(-12) | 0 : 0; | |
| $$10 = $$9; | |
| $$1019 = $$918; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($op2), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $$10; | |
| $$2332 = $$1019; | |
| break; | |
| } | |
| case 108: | |
| { | |
| $1149 = $t$0 + 1 | 0; | |
| $1150 = (tempInt = SAFE_HEAP_LOAD($1149 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1151 = $1150 << 24 >> 24; | |
| if (($1151 | 0) == 101) { | |
| $1152 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($102, 3024, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1153 = (tempInt = invoke_iiiii(21, $1152 | 0, $last | 0, $102 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1154 = __THREW__; | |
| __THREW__ = 0; | |
| $1155 = $1154 & 1; | |
| if ($1155) { | |
| $1157 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1158 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($102), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1157; | |
| $$2332 = $1158; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($102), asyncState ? abort(-12) | 0 : 0; | |
| $1156 = ($1153 | 0) == ($1152 | 0); | |
| $first$47 = $1156 ? $first : $1153; | |
| $$0 = $first$47; | |
| break L1; | |
| } | |
| } else if (($1151 | 0) == 115) { | |
| $1159 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($103, 3032, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1160 = (tempInt = invoke_iiiii(21, $1159 | 0, $last | 0, $103 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1161 = __THREW__; | |
| __THREW__ = 0; | |
| $1162 = $1161 & 1; | |
| if ($1162) { | |
| $1164 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1165 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($103), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1164; | |
| $$2332 = $1165; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($103), asyncState ? abort(-12) | 0 : 0; | |
| $1163 = ($1160 | 0) == ($1159 | 0); | |
| $first$48 = $1163 ? $first : $1160; | |
| $$0 = $first$48; | |
| break L1; | |
| } | |
| } else if (($1151 | 0) == 83) { | |
| $1166 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($104, 3040, 3), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1167 = (tempInt = invoke_iiiii(21, $1166 | 0, $last | 0, $104 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1168 = __THREW__; | |
| __THREW__ = 0; | |
| $1169 = $1168 & 1; | |
| if ($1169) { | |
| $1171 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1172 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($104), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1171; | |
| $$2332 = $1172; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($104), asyncState ? abort(-12) | 0 : 0; | |
| $1170 = ($1167 | 0) == ($1166 | 0); | |
| $first$49 = $1170 ? $first : $1167; | |
| $$0 = $first$49; | |
| break L1; | |
| } | |
| } else if (($1151 | 0) == 116) { | |
| $1173 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($105, 2848, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1174 = (tempInt = invoke_iiiii(21, $1173 | 0, $last | 0, $105 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1175 = __THREW__; | |
| __THREW__ = 0; | |
| $1176 = $1175 & 1; | |
| if ($1176) { | |
| $1178 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1179 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($105), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1178; | |
| $$2332 = $1179; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($105), asyncState ? abort(-12) | 0 : 0; | |
| $1177 = ($1174 | 0) == ($1173 | 0); | |
| $first$50 = $1177 ? $first : $1174; | |
| $$0 = $first$50; | |
| break L1; | |
| } | |
| } else { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 109: | |
| { | |
| $1180 = $t$0 + 1 | 0; | |
| $1181 = (tempInt = SAFE_HEAP_LOAD($1180 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1182 = $1181 << 24 >> 24; | |
| switch ($1182 | 0) { | |
| case 105: | |
| { | |
| $1183 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($106, 3048, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1184 = (tempInt = invoke_iiiii(21, $1183 | 0, $last | 0, $106 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1185 = __THREW__; | |
| __THREW__ = 0; | |
| $1186 = $1185 & 1; | |
| if ($1186) { | |
| $1188 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1189 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($106), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1188; | |
| $$2332 = $1189; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($106), asyncState ? abort(-12) | 0 : 0; | |
| $1187 = ($1184 | 0) == ($1183 | 0); | |
| $first$51 = $1187 ? $first : $1184; | |
| $$0 = $first$51; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 73: | |
| { | |
| $1190 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($107, 3056, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1191 = (tempInt = invoke_iiiii(21, $1190 | 0, $last | 0, $107 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1192 = __THREW__; | |
| __THREW__ = 0; | |
| $1193 = $1192 & 1; | |
| if ($1193) { | |
| $1195 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1196 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($107), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1195; | |
| $$2332 = $1196; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($107), asyncState ? abort(-12) | 0 : 0; | |
| $1194 = ($1191 | 0) == ($1190 | 0); | |
| $first$52 = $1194 ? $first : $1191; | |
| $$0 = $first$52; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 108: | |
| { | |
| $1197 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($108, 2800, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1198 = (tempInt = invoke_iiiii(21, $1197 | 0, $last | 0, $108 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1199 = __THREW__; | |
| __THREW__ = 0; | |
| $1200 = $1199 & 1; | |
| if ($1200) { | |
| $1202 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1203 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($108), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1202; | |
| $$2332 = $1203; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($108), asyncState ? abort(-12) | 0 : 0; | |
| $1201 = ($1198 | 0) == ($1197 | 0); | |
| $first$53 = $1201 ? $first : $1198; | |
| $$0 = $first$53; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 76: | |
| { | |
| $1204 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($109, 3064, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1205 = (tempInt = invoke_iiiii(21, $1204 | 0, $last | 0, $109 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1206 = __THREW__; | |
| __THREW__ = 0; | |
| $1207 = $1206 & 1; | |
| if ($1207) { | |
| $1209 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1210 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($109), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1209; | |
| $$2332 = $1210; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($109), asyncState ? abort(-12) | 0 : 0; | |
| $1208 = ($1205 | 0) == ($1204 | 0); | |
| $first$54 = $1208 ? $first : $1205; | |
| $$0 = $first$54; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 109: | |
| { | |
| $1211 = $first + 2 | 0; | |
| $1212 = ($1211 | 0) == ($last | 0); | |
| if (!$1212) { | |
| $1213 = (tempInt = SAFE_HEAP_LOAD($1211 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1214 = $1213 << 24 >> 24 == 95; | |
| if ($1214) { | |
| $1215 = $first + 3 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($110, 3072, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1216 = (tempInt = invoke_iiiii(22, $1215 | 0, $last | 0, $110 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1217 = __THREW__; | |
| __THREW__ = 0; | |
| $1218 = $1217 & 1; | |
| if ($1218) { | |
| $1220 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1221 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($110), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1220; | |
| $$2332 = $1221; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($110), asyncState ? abort(-12) | 0 : 0; | |
| $1219 = ($1216 | 0) == ($1215 | 0); | |
| $first$55 = $1219 ? $first : $1216; | |
| $$0 = $first$55; | |
| break L1; | |
| } | |
| } | |
| } | |
| $1222 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($1211, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1223 = ($1222 | 0) == ($1211 | 0); | |
| if ($1223) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1224 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1225 = $db + 4 | 0; | |
| $1226 = (tempInt = SAFE_HEAP_LOAD($1225 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1227 = ($1224 | 0) == ($1226 | 0); | |
| if ($1227) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1228 = $1226 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($114, $1228), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1229 = (tempInt = invoke_iiii(4, $114 | 0, 0, 2768 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1230 = __THREW__; | |
| __THREW__ = 0; | |
| $1231 = $1230 & 1; | |
| do { | |
| if ($1231) { | |
| $1239 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1240 = tempRet0; | |
| $$12 = $1239; | |
| $$1221 = $1240; | |
| } else { | |
| SAFE_HEAP_STORE($113 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1229 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($113 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1229 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($113 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1229 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i120 = 0; | |
| while (1) { | |
| $exitcond$i$i$i121 = ($__i$0$i$i$i120 | 0) == 3; | |
| if ($exitcond$i$i$i121) { | |
| break; | |
| } | |
| $1232 = $1229 + ($__i$0$i$i$i120 << 2) | 0; | |
| SAFE_HEAP_STORE($1232 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1233 = $__i$0$i$i$i120 + 1 | 0; | |
| $__i$0$i$i$i120 = $1233; | |
| } | |
| __THREW__ = 0; | |
| $1234 = (tempInt = invoke_iii(5, $113 | 0, 3080 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1235 = __THREW__; | |
| __THREW__ = 0; | |
| $1236 = $1235 & 1; | |
| if ($1236) { | |
| $1241 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1242 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($113), asyncState ? abort(-12) | 0 : 0; | |
| $$12 = $1241; | |
| $$1221 = $1242; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($112 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1234 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($112 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1234 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($112 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1234 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i123 = 0; | |
| while (1) { | |
| $exitcond$i$i$i124 = ($__i$0$i$i$i123 | 0) == 3; | |
| if ($exitcond$i$i$i124) { | |
| break; | |
| } | |
| $1237 = $1234 + ($__i$0$i$i$i123 << 2) | 0; | |
| SAFE_HEAP_STORE($1237 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1238 = $__i$0$i$i$i123 + 1 | 0; | |
| $__i$0$i$i$i123 = $1238; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($111, $112), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($1228, $111), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($111), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($112), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($113), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($114), asyncState ? abort(-12) | 0 : 0; | |
| $$0 = $1222; | |
| break L1; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($114), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $$12; | |
| $$2332 = $$1221; | |
| break L7; | |
| break; | |
| } | |
| default: | |
| { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| } | |
| break; | |
| } | |
| case 110: | |
| { | |
| $1243 = $t$0 + 1 | 0; | |
| $1244 = (tempInt = SAFE_HEAP_LOAD($1243 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1245 = $1244 << 24 >> 24; | |
| switch ($1245 | 0) { | |
| case 119: | |
| case 97: | |
| { | |
| L385 : do { | |
| if ($146) { | |
| $1246 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1247 = $1246 << 24 >> 24 == 103; | |
| if ($1247) { | |
| $1248 = $first + 1 | 0; | |
| $1249 = (tempInt = SAFE_HEAP_LOAD($1248 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1250 = $1249 << 24 >> 24 == 115; | |
| $1251 = $first + 2 | 0; | |
| $$first$i = $1250 ? $1251 : $first; | |
| $$pre521 = (tempInt = SAFE_HEAP_LOAD($$first$i >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1253 = $$pre521; | |
| $parsed_gs$0$off0$i = $1250; | |
| $t$0$i274 = $$first$i; | |
| } else { | |
| $1253 = $1246; | |
| $parsed_gs$0$off0$i = 0; | |
| $t$0$i274 = $first; | |
| } | |
| $1252 = $1253 << 24 >> 24 == 110; | |
| if ($1252) { | |
| $1254 = $t$0$i274 + 1 | 0; | |
| $1255 = (tempInt = SAFE_HEAP_LOAD($1254 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($1255 << 24 >> 24 == 97 | $1255 << 24 >> 24 == 119) { | |
| $1256 = $1255 << 24 >> 24 == 97; | |
| $1257 = $t$0$i274 + 2 | 0; | |
| $1258 = ($1257 | 0) == ($last | 0); | |
| if ($1258) { | |
| $$9$i = $first; | |
| } else { | |
| $has_expr_list$0$off0$i = 0; | |
| $t$1$i = $1257; | |
| while (1) { | |
| $1259 = (tempInt = SAFE_HEAP_LOAD($t$1$i >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1260 = $1259 << 24 >> 24 == 95; | |
| if ($1260) { | |
| $has_expr_list$0$off0$i$lcssa = $has_expr_list$0$off0$i; | |
| $t$1$i$lcssa = $t$1$i; | |
| break; | |
| } | |
| $1261 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($t$1$i, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1262 = ($1261 | 0) == ($t$1$i | 0); | |
| $1263 = ($1261 | 0) == ($last | 0); | |
| $or$cond$i = $1262 | $1263; | |
| if ($or$cond$i) { | |
| label = 697; | |
| break; | |
| } else { | |
| $has_expr_list$0$off0$i = 1; | |
| $t$1$i = $1261; | |
| } | |
| } | |
| if ((label | 0) == 697) { | |
| $$9$i = $first; | |
| break; | |
| } | |
| $1264 = $t$1$i$lcssa + 1 | 0; | |
| $1265 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($1264, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1266 = ($1265 | 0) == ($1264 | 0); | |
| $1267 = ($1265 | 0) == ($last | 0); | |
| $or$cond22$i = $1266 | $1267; | |
| if ($or$cond22$i) { | |
| $$9$i = $first; | |
| } else { | |
| $1268 = $1265; | |
| $1269 = $142 - $1268 | 0; | |
| $1270 = ($1269 | 0) > 2; | |
| $1271 = (tempInt = SAFE_HEAP_LOAD($1265 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1272 = $1271 << 24 >> 24 == 112; | |
| $or$cond = $1270 & $1272; | |
| do { | |
| if ($or$cond) { | |
| $1273 = $1265 + 1 | 0; | |
| $1274 = (tempInt = SAFE_HEAP_LOAD($1273 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1275 = $1274 << 24 >> 24 == 105; | |
| if (!$1275) { | |
| $$9$i = $first; | |
| break L385; | |
| } | |
| $1276 = $1265 + 2 | 0; | |
| $t$2$i = $1276; | |
| while (1) { | |
| $1277 = (tempInt = SAFE_HEAP_LOAD($t$2$i >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1278 = $1277 << 24 >> 24 == 69; | |
| if ($1278) { | |
| $t$2$i$lcssa = $t$2$i; | |
| label = 577; | |
| break; | |
| } | |
| $1279 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($t$2$i, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1280 = ($1279 | 0) == ($t$2$i | 0); | |
| $1281 = ($1279 | 0) == ($last | 0); | |
| $or$cond23$i = $1280 | $1281; | |
| if ($or$cond23$i) { | |
| label = 696; | |
| break; | |
| } else { | |
| $t$2$i = $1279; | |
| } | |
| } | |
| if ((label | 0) == 577) { | |
| $has_init$0$off0$i527 = 1; | |
| $t$3$i526 = $t$2$i$lcssa; | |
| break; | |
| } else if ((label | 0) == 696) { | |
| $$9$i = $first; | |
| break L385; | |
| } | |
| } else { | |
| $1282 = $1271 << 24 >> 24 == 69; | |
| if ($1282) { | |
| $has_init$0$off0$i527 = 0; | |
| $t$3$i526 = $1265; | |
| } else { | |
| $$9$i = $first; | |
| break L385; | |
| } | |
| } | |
| } while (0); | |
| $__i$0$i$i$i275 = 0; | |
| while (1) { | |
| $exitcond$i$i$i276 = ($__i$0$i$i$i275 | 0) == 3; | |
| if ($exitcond$i$i$i276) { | |
| break; | |
| } | |
| $1283 = $init_list$i + ($__i$0$i$i$i275 << 2) | 0; | |
| SAFE_HEAP_STORE($1283 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1284 = $__i$0$i$i$i275 + 1 | 0; | |
| $__i$0$i$i$i275 = $1284; | |
| } | |
| if ($has_init$0$off0$i527) { | |
| $1285 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1286 = $db + 4 | 0; | |
| $1287 = (tempInt = SAFE_HEAP_LOAD($1286 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1288 = ($1285 | 0) == ($1287 | 0); | |
| if ($1288) { | |
| label = 689; | |
| } else { | |
| $1289 = $1287 + -24 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $27 | 0, $1289 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1290 = __THREW__; | |
| __THREW__ = 0; | |
| $1291 = $1290 & 1; | |
| if ($1291) { | |
| label = 601; | |
| } else { | |
| $1292 = (tempInt = SAFE_HEAP_LOAD($init_list$i >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1293 = $1292 & 1; | |
| $1294 = $1293 << 24 >> 24 == 0; | |
| L420 : do { | |
| if ($1294) { | |
| $1295 = $init_list$i + 1 | 0; | |
| SAFE_HEAP_STORE($1295 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($init_list$i >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1296 = $init_list$i + 8 | 0; | |
| $1297 = (tempInt = SAFE_HEAP_LOAD($1296 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1297 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1298 = $init_list$i + 4 | 0; | |
| SAFE_HEAP_STORE($1298 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1299 = (tempInt = SAFE_HEAP_LOAD($init_list$i | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1300 = $1299 & -2; | |
| $phitmp$i$i$i$i$i$i$i280 = $1300 + -1 | 0; | |
| $1301 = $1299 & 255; | |
| $1302 = $1301 & 1; | |
| $1303 = $1302 << 24 >> 24 == 0; | |
| do { | |
| if ($1303) { | |
| $1304 = $1299 >>> 1; | |
| $1305 = $1304 & 127; | |
| $1306 = ($1301 & 255) < 22; | |
| if ($1306) { | |
| $1313 = $init_list$i + 1 | 0; | |
| $1314 = $1299 >>> 1; | |
| $1315 = $1314 & 127; | |
| $1316 = $1315 + 1 | 0; | |
| (tempInt = _memcpy($1313 | 0, $1297 | 0, $1316 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($1297), asyncState ? abort(-12) | 0 : 0; | |
| $$ph532 = $1305; | |
| break; | |
| } | |
| $1307 = $1305 + 16 | 0; | |
| $1308 = $1307 & 240; | |
| $phitmp$i2$i$i$i$i$i$i283 = $1308 + -1 | 0; | |
| $1309 = ($phitmp$i2$i$i$i$i$i$i283 | 0) == ($phitmp$i$i$i$i$i$i$i280 | 0); | |
| if ($1309) { | |
| break L420; | |
| } | |
| $1310 = $phitmp$i2$i$i$i$i$i$i283 >>> 0 <= $phitmp$i$i$i$i$i$i$i280 >>> 0; | |
| $1311 = (tempInt = _malloc($1308) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1312 = ($1311 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i$i285 = $1310 & $1312; | |
| if ($or$cond$i$i$i$i$i$i285) { | |
| break L420; | |
| } | |
| $1318 = $init_list$i + 1 | 0; | |
| $1319 = $1299 >>> 1; | |
| $1320 = $1319 & 127; | |
| $1321 = $1320 + 1 | 0; | |
| (tempInt = _memcpy($1311 | 0, $1318 | 0, $1321 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1322 = $1308 | 1; | |
| SAFE_HEAP_STORE($init_list$i | 0, $1322 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1298 | 0, $1305 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1296 | 0, $1311 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| break L420; | |
| } else { | |
| $1317 = $init_list$i + 1 | 0; | |
| SAFE_HEAP_STORE($1317 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($1297), asyncState ? abort(-12) | 0 : 0; | |
| $$ph532 = 0; | |
| } | |
| } while (0); | |
| $1323 = $$ph532 << 1; | |
| $1324 = $1323 & 255; | |
| SAFE_HEAP_STORE($init_list$i >> 0 | 0, $1324 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($init_list$i + 0 | 0, (tempInt = SAFE_HEAP_LOAD($27 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($init_list$i + 4 | 0, (tempInt = SAFE_HEAP_LOAD($27 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($init_list$i + 8 | 0, (tempInt = SAFE_HEAP_LOAD($27 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i$i293 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i$i294 = ($__i$0$i$i$i$i$i293 | 0) == 3; | |
| if ($exitcond$i$i$i$i$i294) { | |
| break; | |
| } | |
| $1325 = $27 + ($__i$0$i$i$i$i$i293 << 2) | 0; | |
| SAFE_HEAP_STORE($1325 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1326 = $__i$0$i$i$i$i$i293 + 1 | 0; | |
| $__i$0$i$i$i$i$i293 = $1326; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($27), asyncState ? abort(-12) | 0 : 0; | |
| $1327 = (tempInt = SAFE_HEAP_LOAD($1286 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1328 = $1327 + -24 | 0; | |
| $1330 = $1327; | |
| while (1) { | |
| $1329 = ($1330 | 0) == ($1328 | 0); | |
| if ($1329) { | |
| break; | |
| } | |
| $1331 = $1330 + -24 | 0; | |
| SAFE_HEAP_STORE($1286 | 0, $1331 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1331), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i296 = (tempInt = SAFE_HEAP_LOAD($1286 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1330 = $$pre$i$i296; | |
| } | |
| $$pre$phiZ2D = $db; | |
| $1337 = $1328; | |
| label = 603; | |
| } | |
| } | |
| } else { | |
| $$phi$trans$insert = $db + 4 | 0; | |
| $$pre524 = (tempInt = SAFE_HEAP_LOAD($$phi$trans$insert | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $$pre$phiZ2D = $db; | |
| $1337 = $$pre524; | |
| label = 603; | |
| } | |
| do { | |
| if ((label | 0) == 603) { | |
| $1334 = (tempInt = SAFE_HEAP_LOAD($$pre$phiZ2D | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1335 = $db + 4 | 0; | |
| $1336 = ($1334 | 0) == ($1337 | 0); | |
| if ($1336) { | |
| label = 689; | |
| } else { | |
| $1338 = $1337 + -24 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $type$i | 0, $1338 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1339 = __THREW__; | |
| __THREW__ = 0; | |
| $1340 = $1339 & 1; | |
| if ($1340) { | |
| label = 601; | |
| } else { | |
| $1341 = (tempInt = SAFE_HEAP_LOAD($1335 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1342 = $1341 + -24 | 0; | |
| $1344 = $1341; | |
| while (1) { | |
| $1343 = ($1344 | 0) == ($1342 | 0); | |
| if ($1343) { | |
| break; | |
| } | |
| $1345 = $1344 + -24 | 0; | |
| SAFE_HEAP_STORE($1335 | 0, $1345 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1345), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i24$i = (tempInt = SAFE_HEAP_LOAD($1335 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1344 = $$pre$i24$i; | |
| } | |
| $__i$0$i$i26$i = 0; | |
| while (1) { | |
| $exitcond$i$i27$i = ($__i$0$i$i26$i | 0) == 3; | |
| if ($exitcond$i$i27$i) { | |
| break; | |
| } | |
| $1346 = $expr_list$i + ($__i$0$i$i26$i << 2) | 0; | |
| SAFE_HEAP_STORE($1346 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1347 = $__i$0$i$i26$i + 1 | 0; | |
| $__i$0$i$i26$i = $1347; | |
| } | |
| do { | |
| if ($has_expr_list$0$off0$i$lcssa) { | |
| $1348 = (tempInt = SAFE_HEAP_LOAD($$pre$phiZ2D | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1349 = ($1348 | 0) == ($1342 | 0); | |
| if ($1349) { | |
| $$019$i = $first; | |
| $$2$i312 = 1; | |
| label = 690; | |
| } else { | |
| $1350 = $1341 + -48 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $28 | 0, $1350 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1351 = __THREW__; | |
| __THREW__ = 0; | |
| $1352 = $1351 & 1; | |
| if ($1352) { | |
| $1393 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1394 = tempRet0; | |
| $$310$i = $1393; | |
| $$36$i = $1394; | |
| label = 693; | |
| break; | |
| } | |
| $1353 = (tempInt = SAFE_HEAP_LOAD($expr_list$i >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1354 = $1353 & 1; | |
| $1355 = $1354 << 24 >> 24 == 0; | |
| L459 : do { | |
| if ($1355) { | |
| $1356 = $expr_list$i + 1 | 0; | |
| SAFE_HEAP_STORE($1356 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($expr_list$i >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1357 = $expr_list$i + 8 | 0; | |
| $1358 = (tempInt = SAFE_HEAP_LOAD($1357 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1358 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1359 = $expr_list$i + 4 | 0; | |
| SAFE_HEAP_STORE($1359 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1360 = (tempInt = SAFE_HEAP_LOAD($expr_list$i | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1361 = $1360 & -2; | |
| $phitmp$i$i$i$i$i$i32$i = $1361 + -1 | 0; | |
| $1362 = $1360 & 255; | |
| $1363 = $1362 & 1; | |
| $1364 = $1363 << 24 >> 24 == 0; | |
| do { | |
| if ($1364) { | |
| $1365 = $1360 >>> 1; | |
| $1366 = $1365 & 127; | |
| $1367 = ($1362 & 255) < 22; | |
| if ($1367) { | |
| $1374 = $expr_list$i + 1 | 0; | |
| $1375 = $1360 >>> 1; | |
| $1376 = $1375 & 127; | |
| $1377 = $1376 + 1 | 0; | |
| (tempInt = _memcpy($1374 | 0, $1358 | 0, $1377 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($1358), asyncState ? abort(-12) | 0 : 0; | |
| $$ph534538 = $1366; | |
| break; | |
| } | |
| $1368 = $1366 + 16 | 0; | |
| $1369 = $1368 & 240; | |
| $phitmp$i2$i$i$i$i$i35$i = $1369 + -1 | 0; | |
| $1370 = ($phitmp$i2$i$i$i$i$i35$i | 0) == ($phitmp$i$i$i$i$i$i32$i | 0); | |
| if ($1370) { | |
| break L459; | |
| } | |
| $1371 = $phitmp$i2$i$i$i$i$i35$i >>> 0 <= $phitmp$i$i$i$i$i$i32$i >>> 0; | |
| $1372 = (tempInt = _malloc($1369) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1373 = ($1372 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i37$i = $1371 & $1373; | |
| if ($or$cond$i$i$i$i$i37$i) { | |
| break L459; | |
| } | |
| $1379 = $expr_list$i + 1 | 0; | |
| $1380 = $1360 >>> 1; | |
| $1381 = $1380 & 127; | |
| $1382 = $1381 + 1 | 0; | |
| (tempInt = _memcpy($1372 | 0, $1379 | 0, $1382 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1383 = $1369 | 1; | |
| SAFE_HEAP_STORE($expr_list$i | 0, $1383 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1359 | 0, $1366 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1357 | 0, $1372 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| break L459; | |
| } else { | |
| $1378 = $expr_list$i + 1 | 0; | |
| SAFE_HEAP_STORE($1378 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($1358), asyncState ? abort(-12) | 0 : 0; | |
| $$ph534538 = 0; | |
| } | |
| } while (0); | |
| $1384 = $$ph534538 << 1; | |
| $1385 = $1384 & 255; | |
| SAFE_HEAP_STORE($expr_list$i >> 0 | 0, $1385 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($expr_list$i + 0 | 0, (tempInt = SAFE_HEAP_LOAD($28 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($expr_list$i + 4 | 0, (tempInt = SAFE_HEAP_LOAD($28 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($expr_list$i + 8 | 0, (tempInt = SAFE_HEAP_LOAD($28 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i45$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i46$i = ($__i$0$i$i$i$i45$i | 0) == 3; | |
| if ($exitcond$i$i$i$i46$i) { | |
| break; | |
| } | |
| $1386 = $28 + ($__i$0$i$i$i$i45$i << 2) | 0; | |
| SAFE_HEAP_STORE($1386 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1387 = $__i$0$i$i$i$i45$i + 1 | 0; | |
| $__i$0$i$i$i$i45$i = $1387; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($28), asyncState ? abort(-12) | 0 : 0; | |
| $1388 = (tempInt = SAFE_HEAP_LOAD($1335 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1389 = $1388 + -24 | 0; | |
| $1391 = $1388; | |
| while (1) { | |
| $1390 = ($1391 | 0) == ($1389 | 0); | |
| if ($1390) { | |
| break; | |
| } | |
| $1392 = $1391 + -24 | 0; | |
| SAFE_HEAP_STORE($1335 | 0, $1392 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1392), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i48$i = (tempInt = SAFE_HEAP_LOAD($1335 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1391 = $$pre$i48$i; | |
| } | |
| label = 632; | |
| } | |
| } else { | |
| label = 632; | |
| } | |
| } while (0); | |
| L480 : do { | |
| if ((label | 0) == 632) { | |
| $__i$0$i$i50$i = 0; | |
| while (1) { | |
| $exitcond$i$i51$i = ($__i$0$i$i50$i | 0) == 3; | |
| if ($exitcond$i$i51$i) { | |
| break; | |
| } | |
| $1395 = $r$i + ($__i$0$i$i50$i << 2) | 0; | |
| SAFE_HEAP_STORE($1395 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1396 = $__i$0$i$i50$i + 1 | 0; | |
| $__i$0$i$i50$i = $1396; | |
| } | |
| if ($parsed_gs$0$off0$i) { | |
| __THREW__ = 0; | |
| invoke_viii(23, $r$i | 0, 2936 | 0, 2), asyncState ? abort(-12) | 0 : 0; | |
| $1397 = __THREW__; | |
| __THREW__ = 0; | |
| $1398 = $1397 & 1; | |
| if ($1398) { | |
| label = 637; | |
| } else { | |
| label = 638; | |
| } | |
| } else { | |
| label = 638; | |
| } | |
| L488 : do { | |
| if ((label | 0) == 638) { | |
| if ($1256) { | |
| __THREW__ = 0; | |
| (tempInt = invoke_iii(5, $r$i | 0, 3352 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1401 = __THREW__; | |
| __THREW__ = 0; | |
| $1402 = $1401 & 1; | |
| if ($1402) { | |
| label = 637; | |
| break; | |
| } | |
| } else { | |
| __THREW__ = 0; | |
| (tempInt = invoke_iii(5, $r$i | 0, 2840 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1403 = __THREW__; | |
| __THREW__ = 0; | |
| $1404 = $1403 & 1; | |
| if ($1404) { | |
| label = 637; | |
| break; | |
| } | |
| } | |
| L494 : do { | |
| if ($has_expr_list$0$off0$i$lcssa) { | |
| __THREW__ = 0; | |
| invoke_viii(19, $30 | 0, 2768 | 0, $expr_list$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1405 = __THREW__; | |
| __THREW__ = 0; | |
| $1406 = $1405 & 1; | |
| if ($1406) { | |
| label = 637; | |
| break L488; | |
| } | |
| __THREW__ = 0; | |
| $1407 = (tempInt = invoke_iii(5, $30 | 0, 3360 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1408 = __THREW__; | |
| __THREW__ = 0; | |
| $1409 = $1408 & 1; | |
| do { | |
| if ($1409) { | |
| $1426 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1427 = tempRet0; | |
| $$03$i305 = $1427; | |
| $$07$i = $1426; | |
| } else { | |
| SAFE_HEAP_STORE($29 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1407 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($29 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1407 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($29 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1407 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i300 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i301 = ($__i$0$i$i$i$i300 | 0) == 3; | |
| if ($exitcond$i$i$i$i301) { | |
| break; | |
| } | |
| $1410 = $1407 + ($__i$0$i$i$i$i300 << 2) | 0; | |
| SAFE_HEAP_STORE($1410 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1411 = $__i$0$i$i$i$i300 + 1 | 0; | |
| $__i$0$i$i$i$i300 = $1411; | |
| } | |
| $1412 = (tempInt = SAFE_HEAP_LOAD($29 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1413 = $1412 & 1; | |
| $1414 = $1413 << 24 >> 24 == 0; | |
| if ($1414) { | |
| $1419 = $29 + 1 | 0; | |
| $1420 = $1412 & 255; | |
| $1421 = $1420 >>> 1; | |
| $1422 = $1419; | |
| $1423 = $1421; | |
| } else { | |
| $1415 = $29 + 8 | 0; | |
| $1416 = (tempInt = SAFE_HEAP_LOAD($1415 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1417 = $29 + 4 | 0; | |
| $1418 = (tempInt = SAFE_HEAP_LOAD($1417 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1422 = $1416; | |
| $1423 = $1418; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiii(3, $r$i | 0, $1422 | 0, $1423 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1424 = __THREW__; | |
| __THREW__ = 0; | |
| $1425 = $1424 & 1; | |
| if ($1425) { | |
| $1428 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1429 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($29), asyncState ? abort(-12) | 0 : 0; | |
| $$03$i305 = $1429; | |
| $$07$i = $1428; | |
| break; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($29), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($30), asyncState ? abort(-12) | 0 : 0; | |
| break L494; | |
| } | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($30), asyncState ? abort(-12) | 0 : 0; | |
| $$25$i = $$03$i305; | |
| $$29$i = $$07$i; | |
| break L488; | |
| } | |
| } while (0); | |
| $1430 = (tempInt = SAFE_HEAP_LOAD($type$i >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1431 = $1430 & 1; | |
| $1432 = $1431 << 24 >> 24 == 0; | |
| if ($1432) { | |
| $1437 = $type$i + 1 | 0; | |
| $1438 = $1430 & 255; | |
| $1439 = $1438 >>> 1; | |
| $1440 = $1437; | |
| $1441 = $1439; | |
| } else { | |
| $1433 = $type$i + 8 | 0; | |
| $1434 = (tempInt = SAFE_HEAP_LOAD($1433 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1435 = $type$i + 4 | 0; | |
| $1436 = (tempInt = SAFE_HEAP_LOAD($1435 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1440 = $1434; | |
| $1441 = $1436; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiii(3, $r$i | 0, $1440 | 0, $1441 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1442 = __THREW__; | |
| __THREW__ = 0; | |
| $1443 = $1442 & 1; | |
| if ($1443) { | |
| label = 637; | |
| break; | |
| } | |
| L518 : do { | |
| if ($has_init$0$off0$i527) { | |
| __THREW__ = 0; | |
| invoke_viii(19, $32 | 0, 2752 | 0, $init_list$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1444 = __THREW__; | |
| __THREW__ = 0; | |
| $1445 = $1444 & 1; | |
| if ($1445) { | |
| label = 637; | |
| break L488; | |
| } | |
| __THREW__ = 0; | |
| $1446 = (tempInt = invoke_iii(5, $32 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1447 = __THREW__; | |
| __THREW__ = 0; | |
| $1448 = $1447 & 1; | |
| do { | |
| if ($1448) { | |
| $1465 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1466 = tempRet0; | |
| $$14$i = $1466; | |
| $$18$i = $1465; | |
| } else { | |
| SAFE_HEAP_STORE($31 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1446 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($31 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1446 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($31 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1446 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i58$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i59$i = ($__i$0$i$i$i58$i | 0) == 3; | |
| if ($exitcond$i$i$i59$i) { | |
| break; | |
| } | |
| $1449 = $1446 + ($__i$0$i$i$i58$i << 2) | 0; | |
| SAFE_HEAP_STORE($1449 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1450 = $__i$0$i$i$i58$i + 1 | 0; | |
| $__i$0$i$i$i58$i = $1450; | |
| } | |
| $1451 = (tempInt = SAFE_HEAP_LOAD($31 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1452 = $1451 & 1; | |
| $1453 = $1452 << 24 >> 24 == 0; | |
| if ($1453) { | |
| $1458 = $31 + 1 | 0; | |
| $1459 = $1451 & 255; | |
| $1460 = $1459 >>> 1; | |
| $1461 = $1458; | |
| $1462 = $1460; | |
| } else { | |
| $1454 = $31 + 8 | 0; | |
| $1455 = (tempInt = SAFE_HEAP_LOAD($1454 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1456 = $31 + 4 | 0; | |
| $1457 = (tempInt = SAFE_HEAP_LOAD($1456 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1461 = $1455; | |
| $1462 = $1457; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiii(3, $r$i | 0, $1461 | 0, $1462 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1463 = __THREW__; | |
| __THREW__ = 0; | |
| $1464 = $1463 & 1; | |
| if ($1464) { | |
| $1467 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1468 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($31), asyncState ? abort(-12) | 0 : 0; | |
| $$14$i = $1468; | |
| $$18$i = $1467; | |
| break; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($31), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($32), asyncState ? abort(-12) | 0 : 0; | |
| break L518; | |
| } | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($32), asyncState ? abort(-12) | 0 : 0; | |
| $$25$i = $$14$i; | |
| $$29$i = $$18$i; | |
| break L488; | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($34 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($r$i + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($34 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($r$i + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($34 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($r$i + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i65$i = 0; | |
| while (1) { | |
| $exitcond$i$i66$i = ($__i$0$i$i65$i | 0) == 3; | |
| if ($exitcond$i$i66$i) { | |
| break; | |
| } | |
| $1469 = $r$i + ($__i$0$i$i65$i << 2) | 0; | |
| SAFE_HEAP_STORE($1469 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1470 = $__i$0$i$i65$i + 1 | 0; | |
| $__i$0$i$i65$i = $1470; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($33, $34), asyncState ? abort(-12) | 0 : 0; | |
| $1471 = (tempInt = SAFE_HEAP_LOAD($1335 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1472 = $db + 8 | 0; | |
| $1473 = (tempInt = SAFE_HEAP_LOAD($1472 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1474 = $1471 >>> 0 < $1473 >>> 0; | |
| if ($1474) { | |
| $1475 = ($1471 | 0) == (0 | 0); | |
| if ($1475) { | |
| $1477 = 0; | |
| } else { | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2EOS1_($1471, $33), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i67$i = (tempInt = SAFE_HEAP_LOAD($1335 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1477 = $$pre$i67$i; | |
| } | |
| $1476 = $1477 + 24 | 0; | |
| SAFE_HEAP_STORE($1335 | 0, $1476 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1478 = $db + 12 | 0; | |
| $1479 = (tempInt = SAFE_HEAP_LOAD($$pre$phiZ2D | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1480 = $1471; | |
| $1481 = $1479; | |
| $1482 = $1480 - $1481 | 0; | |
| $1483 = ($1482 | 0) / 24 & -1; | |
| $1484 = $1483 + 1 | 0; | |
| $1485 = ($1484 | 0) < 0; | |
| if ($1485) { | |
| __THREW__ = 0; | |
| invoke_vi(14, $db | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1486 = __THREW__; | |
| __THREW__ = 0; | |
| $1487 = $1486 & 1; | |
| if ($1487) { | |
| $1500 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1501 = tempRet0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($33), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($34), asyncState ? abort(-12) | 0 : 0; | |
| $$25$i = $1501; | |
| $$29$i = $1500; | |
| break; | |
| } else {} | |
| } | |
| $1488 = $1473; | |
| $1489 = $1488 - $1481 | 0; | |
| $1490 = ($1489 | 0) / 24 & -1; | |
| $1491 = $1490 >>> 0 < 1073741823; | |
| if ($1491) { | |
| $1492 = $1490 << 1; | |
| $1493 = $1492 >>> 0 < $1484 >>> 0; | |
| $1494 = $1493 ? $1484 : $1492; | |
| $$0$i$i$i$i308 = $1494; | |
| } else { | |
| $$0$i$i$i$i308 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEEC2EjjS6_($__v$i$i$i273, $$0$i$i$i$i308, $1483, $1478), asyncState ? abort(-12) | 0 : 0; | |
| $1495 = $__v$i$i$i273 + 8 | 0; | |
| $1496 = (tempInt = SAFE_HEAP_LOAD($1495 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1497 = ($1496 | 0) == (0 | 0); | |
| if (!$1497) { | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2EOS1_($1496, $33), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1498 = $1496 + 24 | 0; | |
| SAFE_HEAP_STORE($1495 | 0, $1498 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS3_RS5_EE($db, $__v$i$i$i273), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i$i273), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($33), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($34), asyncState ? abort(-12) | 0 : 0; | |
| $1499 = $t$3$i526 + 1 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($r$i), asyncState ? abort(-12) | 0 : 0; | |
| $$019$i = $1499; | |
| $$2$i312 = 0; | |
| label = 690; | |
| break L480; | |
| } | |
| } while (0); | |
| if ((label | 0) == 637) { | |
| $1399 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1400 = tempRet0; | |
| $$25$i = $1400; | |
| $$29$i = $1399; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($r$i), asyncState ? abort(-12) | 0 : 0; | |
| $$310$i = $$29$i; | |
| $$36$i = $$25$i; | |
| label = 693; | |
| } | |
| } while (0); | |
| if ((label | 0) == 690) { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($expr_list$i), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($type$i), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($init_list$i), asyncState ? abort(-12) | 0 : 0; | |
| if ($$2$i312) { | |
| $$9$i = $first; | |
| break L385; | |
| } else { | |
| $$221$i = $$019$i; | |
| label = 695; | |
| break L385; | |
| } | |
| } else if ((label | 0) == 693) { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($expr_list$i), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($type$i), asyncState ? abort(-12) | 0 : 0; | |
| $$4$i314 = $$36$i; | |
| $$411$i = $$310$i; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } while (0); | |
| if ((label | 0) == 601) { | |
| $1332 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1333 = tempRet0; | |
| $$4$i314 = $1333; | |
| $$411$i = $1332; | |
| } else if ((label | 0) == 689) { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($init_list$i), asyncState ? abort(-12) | 0 : 0; | |
| $$9$i = $first; | |
| break; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($init_list$i), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$411$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } else { | |
| $$221$i = $first; | |
| label = 695; | |
| } | |
| } else { | |
| $$221$i = $first; | |
| label = 695; | |
| } | |
| } else { | |
| $$221$i = $first; | |
| label = 695; | |
| } | |
| } while (0); | |
| if ((label | 0) == 695) { | |
| $$9$i = $$221$i; | |
| } | |
| $$0 = $$9$i; | |
| break L1; | |
| break; | |
| } | |
| case 101: | |
| { | |
| $1502 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($115, 3088, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1503 = (tempInt = invoke_iiiii(21, $1502 | 0, $last | 0, $115 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1504 = __THREW__; | |
| __THREW__ = 0; | |
| $1505 = $1504 & 1; | |
| if ($1505) { | |
| $1507 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1508 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($115), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1507; | |
| $$2332 = $1508; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($115), asyncState ? abort(-12) | 0 : 0; | |
| $1506 = ($1503 | 0) == ($1502 | 0); | |
| $first$56 = $1506 ? $first : $1503; | |
| $$0 = $first$56; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 103: | |
| { | |
| $1509 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($116, 3048, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1510 = (tempInt = invoke_iiiii(22, $1509 | 0, $last | 0, $116 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1511 = __THREW__; | |
| __THREW__ = 0; | |
| $1512 = $1511 & 1; | |
| if ($1512) { | |
| $1514 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1515 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($116), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1514; | |
| $$2332 = $1515; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($116), asyncState ? abort(-12) | 0 : 0; | |
| $1513 = ($1510 | 0) == ($1509 | 0); | |
| $first$57 = $1513 ? $first : $1510; | |
| $$0 = $first$57; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 116: | |
| { | |
| $1516 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($117, 3096, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1517 = (tempInt = invoke_iiiii(22, $1516 | 0, $last | 0, $117 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1518 = __THREW__; | |
| __THREW__ = 0; | |
| $1519 = $1518 & 1; | |
| if ($1519) { | |
| $1521 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1522 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($117), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1521; | |
| $$2332 = $1522; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($117), asyncState ? abort(-12) | 0 : 0; | |
| $1520 = ($1517 | 0) == ($1516 | 0); | |
| $first$58 = $1520 ? $first : $1517; | |
| $$0 = $first$58; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 120: | |
| { | |
| $1523 = $first + 2 | 0; | |
| $1524 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($1523, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1525 = ($1524 | 0) == ($1523 | 0); | |
| L586 : do { | |
| if ($1525) { | |
| $$03$i272 = $1523; | |
| } else { | |
| $1526 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1527 = $db + 4 | 0; | |
| $1528 = (tempInt = SAFE_HEAP_LOAD($1527 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1529 = ($1526 | 0) == ($1528 | 0); | |
| if ($1529) { | |
| $$03$i272 = $1523; | |
| } else { | |
| $1530 = $1528 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($37, $1530), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1531 = (tempInt = invoke_iiii(4, $37 | 0, 0, 3336 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1532 = __THREW__; | |
| __THREW__ = 0; | |
| $1533 = $1532 & 1; | |
| do { | |
| if ($1533) { | |
| $1587 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1588 = tempRet0; | |
| $$1$i271 = $1588; | |
| $$12$i270 = $1587; | |
| } else { | |
| SAFE_HEAP_STORE($36 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1531 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($36 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1531 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($36 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1531 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i263 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i264 = ($__i$0$i$i$i$i263 | 0) == 3; | |
| if ($exitcond$i$i$i$i264) { | |
| break; | |
| } | |
| $1534 = $1531 + ($__i$0$i$i$i$i263 << 2) | 0; | |
| SAFE_HEAP_STORE($1534 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1535 = $__i$0$i$i$i$i263 + 1 | 0; | |
| $__i$0$i$i$i$i263 = $1535; | |
| } | |
| __THREW__ = 0; | |
| $1536 = (tempInt = invoke_iii(5, $36 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1537 = __THREW__; | |
| __THREW__ = 0; | |
| $1538 = $1537 & 1; | |
| if ($1538) { | |
| $1589 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1590 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($36), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i271 = $1590; | |
| $$12$i270 = $1589; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($35 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1536 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($35 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1536 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($35 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1536 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i5$i267 = 0; | |
| while (1) { | |
| $exitcond$i$i$i6$i268 = ($__i$0$i$i$i5$i267 | 0) == 3; | |
| if ($exitcond$i$i$i6$i268) { | |
| break; | |
| } | |
| $1539 = $1536 + ($__i$0$i$i$i5$i267 << 2) | 0; | |
| SAFE_HEAP_STORE($1539 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1540 = $__i$0$i$i$i5$i267 + 1 | 0; | |
| $__i$0$i$i$i5$i267 = $1540; | |
| } | |
| $1541 = (tempInt = SAFE_HEAP_LOAD($1530 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1542 = $1541 & 1; | |
| $1543 = $1542 << 24 >> 24 == 0; | |
| do { | |
| if ($1543) { | |
| $1544 = $1530 + 1 | 0; | |
| SAFE_HEAP_STORE($1544 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1530 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1545 = $1528 + -16 | 0; | |
| $1546 = (tempInt = SAFE_HEAP_LOAD($1545 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1546 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1547 = $1528 + -20 | 0; | |
| SAFE_HEAP_STORE($1547 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i$i$i = (tempInt = SAFE_HEAP_LOAD($1530 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1548 = $$pre$i$i$i$i & 1; | |
| $1549 = $1548 << 24 >> 24 == 0; | |
| if ($1549) { | |
| $1554 = $$pre$i$i$i$i; | |
| $1563 = 10; | |
| } else { | |
| $1550 = (tempInt = SAFE_HEAP_LOAD($1530 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1551 = $1550 & -2; | |
| $phitmp$i$i$i$i$i$i$i = $1551 + -1 | 0; | |
| $1552 = $1550 & 255; | |
| $1554 = $1552; | |
| $1563 = $phitmp$i$i$i$i$i$i$i; | |
| } | |
| $1553 = $1554 & 1; | |
| $1555 = $1553 << 24 >> 24 == 0; | |
| if ($1555) { | |
| $1556 = $1554 & 255; | |
| $1557 = $1556 >>> 1; | |
| $1558 = ($1554 & 255) < 22; | |
| if ($1558) { | |
| $1562 = 10; | |
| $1582 = $1557; | |
| $2330 = 1; | |
| } else { | |
| $1559 = $1557 + 16 | 0; | |
| $1560 = $1559 & 240; | |
| $phitmp$i2$i$i$i$i$i$i = $1560 + -1 | 0; | |
| $1562 = $phitmp$i2$i$i$i$i$i$i; | |
| $1582 = $1557; | |
| $2330 = 1; | |
| } | |
| } else { | |
| $1562 = 10; | |
| $1582 = 0; | |
| $2330 = 0; | |
| } | |
| $1561 = ($1562 | 0) == ($1563 | 0); | |
| if (!$1561) { | |
| $1564 = ($1562 | 0) == 10; | |
| if ($1564) { | |
| $1569 = $1530 + 1 | 0; | |
| $1570 = (tempInt = SAFE_HEAP_LOAD($1545 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2330) { | |
| $1571 = $1554 & 255; | |
| $1572 = $1571 >>> 1; | |
| $1573 = $1572 + 1 | 0; | |
| (tempInt = _memcpy($1569 | 0, $1570 | 0, $1573 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($1570), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1578 = (tempInt = SAFE_HEAP_LOAD($1570 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1569 >> 0 | 0, $1578 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($1570), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1583 = $1582 << 1; | |
| $1584 = $1583 & 255; | |
| SAFE_HEAP_STORE($1530 >> 0 | 0, $1584 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $1565 = $1562 >>> 0 <= $1563 >>> 0; | |
| $1566 = $1562 + 1 | 0; | |
| $1567 = (tempInt = _malloc($1566) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1568 = ($1567 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i$i = $1565 & $1568; | |
| if (!$or$cond$i$i$i$i$i$i) { | |
| if ($2330) { | |
| $1574 = $1530 + 1 | 0; | |
| $1575 = $1554 & 255; | |
| $1576 = $1575 >>> 1; | |
| $1577 = $1576 + 1 | 0; | |
| (tempInt = _memcpy($1567 | 0, $1574 | 0, $1577 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } else { | |
| $1579 = (tempInt = SAFE_HEAP_LOAD($1545 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1580 = (tempInt = SAFE_HEAP_LOAD($1579 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1567 >> 0 | 0, $1580 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($1579), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1581 = $1566 | 1; | |
| SAFE_HEAP_STORE($1530 | 0, $1581 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1547 | 0, $1582 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1545 | 0, $1567 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($1530 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($35 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1530 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($35 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1530 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($35 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i$i = ($__i$0$i$i$i$i$i | 0) == 3; | |
| if ($exitcond$i$i$i$i$i) { | |
| break; | |
| } | |
| $1585 = $35 + ($__i$0$i$i$i$i$i << 2) | 0; | |
| SAFE_HEAP_STORE($1585 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1586 = $__i$0$i$i$i$i$i + 1 | 0; | |
| $__i$0$i$i$i$i$i = $1586; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($35), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($36), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($37), asyncState ? abort(-12) | 0 : 0; | |
| $$03$i272 = $1524; | |
| break L586; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($37), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$12$i270 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } while (0); | |
| $1591 = ($$03$i272 | 0) == ($1523 | 0); | |
| $first$59 = $1591 ? $first : $$03$i272; | |
| $$0 = $first$59; | |
| break L1; | |
| break; | |
| } | |
| default: | |
| { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| } | |
| break; | |
| } | |
| case 111: | |
| { | |
| $1592 = $t$0 + 1 | 0; | |
| $1593 = (tempInt = SAFE_HEAP_LOAD($1592 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1594 = $1593 << 24 >> 24; | |
| if (($1594 | 0) == 110) { | |
| $1595 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_121parse_unresolved_nameINS0_2DbEEEPKcS4_S4_RT_($first, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $$0 = $1595; | |
| break L1; | |
| } else if (($1594 | 0) == 111) { | |
| $1596 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($118, 3104, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1597 = (tempInt = invoke_iiiii(21, $1596 | 0, $last | 0, $118 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1598 = __THREW__; | |
| __THREW__ = 0; | |
| $1599 = $1598 & 1; | |
| if ($1599) { | |
| $1601 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1602 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($118), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1601; | |
| $$2332 = $1602; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($118), asyncState ? abort(-12) | 0 : 0; | |
| $1600 = ($1597 | 0) == ($1596 | 0); | |
| $first$60 = $1600 ? $first : $1597; | |
| $$0 = $first$60; | |
| break L1; | |
| } | |
| } else if (($1594 | 0) == 114) { | |
| $1603 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($119, 3112, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1604 = (tempInt = invoke_iiiii(21, $1603 | 0, $last | 0, $119 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1605 = __THREW__; | |
| __THREW__ = 0; | |
| $1606 = $1605 & 1; | |
| if ($1606) { | |
| $1608 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1609 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($119), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1608; | |
| $$2332 = $1609; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($119), asyncState ? abort(-12) | 0 : 0; | |
| $1607 = ($1604 | 0) == ($1603 | 0); | |
| $first$61 = $1607 ? $first : $1604; | |
| $$0 = $first$61; | |
| break L1; | |
| } | |
| } else if (($1594 | 0) == 82) { | |
| $1610 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($120, 3120, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1611 = (tempInt = invoke_iiiii(21, $1610 | 0, $last | 0, $120 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1612 = __THREW__; | |
| __THREW__ = 0; | |
| $1613 = $1612 & 1; | |
| if ($1613) { | |
| $1615 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1616 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($120), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1615; | |
| $$2332 = $1616; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($120), asyncState ? abort(-12) | 0 : 0; | |
| $1614 = ($1611 | 0) == ($1610 | 0); | |
| $first$62 = $1614 ? $first : $1611; | |
| $$0 = $first$62; | |
| break L1; | |
| } | |
| } else { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 112: | |
| { | |
| $1617 = $t$0 + 1 | 0; | |
| $1618 = (tempInt = SAFE_HEAP_LOAD($1617 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1619 = $1618 << 24 >> 24; | |
| switch ($1619 | 0) { | |
| case 109: | |
| { | |
| $1620 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($121, 3128, 3), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1621 = (tempInt = invoke_iiiii(21, $1620 | 0, $last | 0, $121 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1622 = __THREW__; | |
| __THREW__ = 0; | |
| $1623 = $1622 & 1; | |
| if ($1623) { | |
| $1625 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1626 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($121), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1625; | |
| $$2332 = $1626; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($121), asyncState ? abort(-12) | 0 : 0; | |
| $1624 = ($1621 | 0) == ($1620 | 0); | |
| $first$63 = $1624 ? $first : $1621; | |
| $$0 = $first$63; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 108: | |
| { | |
| $1627 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($122, 3136, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1628 = (tempInt = invoke_iiiii(21, $1627 | 0, $last | 0, $122 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1629 = __THREW__; | |
| __THREW__ = 0; | |
| $1630 = $1629 & 1; | |
| if ($1630) { | |
| $1632 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1633 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($122), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1632; | |
| $$2332 = $1633; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($122), asyncState ? abort(-12) | 0 : 0; | |
| $1631 = ($1628 | 0) == ($1627 | 0); | |
| $first$64 = $1631 ? $first : $1628; | |
| $$0 = $first$64; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 76: | |
| { | |
| $1634 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($123, 3144, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1635 = (tempInt = invoke_iiiii(21, $1634 | 0, $last | 0, $123 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1636 = __THREW__; | |
| __THREW__ = 0; | |
| $1637 = $1636 & 1; | |
| if ($1637) { | |
| $1639 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1640 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($123), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1639; | |
| $$2332 = $1640; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($123), asyncState ? abort(-12) | 0 : 0; | |
| $1638 = ($1635 | 0) == ($1634 | 0); | |
| $first$65 = $1638 ? $first : $1635; | |
| $$0 = $first$65; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 112: | |
| { | |
| $1641 = $first + 2 | 0; | |
| $1642 = ($1641 | 0) == ($last | 0); | |
| if (!$1642) { | |
| $1643 = (tempInt = SAFE_HEAP_LOAD($1641 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1644 = $1643 << 24 >> 24 == 95; | |
| if ($1644) { | |
| $1645 = $first + 3 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($124, 3152, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1646 = (tempInt = invoke_iiiii(22, $1645 | 0, $last | 0, $124 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1647 = __THREW__; | |
| __THREW__ = 0; | |
| $1648 = $1647 & 1; | |
| if ($1648) { | |
| $1650 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1651 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($124), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1650; | |
| $$2332 = $1651; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($124), asyncState ? abort(-12) | 0 : 0; | |
| $1649 = ($1646 | 0) == ($1645 | 0); | |
| $first$66 = $1649 ? $first : $1646; | |
| $$0 = $first$66; | |
| break L1; | |
| } | |
| } | |
| } | |
| $1652 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($1641, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1653 = ($1652 | 0) == ($1641 | 0); | |
| if ($1653) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1654 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1655 = $db + 4 | 0; | |
| $1656 = (tempInt = SAFE_HEAP_LOAD($1655 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1657 = ($1654 | 0) == ($1656 | 0); | |
| if ($1657) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1658 = $1656 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($128, $1658), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1659 = (tempInt = invoke_iiii(4, $128 | 0, 0, 2768 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1660 = __THREW__; | |
| __THREW__ = 0; | |
| $1661 = $1660 & 1; | |
| do { | |
| if ($1661) { | |
| $1669 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1670 = tempRet0; | |
| $$14 = $1669; | |
| $$1423 = $1670; | |
| } else { | |
| SAFE_HEAP_STORE($127 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1659 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($127 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1659 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($127 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1659 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i127 = 0; | |
| while (1) { | |
| $exitcond$i$i$i128 = ($__i$0$i$i$i127 | 0) == 3; | |
| if ($exitcond$i$i$i128) { | |
| break; | |
| } | |
| $1662 = $1659 + ($__i$0$i$i$i127 << 2) | 0; | |
| SAFE_HEAP_STORE($1662 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1663 = $__i$0$i$i$i127 + 1 | 0; | |
| $__i$0$i$i$i127 = $1663; | |
| } | |
| __THREW__ = 0; | |
| $1664 = (tempInt = invoke_iii(5, $127 | 0, 3160 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1665 = __THREW__; | |
| __THREW__ = 0; | |
| $1666 = $1665 & 1; | |
| if ($1666) { | |
| $1671 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1672 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($127), asyncState ? abort(-12) | 0 : 0; | |
| $$14 = $1671; | |
| $$1423 = $1672; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($126 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1664 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($126 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1664 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($126 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1664 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i131 = 0; | |
| while (1) { | |
| $exitcond$i$i$i132 = ($__i$0$i$i$i131 | 0) == 3; | |
| if ($exitcond$i$i$i132) { | |
| break; | |
| } | |
| $1667 = $1664 + ($__i$0$i$i$i131 << 2) | 0; | |
| SAFE_HEAP_STORE($1667 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1668 = $__i$0$i$i$i131 + 1 | 0; | |
| $__i$0$i$i$i131 = $1668; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($125, $126), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($1658, $125), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($125), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($126), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($127), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($128), asyncState ? abort(-12) | 0 : 0; | |
| $$0 = $1652; | |
| break L1; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($128), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $$14; | |
| $$2332 = $$1423; | |
| break L7; | |
| break; | |
| } | |
| case 115: | |
| { | |
| $1673 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($129, 3136, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1674 = (tempInt = invoke_iiiii(22, $1673 | 0, $last | 0, $129 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1675 = __THREW__; | |
| __THREW__ = 0; | |
| $1676 = $1675 & 1; | |
| if ($1676) { | |
| $1678 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1679 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($129), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1678; | |
| $$2332 = $1679; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($129), asyncState ? abort(-12) | 0 : 0; | |
| $1677 = ($1674 | 0) == ($1673 | 0); | |
| $first$67 = $1677 ? $first : $1674; | |
| $$0 = $first$67; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 116: | |
| { | |
| $1680 = ($144 | 0) > 2; | |
| do { | |
| if ($1680) { | |
| $1681 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1682 = $1681 << 24 >> 24 == 112; | |
| if ($1682) { | |
| $1683 = $first + 1 | 0; | |
| $1684 = (tempInt = SAFE_HEAP_LOAD($1683 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1685 = $1684 << 24 >> 24 == 116; | |
| if ($1685) { | |
| $1686 = $first + 2 | 0; | |
| $1687 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($1686, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1688 = ($1687 | 0) == ($1686 | 0); | |
| if ($1688) { | |
| $$0$i261 = $first; | |
| } else { | |
| $1689 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($1687, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1690 = ($1689 | 0) == ($1687 | 0); | |
| if ($1690) { | |
| $$0$i261 = $first; | |
| } else { | |
| $1691 = $db + 4 | 0; | |
| $1692 = (tempInt = SAFE_HEAP_LOAD($1691 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1693 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1694 = $1692; | |
| $1695 = $1693; | |
| $1696 = $1694 - $1695 | 0; | |
| $1697 = ($1696 | 0) / 24 & -1; | |
| $1698 = $1697 >>> 0 < 2; | |
| if ($1698) { | |
| $$0$i261 = $first; | |
| } else { | |
| $1699 = $1692 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($tmp$i255, $1699), asyncState ? abort(-12) | 0 : 0; | |
| $1700 = (tempInt = SAFE_HEAP_LOAD($1691 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1701 = $1700 + -24 | 0; | |
| $1703 = $1700; | |
| while (1) { | |
| $1702 = ($1703 | 0) == ($1701 | 0); | |
| if ($1702) { | |
| break; | |
| } | |
| $1704 = $1703 + -24 | 0; | |
| SAFE_HEAP_STORE($1691 | 0, $1704 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1704), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i256 = (tempInt = SAFE_HEAP_LOAD($1691 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1703 = $$pre$i$i256; | |
| } | |
| $1705 = $1700 + -48 | 0; | |
| __THREW__ = 0; | |
| (tempInt = invoke_iii(5, $1705 | 0, 3328 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1706 = __THREW__; | |
| __THREW__ = 0; | |
| $1707 = $1706 & 1; | |
| if (!$1707) { | |
| $1708 = (tempInt = SAFE_HEAP_LOAD($1691 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1709 = $1708 + -24 | 0; | |
| $1710 = (tempInt = SAFE_HEAP_LOAD($tmp$i255 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1711 = $1710 & 1; | |
| $1712 = $1711 << 24 >> 24 == 0; | |
| if ($1712) { | |
| $1717 = $tmp$i255 + 1 | 0; | |
| $1718 = $1710 & 255; | |
| $1719 = $1718 >>> 1; | |
| $1720 = $1717; | |
| $1721 = $1719; | |
| } else { | |
| $1713 = $tmp$i255 + 8 | 0; | |
| $1714 = (tempInt = SAFE_HEAP_LOAD($1713 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1715 = $tmp$i255 + 4 | 0; | |
| $1716 = (tempInt = SAFE_HEAP_LOAD($1715 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1720 = $1714; | |
| $1721 = $1716; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiii(3, $1709 | 0, $1720 | 0, $1721 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1722 = __THREW__; | |
| __THREW__ = 0; | |
| $1723 = $1722 & 1; | |
| if (!$1723) { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($tmp$i255), asyncState ? abort(-12) | 0 : 0; | |
| $$0$i261 = $1689; | |
| break; | |
| } | |
| } | |
| $1724 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1725 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($tmp$i255), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($1724 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } | |
| } else { | |
| $$0$i261 = $first; | |
| } | |
| } else { | |
| $$0$i261 = $first; | |
| } | |
| } else { | |
| $$0$i261 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$0$i261; | |
| break L1; | |
| break; | |
| } | |
| default: | |
| { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| } | |
| break; | |
| } | |
| case 113: | |
| { | |
| $1726 = $t$0 + 1 | 0; | |
| $1727 = (tempInt = SAFE_HEAP_LOAD($1726 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1728 = $1727 << 24 >> 24 == 117; | |
| if (!$1728) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1729 = $first + 2 | 0; | |
| $1730 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($1729, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1731 = ($1730 | 0) == ($1729 | 0); | |
| if ($1731) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1732 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($1730, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1733 = ($1732 | 0) == ($1730 | 0); | |
| if ($1733) { | |
| $1838 = $db + 4 | 0; | |
| $1839 = (tempInt = SAFE_HEAP_LOAD($1838 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1840 = $1839 + -24 | 0; | |
| $1842 = $1839; | |
| while (1) { | |
| $1841 = ($1842 | 0) == ($1840 | 0); | |
| if ($1841) { | |
| break; | |
| } | |
| $1843 = $1842 + -24 | 0; | |
| SAFE_HEAP_STORE($1838 | 0, $1843 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1843), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i165 = (tempInt = SAFE_HEAP_LOAD($1838 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1842 = $$pre$i165; | |
| } | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1734 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($1732, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1735 = ($1734 | 0) == ($1732 | 0); | |
| $1736 = $db + 4 | 0; | |
| $1737 = (tempInt = SAFE_HEAP_LOAD($1736 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($1735) { | |
| $1830 = $1737 + -24 | 0; | |
| $1832 = $1737; | |
| while (1) { | |
| $1831 = ($1832 | 0) == ($1830 | 0); | |
| if ($1831) { | |
| break; | |
| } | |
| $1833 = $1832 + -24 | 0; | |
| SAFE_HEAP_STORE($1736 | 0, $1833 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1833), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i161 = (tempInt = SAFE_HEAP_LOAD($1736 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1832 = $$pre$i161; | |
| } | |
| $1834 = $1737 + -48 | 0; | |
| $1836 = $1830; | |
| while (1) { | |
| $1835 = ($1836 | 0) == ($1834 | 0); | |
| if ($1835) { | |
| break; | |
| } | |
| $1837 = $1836 + -24 | 0; | |
| SAFE_HEAP_STORE($1736 | 0, $1837 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1837), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i163 = (tempInt = SAFE_HEAP_LOAD($1736 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1836 = $$pre$i163; | |
| } | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1738 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1739 = $1737; | |
| $1740 = $1738; | |
| $1741 = $1739 - $1740 | 0; | |
| $1742 = ($1741 | 0) / 24 & -1; | |
| $1743 = $1742 >>> 0 < 3; | |
| if ($1743) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1744 = $1737 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($op3, $1744), asyncState ? abort(-12) | 0 : 0; | |
| $1745 = (tempInt = SAFE_HEAP_LOAD($1736 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1746 = $1745 + -24 | 0; | |
| $1748 = $1745; | |
| while (1) { | |
| $1747 = ($1748 | 0) == ($1746 | 0); | |
| if ($1747) { | |
| break; | |
| } | |
| $1749 = $1748 + -24 | 0; | |
| SAFE_HEAP_STORE($1736 | 0, $1749 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1749), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i135 = (tempInt = SAFE_HEAP_LOAD($1736 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1748 = $$pre$i135; | |
| } | |
| $1750 = $1745 + -48 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $op27 | 0, $1750 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1751 = __THREW__; | |
| __THREW__ = 0; | |
| $1752 = $1751 & 1; | |
| if ($1752) { | |
| $1814 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1815 = tempRet0; | |
| $$22 = $1814; | |
| $$2231 = $1815; | |
| } else { | |
| $1753 = (tempInt = SAFE_HEAP_LOAD($1736 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1754 = $1753 + -24 | 0; | |
| $1756 = $1753; | |
| while (1) { | |
| $1755 = ($1756 | 0) == ($1754 | 0); | |
| if ($1755) { | |
| break; | |
| } | |
| $1757 = $1756 + -24 | 0; | |
| SAFE_HEAP_STORE($1736 | 0, $1757 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1757), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i137 = (tempInt = SAFE_HEAP_LOAD($1736 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1756 = $$pre$i137; | |
| } | |
| $1758 = $1753 + -48 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $op18 | 0, $1758 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1759 = __THREW__; | |
| __THREW__ = 0; | |
| $1760 = $1759 & 1; | |
| if ($1760) { | |
| $1816 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1817 = tempRet0; | |
| $$21 = $1816; | |
| $$2130 = $1817; | |
| } else { | |
| $1761 = (tempInt = SAFE_HEAP_LOAD($1736 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1762 = $1761 + -24 | 0; | |
| __THREW__ = 0; | |
| invoke_viii(19, $136 | 0, 2768 | 0, $op18 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1763 = __THREW__; | |
| __THREW__ = 0; | |
| $1764 = $1763 & 1; | |
| if ($1764) { | |
| $1818 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1819 = tempRet0; | |
| $$20 = $1818; | |
| $$2029 = $1819; | |
| } else { | |
| __THREW__ = 0; | |
| $1765 = (tempInt = invoke_iii(5, $136 | 0, 3168 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1766 = __THREW__; | |
| __THREW__ = 0; | |
| $1767 = $1766 & 1; | |
| if ($1767) { | |
| $1820 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1821 = tempRet0; | |
| $$19 = $1820; | |
| $$1928 = $1821; | |
| } else { | |
| SAFE_HEAP_STORE($135 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1765 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($135 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1765 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($135 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1765 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i139 = 0; | |
| while (1) { | |
| $exitcond$i$i$i140 = ($__i$0$i$i$i139 | 0) == 3; | |
| if ($exitcond$i$i$i140) { | |
| break; | |
| } | |
| $1768 = $1765 + ($__i$0$i$i$i139 << 2) | 0; | |
| SAFE_HEAP_STORE($1768 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1769 = $__i$0$i$i$i139 + 1 | 0; | |
| $__i$0$i$i$i139 = $1769; | |
| } | |
| $1770 = (tempInt = SAFE_HEAP_LOAD($op27 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1771 = $1770 & 1; | |
| $1772 = $1771 << 24 >> 24 == 0; | |
| if ($1772) { | |
| $1777 = $op27 + 1 | 0; | |
| $1778 = $1770 & 255; | |
| $1779 = $1778 >>> 1; | |
| $1780 = $1777; | |
| $1781 = $1779; | |
| } else { | |
| $1773 = $op27 + 8 | 0; | |
| $1774 = (tempInt = SAFE_HEAP_LOAD($1773 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1775 = $op27 + 4 | 0; | |
| $1776 = (tempInt = SAFE_HEAP_LOAD($1775 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1780 = $1774; | |
| $1781 = $1776; | |
| } | |
| __THREW__ = 0; | |
| $1782 = (tempInt = invoke_iiii(3, $135 | 0, $1780 | 0, $1781 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1783 = __THREW__; | |
| __THREW__ = 0; | |
| $1784 = $1783 & 1; | |
| if ($1784) { | |
| $1822 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1823 = tempRet0; | |
| $$18 = $1822; | |
| $$1827 = $1823; | |
| } else { | |
| SAFE_HEAP_STORE($134 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1782 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($134 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1782 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($134 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1782 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i144 = 0; | |
| while (1) { | |
| $exitcond$i$i$i145 = ($__i$0$i$i$i144 | 0) == 3; | |
| if ($exitcond$i$i$i145) { | |
| break; | |
| } | |
| $1785 = $1782 + ($__i$0$i$i$i144 << 2) | 0; | |
| SAFE_HEAP_STORE($1785 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1786 = $__i$0$i$i$i144 + 1 | 0; | |
| $__i$0$i$i$i144 = $1786; | |
| } | |
| __THREW__ = 0; | |
| $1787 = (tempInt = invoke_iii(5, $134 | 0, 3176 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1788 = __THREW__; | |
| __THREW__ = 0; | |
| $1789 = $1788 & 1; | |
| if ($1789) { | |
| $1824 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1825 = tempRet0; | |
| $$17 = $1824; | |
| $$1726 = $1825; | |
| } else { | |
| SAFE_HEAP_STORE($133 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1787 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($133 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1787 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($133 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1787 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i148 = 0; | |
| while (1) { | |
| $exitcond$i$i$i149 = ($__i$0$i$i$i148 | 0) == 3; | |
| if ($exitcond$i$i$i149) { | |
| break; | |
| } | |
| $1790 = $1787 + ($__i$0$i$i$i148 << 2) | 0; | |
| SAFE_HEAP_STORE($1790 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1791 = $__i$0$i$i$i148 + 1 | 0; | |
| $__i$0$i$i$i148 = $1791; | |
| } | |
| $1792 = (tempInt = SAFE_HEAP_LOAD($op3 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1793 = $1792 & 1; | |
| $1794 = $1793 << 24 >> 24 == 0; | |
| if ($1794) { | |
| $1799 = $op3 + 1 | 0; | |
| $1800 = $1792 & 255; | |
| $1801 = $1800 >>> 1; | |
| $1802 = $1799; | |
| $1803 = $1801; | |
| } else { | |
| $1795 = $op3 + 8 | 0; | |
| $1796 = (tempInt = SAFE_HEAP_LOAD($1795 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1797 = $op3 + 4 | 0; | |
| $1798 = (tempInt = SAFE_HEAP_LOAD($1797 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1802 = $1796; | |
| $1803 = $1798; | |
| } | |
| __THREW__ = 0; | |
| $1804 = (tempInt = invoke_iiii(3, $133 | 0, $1802 | 0, $1803 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1805 = __THREW__; | |
| __THREW__ = 0; | |
| $1806 = $1805 & 1; | |
| do { | |
| if ($1806) { | |
| $1826 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1827 = tempRet0; | |
| $$16 = $1826; | |
| $$1625 = $1827; | |
| } else { | |
| SAFE_HEAP_STORE($132 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1804 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($132 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1804 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($132 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1804 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i153 = 0; | |
| while (1) { | |
| $exitcond$i$i$i154 = ($__i$0$i$i$i153 | 0) == 3; | |
| if ($exitcond$i$i$i154) { | |
| break; | |
| } | |
| $1807 = $1804 + ($__i$0$i$i$i153 << 2) | 0; | |
| SAFE_HEAP_STORE($1807 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1808 = $__i$0$i$i$i153 + 1 | 0; | |
| $__i$0$i$i$i153 = $1808; | |
| } | |
| __THREW__ = 0; | |
| $1809 = (tempInt = invoke_iii(5, $132 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1810 = __THREW__; | |
| __THREW__ = 0; | |
| $1811 = $1810 & 1; | |
| if ($1811) { | |
| $1828 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1829 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($132), asyncState ? abort(-12) | 0 : 0; | |
| $$16 = $1828; | |
| $$1625 = $1829; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($131 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1809 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($131 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1809 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($131 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1809 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i157 = 0; | |
| while (1) { | |
| $exitcond$i$i$i158 = ($__i$0$i$i$i157 | 0) == 3; | |
| if ($exitcond$i$i$i158) { | |
| break; | |
| } | |
| $1812 = $1809 + ($__i$0$i$i$i157 << 2) | 0; | |
| SAFE_HEAP_STORE($1812 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1813 = $__i$0$i$i$i157 + 1 | 0; | |
| $__i$0$i$i$i157 = $1813; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($130, $131), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($1762, $130), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($130), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($131), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($132), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($133), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($134), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($135), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($136), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($op18), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($op27), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($op3), asyncState ? abort(-12) | 0 : 0; | |
| $$0 = $1734; | |
| break L1; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($133), asyncState ? abort(-12) | 0 : 0; | |
| $$17 = $$16; | |
| $$1726 = $$1625; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($134), asyncState ? abort(-12) | 0 : 0; | |
| $$18 = $$17; | |
| $$1827 = $$1726; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($135), asyncState ? abort(-12) | 0 : 0; | |
| $$19 = $$18; | |
| $$1928 = $$1827; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($136), asyncState ? abort(-12) | 0 : 0; | |
| $$20 = $$19; | |
| $$2029 = $$1928; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($op18), asyncState ? abort(-12) | 0 : 0; | |
| $$21 = $$20; | |
| $$2130 = $$2029; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($op27), asyncState ? abort(-12) | 0 : 0; | |
| $$22 = $$21; | |
| $$2231 = $$2130; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($op3), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $$22; | |
| $$2332 = $$2231; | |
| break; | |
| } | |
| case 114: | |
| { | |
| $1844 = $t$0 + 1 | 0; | |
| $1845 = (tempInt = SAFE_HEAP_LOAD($1844 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1846 = $1845 << 24 >> 24; | |
| switch ($1846 | 0) { | |
| case 99: | |
| { | |
| $1847 = ($144 | 0) > 2; | |
| L804 : do { | |
| if ($1847) { | |
| $1848 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1849 = $1848 << 24 >> 24 == 114; | |
| if ($1849) { | |
| $1850 = $first + 1 | 0; | |
| $1851 = (tempInt = SAFE_HEAP_LOAD($1850 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1852 = $1851 << 24 >> 24 == 99; | |
| if ($1852) { | |
| $1853 = $first + 2 | 0; | |
| $1854 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($1853, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1855 = ($1854 | 0) == ($1853 | 0); | |
| if ($1855) { | |
| $$06$i254 = $first; | |
| } else { | |
| $1856 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($1854, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1857 = ($1856 | 0) == ($1854 | 0); | |
| if ($1857) { | |
| $$06$i254 = $first; | |
| } else { | |
| $1858 = $db + 4 | 0; | |
| $1859 = (tempInt = SAFE_HEAP_LOAD($1858 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1860 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1861 = $1859; | |
| $1862 = $1860; | |
| $1863 = $1861 - $1862 | 0; | |
| $1864 = ($1863 | 0) / 24 & -1; | |
| $1865 = $1864 >>> 0 < 2; | |
| if ($1865) { | |
| $$06$i254 = $first; | |
| } else { | |
| $1866 = $1859 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($expr$i226, $1866), asyncState ? abort(-12) | 0 : 0; | |
| $1867 = (tempInt = SAFE_HEAP_LOAD($1858 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1868 = $1867 + -24 | 0; | |
| $1870 = $1867; | |
| while (1) { | |
| $1869 = ($1870 | 0) == ($1868 | 0); | |
| if ($1869) { | |
| break; | |
| } | |
| $1871 = $1870 + -24 | 0; | |
| SAFE_HEAP_STORE($1858 | 0, $1871 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1871), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i227 = (tempInt = SAFE_HEAP_LOAD($1858 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1870 = $$pre$i$i227; | |
| } | |
| $1872 = $1867 + -48 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $43 | 0, $1872 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1873 = __THREW__; | |
| __THREW__ = 0; | |
| $1874 = $1873 & 1; | |
| if ($1874) { | |
| $1907 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1908 = tempRet0; | |
| $$4$i253 = $1908; | |
| $$45$i252 = $1907; | |
| } else { | |
| __THREW__ = 0; | |
| $1875 = (tempInt = invoke_iiii(4, $43 | 0, 0, 3304 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1876 = __THREW__; | |
| __THREW__ = 0; | |
| $1877 = $1876 & 1; | |
| if ($1877) { | |
| $1909 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1910 = tempRet0; | |
| $$3$i251 = $1910; | |
| $$34$i250 = $1909; | |
| } else { | |
| SAFE_HEAP_STORE($42 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1875 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($42 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1875 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($42 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1875 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i230 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i231 = ($__i$0$i$i$i$i230 | 0) == 3; | |
| if ($exitcond$i$i$i$i231) { | |
| break; | |
| } | |
| $1878 = $1875 + ($__i$0$i$i$i$i230 << 2) | 0; | |
| SAFE_HEAP_STORE($1878 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1879 = $__i$0$i$i$i$i230 + 1 | 0; | |
| $__i$0$i$i$i$i230 = $1879; | |
| } | |
| __THREW__ = 0; | |
| $1880 = (tempInt = invoke_iii(5, $42 | 0, 3296 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1881 = __THREW__; | |
| __THREW__ = 0; | |
| $1882 = $1881 & 1; | |
| if ($1882) { | |
| $1911 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1912 = tempRet0; | |
| $$2$i249 = $1912; | |
| $$23$i248 = $1911; | |
| } else { | |
| SAFE_HEAP_STORE($41 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1880 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($41 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1880 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($41 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1880 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i8$i234 = 0; | |
| while (1) { | |
| $exitcond$i$i$i9$i235 = ($__i$0$i$i$i8$i234 | 0) == 3; | |
| if ($exitcond$i$i$i9$i235) { | |
| break; | |
| } | |
| $1883 = $1880 + ($__i$0$i$i$i8$i234 << 2) | 0; | |
| SAFE_HEAP_STORE($1883 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1884 = $__i$0$i$i$i8$i234 + 1 | 0; | |
| $__i$0$i$i$i8$i234 = $1884; | |
| } | |
| $1885 = (tempInt = SAFE_HEAP_LOAD($expr$i226 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1886 = $1885 & 1; | |
| $1887 = $1886 << 24 >> 24 == 0; | |
| if ($1887) { | |
| $1892 = $expr$i226 + 1 | 0; | |
| $1893 = $1885 & 255; | |
| $1894 = $1893 >>> 1; | |
| $1895 = $1892; | |
| $1896 = $1894; | |
| } else { | |
| $1888 = $expr$i226 + 8 | 0; | |
| $1889 = (tempInt = SAFE_HEAP_LOAD($1888 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1890 = $expr$i226 + 4 | 0; | |
| $1891 = (tempInt = SAFE_HEAP_LOAD($1890 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1895 = $1889; | |
| $1896 = $1891; | |
| } | |
| __THREW__ = 0; | |
| $1897 = (tempInt = invoke_iiii(3, $41 | 0, $1895 | 0, $1896 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1898 = __THREW__; | |
| __THREW__ = 0; | |
| $1899 = $1898 & 1; | |
| do { | |
| if ($1899) { | |
| $1913 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1914 = tempRet0; | |
| $$1$i247 = $1914; | |
| $$12$i246 = $1913; | |
| } else { | |
| SAFE_HEAP_STORE($40 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1897 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($40 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1897 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($40 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1897 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i11$i239 = 0; | |
| while (1) { | |
| $exitcond$i$i$i12$i240 = ($__i$0$i$i$i11$i239 | 0) == 3; | |
| if ($exitcond$i$i$i12$i240) { | |
| break; | |
| } | |
| $1900 = $1897 + ($__i$0$i$i$i11$i239 << 2) | 0; | |
| SAFE_HEAP_STORE($1900 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1901 = $__i$0$i$i$i11$i239 + 1 | 0; | |
| $__i$0$i$i$i11$i239 = $1901; | |
| } | |
| __THREW__ = 0; | |
| $1902 = (tempInt = invoke_iii(5, $40 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1903 = __THREW__; | |
| __THREW__ = 0; | |
| $1904 = $1903 & 1; | |
| if ($1904) { | |
| $1915 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1916 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($40), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i247 = $1916; | |
| $$12$i246 = $1915; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($39 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1902 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($39 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1902 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($39 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1902 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i14$i243 = 0; | |
| while (1) { | |
| $exitcond$i$i$i15$i244 = ($__i$0$i$i$i14$i243 | 0) == 3; | |
| if ($exitcond$i$i$i15$i244) { | |
| break; | |
| } | |
| $1905 = $1902 + ($__i$0$i$i$i14$i243 << 2) | 0; | |
| SAFE_HEAP_STORE($1905 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1906 = $__i$0$i$i$i14$i243 + 1 | 0; | |
| $__i$0$i$i$i14$i243 = $1906; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($38, $39), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($1872, $38), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($38), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($39), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($40), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($41), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($42), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($43), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($expr$i226), asyncState ? abort(-12) | 0 : 0; | |
| $$06$i254 = $1856; | |
| break L804; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($41), asyncState ? abort(-12) | 0 : 0; | |
| $$2$i249 = $$1$i247; | |
| $$23$i248 = $$12$i246; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($42), asyncState ? abort(-12) | 0 : 0; | |
| $$3$i251 = $$2$i249; | |
| $$34$i250 = $$23$i248; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($43), asyncState ? abort(-12) | 0 : 0; | |
| $$4$i253 = $$3$i251; | |
| $$45$i252 = $$34$i250; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($expr$i226), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$45$i252 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } | |
| } else { | |
| $$06$i254 = $first; | |
| } | |
| } else { | |
| $$06$i254 = $first; | |
| } | |
| } else { | |
| $$06$i254 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$06$i254; | |
| break L1; | |
| break; | |
| } | |
| case 109: | |
| { | |
| $1917 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($137, 3184, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1918 = (tempInt = invoke_iiiii(21, $1917 | 0, $last | 0, $137 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1919 = __THREW__; | |
| __THREW__ = 0; | |
| $1920 = $1919 & 1; | |
| if ($1920) { | |
| $1922 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1923 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($137), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1922; | |
| $$2332 = $1923; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($137), asyncState ? abort(-12) | 0 : 0; | |
| $1921 = ($1918 | 0) == ($1917 | 0); | |
| $first$68 = $1921 ? $first : $1918; | |
| $$0 = $first$68; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 77: | |
| { | |
| $1924 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($138, 3192, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1925 = (tempInt = invoke_iiiii(21, $1924 | 0, $last | 0, $138 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1926 = __THREW__; | |
| __THREW__ = 0; | |
| $1927 = $1926 & 1; | |
| if ($1927) { | |
| $1929 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1930 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($138), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1929; | |
| $$2332 = $1930; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($138), asyncState ? abort(-12) | 0 : 0; | |
| $1928 = ($1925 | 0) == ($1924 | 0); | |
| $first$69 = $1928 ? $first : $1925; | |
| $$0 = $first$69; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 115: | |
| { | |
| $1931 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($139, 3200, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1932 = (tempInt = invoke_iiiii(21, $1931 | 0, $last | 0, $139 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1933 = __THREW__; | |
| __THREW__ = 0; | |
| $1934 = $1933 & 1; | |
| if ($1934) { | |
| $1936 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1937 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($139), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1936; | |
| $$2332 = $1937; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($139), asyncState ? abort(-12) | 0 : 0; | |
| $1935 = ($1932 | 0) == ($1931 | 0); | |
| $first$70 = $1935 ? $first : $1932; | |
| $$0 = $first$70; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 83: | |
| { | |
| $1938 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($140, 3208, 3), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $1939 = (tempInt = invoke_iiiii(21, $1938 | 0, $last | 0, $140 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1940 = __THREW__; | |
| __THREW__ = 0; | |
| $1941 = $1940 & 1; | |
| if ($1941) { | |
| $1943 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1944 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($140), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $1943; | |
| $$2332 = $1944; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($140), asyncState ? abort(-12) | 0 : 0; | |
| $1942 = ($1939 | 0) == ($1938 | 0); | |
| $first$71 = $1942 ? $first : $1939; | |
| STACKTOP = sp; | |
| return $first$71 | 0; | |
| } | |
| break; | |
| } | |
| default: | |
| { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| } | |
| break; | |
| } | |
| case 115: | |
| { | |
| $1945 = $t$0 + 1 | 0; | |
| $1946 = (tempInt = SAFE_HEAP_LOAD($1945 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1947 = $1946 << 24 >> 24; | |
| switch ($1947 | 0) { | |
| case 99: | |
| { | |
| $1948 = ($144 | 0) > 2; | |
| L874 : do { | |
| if ($1948) { | |
| $1949 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1950 = $1949 << 24 >> 24 == 115; | |
| if ($1950) { | |
| $1951 = $first + 1 | 0; | |
| $1952 = (tempInt = SAFE_HEAP_LOAD($1951 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1953 = $1952 << 24 >> 24 == 99; | |
| if ($1953) { | |
| $1954 = $first + 2 | 0; | |
| $1955 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($1954, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1956 = ($1955 | 0) == ($1954 | 0); | |
| if ($1956) { | |
| $$06$i = $first; | |
| } else { | |
| $1957 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($1955, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1958 = ($1957 | 0) == ($1955 | 0); | |
| if ($1958) { | |
| $$06$i = $first; | |
| } else { | |
| $1959 = $db + 4 | 0; | |
| $1960 = (tempInt = SAFE_HEAP_LOAD($1959 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1961 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1962 = $1960; | |
| $1963 = $1961; | |
| $1964 = $1962 - $1963 | 0; | |
| $1965 = ($1964 | 0) / 24 & -1; | |
| $1966 = $1965 >>> 0 < 2; | |
| if ($1966) { | |
| $$06$i = $first; | |
| } else { | |
| $1967 = $1960 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($expr$i, $1967), asyncState ? abort(-12) | 0 : 0; | |
| $1968 = (tempInt = SAFE_HEAP_LOAD($1959 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1969 = $1968 + -24 | 0; | |
| $1971 = $1968; | |
| while (1) { | |
| $1970 = ($1971 | 0) == ($1969 | 0); | |
| if ($1970) { | |
| break; | |
| } | |
| $1972 = $1971 + -24 | 0; | |
| SAFE_HEAP_STORE($1959 | 0, $1972 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1972), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i216 = (tempInt = SAFE_HEAP_LOAD($1959 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1971 = $$pre$i$i216; | |
| } | |
| $1973 = $1968 + -48 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $49 | 0, $1973 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1974 = __THREW__; | |
| __THREW__ = 0; | |
| $1975 = $1974 & 1; | |
| if ($1975) { | |
| $2008 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2009 = tempRet0; | |
| $$4$i = $2009; | |
| $$45$i = $2008; | |
| } else { | |
| __THREW__ = 0; | |
| $1976 = (tempInt = invoke_iiii(4, $49 | 0, 0, 3280 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1977 = __THREW__; | |
| __THREW__ = 0; | |
| $1978 = $1977 & 1; | |
| if ($1978) { | |
| $2010 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2011 = tempRet0; | |
| $$3$i = $2011; | |
| $$34$i = $2010; | |
| } else { | |
| SAFE_HEAP_STORE($48 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1976 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($48 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1976 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($48 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1976 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i219 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i220 = ($__i$0$i$i$i$i219 | 0) == 3; | |
| if ($exitcond$i$i$i$i220) { | |
| break; | |
| } | |
| $1979 = $1976 + ($__i$0$i$i$i$i219 << 2) | 0; | |
| SAFE_HEAP_STORE($1979 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1980 = $__i$0$i$i$i$i219 + 1 | 0; | |
| $__i$0$i$i$i$i219 = $1980; | |
| } | |
| __THREW__ = 0; | |
| $1981 = (tempInt = invoke_iii(5, $48 | 0, 3296 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1982 = __THREW__; | |
| __THREW__ = 0; | |
| $1983 = $1982 & 1; | |
| if ($1983) { | |
| $2012 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2013 = tempRet0; | |
| $$2$i = $2013; | |
| $$23$i = $2012; | |
| } else { | |
| SAFE_HEAP_STORE($47 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1981 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($47 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1981 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($47 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1981 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i8$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i9$i = ($__i$0$i$i$i8$i | 0) == 3; | |
| if ($exitcond$i$i$i9$i) { | |
| break; | |
| } | |
| $1984 = $1981 + ($__i$0$i$i$i8$i << 2) | 0; | |
| SAFE_HEAP_STORE($1984 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1985 = $__i$0$i$i$i8$i + 1 | 0; | |
| $__i$0$i$i$i8$i = $1985; | |
| } | |
| $1986 = (tempInt = SAFE_HEAP_LOAD($expr$i >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1987 = $1986 & 1; | |
| $1988 = $1987 << 24 >> 24 == 0; | |
| if ($1988) { | |
| $1993 = $expr$i + 1 | 0; | |
| $1994 = $1986 & 255; | |
| $1995 = $1994 >>> 1; | |
| $1996 = $1993; | |
| $1997 = $1995; | |
| } else { | |
| $1989 = $expr$i + 8 | 0; | |
| $1990 = (tempInt = SAFE_HEAP_LOAD($1989 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1991 = $expr$i + 4 | 0; | |
| $1992 = (tempInt = SAFE_HEAP_LOAD($1991 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1996 = $1990; | |
| $1997 = $1992; | |
| } | |
| __THREW__ = 0; | |
| $1998 = (tempInt = invoke_iiii(3, $47 | 0, $1996 | 0, $1997 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1999 = __THREW__; | |
| __THREW__ = 0; | |
| $2000 = $1999 & 1; | |
| do { | |
| if ($2000) { | |
| $2014 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2015 = tempRet0; | |
| $$1$i225 = $2015; | |
| $$12$i224 = $2014; | |
| } else { | |
| SAFE_HEAP_STORE($46 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1998 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($46 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1998 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($46 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1998 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i11$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i12$i = ($__i$0$i$i$i11$i | 0) == 3; | |
| if ($exitcond$i$i$i12$i) { | |
| break; | |
| } | |
| $2001 = $1998 + ($__i$0$i$i$i11$i << 2) | 0; | |
| SAFE_HEAP_STORE($2001 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2002 = $__i$0$i$i$i11$i + 1 | 0; | |
| $__i$0$i$i$i11$i = $2002; | |
| } | |
| __THREW__ = 0; | |
| $2003 = (tempInt = invoke_iii(5, $46 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2004 = __THREW__; | |
| __THREW__ = 0; | |
| $2005 = $2004 & 1; | |
| if ($2005) { | |
| $2016 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2017 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($46), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i225 = $2017; | |
| $$12$i224 = $2016; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($45 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2003 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($45 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2003 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($45 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2003 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i14$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i15$i = ($__i$0$i$i$i14$i | 0) == 3; | |
| if ($exitcond$i$i$i15$i) { | |
| break; | |
| } | |
| $2006 = $2003 + ($__i$0$i$i$i14$i << 2) | 0; | |
| SAFE_HEAP_STORE($2006 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2007 = $__i$0$i$i$i14$i + 1 | 0; | |
| $__i$0$i$i$i14$i = $2007; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($44, $45), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($1973, $44), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($44), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($45), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($46), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($47), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($48), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($49), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($expr$i), asyncState ? abort(-12) | 0 : 0; | |
| $$06$i = $1957; | |
| break L874; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($47), asyncState ? abort(-12) | 0 : 0; | |
| $$2$i = $$1$i225; | |
| $$23$i = $$12$i224; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($48), asyncState ? abort(-12) | 0 : 0; | |
| $$3$i = $$2$i; | |
| $$34$i = $$23$i; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($49), asyncState ? abort(-12) | 0 : 0; | |
| $$4$i = $$3$i; | |
| $$45$i = $$34$i; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($expr$i), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$45$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } | |
| } else { | |
| $$06$i = $first; | |
| } | |
| } else { | |
| $$06$i = $first; | |
| } | |
| } else { | |
| $$06$i = $first; | |
| } | |
| } while (0); | |
| $$0 = $$06$i; | |
| break L1; | |
| break; | |
| } | |
| case 112: | |
| { | |
| $2018 = ($144 | 0) > 2; | |
| if (!$2018) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $2019 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2020 = $2019 << 24 >> 24 == 115; | |
| if (!$2020) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $2021 = $first + 1 | 0; | |
| $2022 = (tempInt = SAFE_HEAP_LOAD($2021 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2023 = $2022 << 24 >> 24 == 112; | |
| if (!$2023) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $2024 = $first + 2 | 0; | |
| $2025 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($2024, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2026 = ($2025 | 0) == ($2024 | 0); | |
| $first$$i = $2026 ? $first : $2025; | |
| $$0 = $first$$i; | |
| break L1; | |
| break; | |
| } | |
| case 114: | |
| { | |
| $2027 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_121parse_unresolved_nameINS0_2DbEEEPKcS4_S4_RT_($first, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $$0 = $2027; | |
| break L1; | |
| break; | |
| } | |
| case 116: | |
| { | |
| $2028 = ($144 | 0) > 2; | |
| L931 : do { | |
| if ($2028) { | |
| $2029 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2030 = $2029 << 24 >> 24 == 115; | |
| if ($2030) { | |
| $2031 = $first + 1 | 0; | |
| $2032 = (tempInt = SAFE_HEAP_LOAD($2031 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2033 = $2032 << 24 >> 24 == 116; | |
| if ($2033) { | |
| $2034 = $first + 2 | 0; | |
| $2035 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($2034, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2036 = ($2035 | 0) == ($2034 | 0); | |
| if ($2036) { | |
| $$03$i215 = $first; | |
| } else { | |
| $2037 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2038 = $db + 4 | 0; | |
| $2039 = (tempInt = SAFE_HEAP_LOAD($2038 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2040 = ($2037 | 0) == ($2039 | 0); | |
| if ($2040) { | |
| $$03$i215 = $first; | |
| } else { | |
| $2041 = $2039 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($53, $2041), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $2042 = (tempInt = invoke_iiii(4, $53 | 0, 0, 3264 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2043 = __THREW__; | |
| __THREW__ = 0; | |
| $2044 = $2043 & 1; | |
| do { | |
| if ($2044) { | |
| $2052 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2053 = tempRet0; | |
| $$1$i214 = $2053; | |
| $$12$i213 = $2052; | |
| } else { | |
| SAFE_HEAP_STORE($52 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2042 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($52 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2042 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($52 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2042 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i206 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i207 = ($__i$0$i$i$i$i206 | 0) == 3; | |
| if ($exitcond$i$i$i$i207) { | |
| break; | |
| } | |
| $2045 = $2042 + ($__i$0$i$i$i$i206 << 2) | 0; | |
| SAFE_HEAP_STORE($2045 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2046 = $__i$0$i$i$i$i206 + 1 | 0; | |
| $__i$0$i$i$i$i206 = $2046; | |
| } | |
| __THREW__ = 0; | |
| $2047 = (tempInt = invoke_iii(5, $52 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2048 = __THREW__; | |
| __THREW__ = 0; | |
| $2049 = $2048 & 1; | |
| if ($2049) { | |
| $2054 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2055 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($52), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i214 = $2055; | |
| $$12$i213 = $2054; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($51 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2047 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($51 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2047 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($51 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2047 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i5$i210 = 0; | |
| while (1) { | |
| $exitcond$i$i$i6$i211 = ($__i$0$i$i$i5$i210 | 0) == 3; | |
| if ($exitcond$i$i$i6$i211) { | |
| break; | |
| } | |
| $2050 = $2047 + ($__i$0$i$i$i5$i210 << 2) | 0; | |
| SAFE_HEAP_STORE($2050 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2051 = $__i$0$i$i$i5$i210 + 1 | 0; | |
| $__i$0$i$i$i5$i210 = $2051; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($50, $51), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($2041, $50), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($50), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($51), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($52), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($53), asyncState ? abort(-12) | 0 : 0; | |
| $$03$i215 = $2035; | |
| break L931; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($53), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$12$i213 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } else { | |
| $$03$i215 = $first; | |
| } | |
| } else { | |
| $$03$i215 = $first; | |
| } | |
| } else { | |
| $$03$i215 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$03$i215; | |
| break L1; | |
| break; | |
| } | |
| case 122: | |
| { | |
| $2056 = ($144 | 0) > 2; | |
| L954 : do { | |
| if ($2056) { | |
| $2057 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2058 = $2057 << 24 >> 24 == 115; | |
| if ($2058) { | |
| $2059 = $first + 1 | 0; | |
| $2060 = (tempInt = SAFE_HEAP_LOAD($2059 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2061 = $2060 << 24 >> 24 == 122; | |
| if ($2061) { | |
| $2062 = $first + 2 | 0; | |
| $2063 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($2062, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2064 = ($2063 | 0) == ($2062 | 0); | |
| if ($2064) { | |
| $$03$i204 = $first; | |
| } else { | |
| $2065 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2066 = $db + 4 | 0; | |
| $2067 = (tempInt = SAFE_HEAP_LOAD($2066 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2068 = ($2065 | 0) == ($2067 | 0); | |
| if ($2068) { | |
| $$03$i204 = $first; | |
| } else { | |
| $2069 = $2067 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($57, $2069), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $2070 = (tempInt = invoke_iiii(4, $57 | 0, 0, 3264 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2071 = __THREW__; | |
| __THREW__ = 0; | |
| $2072 = $2071 & 1; | |
| do { | |
| if ($2072) { | |
| $2080 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2081 = tempRet0; | |
| $$1$i203 = $2081; | |
| $$12$i202 = $2080; | |
| } else { | |
| SAFE_HEAP_STORE($56 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2070 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($56 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2070 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($56 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2070 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i195 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i196 = ($__i$0$i$i$i$i195 | 0) == 3; | |
| if ($exitcond$i$i$i$i196) { | |
| break; | |
| } | |
| $2073 = $2070 + ($__i$0$i$i$i$i195 << 2) | 0; | |
| SAFE_HEAP_STORE($2073 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2074 = $__i$0$i$i$i$i195 + 1 | 0; | |
| $__i$0$i$i$i$i195 = $2074; | |
| } | |
| __THREW__ = 0; | |
| $2075 = (tempInt = invoke_iii(5, $56 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2076 = __THREW__; | |
| __THREW__ = 0; | |
| $2077 = $2076 & 1; | |
| if ($2077) { | |
| $2082 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2083 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($56), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i203 = $2083; | |
| $$12$i202 = $2082; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($55 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2075 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($55 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2075 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($55 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2075 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i5$i199 = 0; | |
| while (1) { | |
| $exitcond$i$i$i6$i200 = ($__i$0$i$i$i5$i199 | 0) == 3; | |
| if ($exitcond$i$i$i6$i200) { | |
| break; | |
| } | |
| $2078 = $2075 + ($__i$0$i$i$i5$i199 << 2) | 0; | |
| SAFE_HEAP_STORE($2078 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2079 = $__i$0$i$i$i5$i199 + 1 | 0; | |
| $__i$0$i$i$i5$i199 = $2079; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($54, $55), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($2069, $54), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($54), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($55), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($56), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($57), asyncState ? abort(-12) | 0 : 0; | |
| $$03$i204 = $2063; | |
| break L954; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($57), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$12$i202 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } else { | |
| $$03$i204 = $first; | |
| } | |
| } else { | |
| $$03$i204 = $first; | |
| } | |
| } else { | |
| $$03$i204 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$03$i204; | |
| break L1; | |
| break; | |
| } | |
| case 90: | |
| { | |
| $2084 = $t$0; | |
| $2085 = $142 - $2084 | 0; | |
| $2086 = ($2085 | 0) > 2; | |
| if (!$2086) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $2087 = $t$0 + 2 | 0; | |
| $2088 = (tempInt = SAFE_HEAP_LOAD($2087 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2089 = $2088 << 24 >> 24; | |
| if (($2089 | 0) == 102) { | |
| $2209 = ($144 | 0) > 2; | |
| L980 : do { | |
| if ($2209) { | |
| $2210 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2211 = $2210 << 24 >> 24 == 115; | |
| if ($2211) { | |
| $2212 = $first + 1 | 0; | |
| $2213 = (tempInt = SAFE_HEAP_LOAD($2212 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2214 = $2213 << 24 >> 24 == 90; | |
| if ($2214) { | |
| $2215 = $first + 2 | 0; | |
| $2216 = (tempInt = SAFE_HEAP_LOAD($2215 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2217 = $2216 << 24 >> 24 == 102; | |
| if ($2217) { | |
| $2218 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_120parse_function_paramINS0_2DbEEEPKcS4_S4_RT_($2215, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2219 = ($2218 | 0) == ($2215 | 0); | |
| if ($2219) { | |
| $$03$i177 = $first; | |
| } else { | |
| $2220 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2221 = $db + 4 | 0; | |
| $2222 = (tempInt = SAFE_HEAP_LOAD($2221 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2223 = ($2220 | 0) == ($2222 | 0); | |
| if ($2223) { | |
| $$03$i177 = $first; | |
| } else { | |
| $2224 = $2222 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($68, $2224), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $2225 = (tempInt = invoke_iiii(4, $68 | 0, 0, 3240 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2226 = __THREW__; | |
| __THREW__ = 0; | |
| $2227 = $2226 & 1; | |
| do { | |
| if ($2227) { | |
| $2235 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2236 = tempRet0; | |
| $$1$i176 = $2236; | |
| $$12$i175 = $2235; | |
| } else { | |
| SAFE_HEAP_STORE($67 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2225 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($67 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2225 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($67 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2225 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i172 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i173 = ($__i$0$i$i$i$i172 | 0) == 3; | |
| if ($exitcond$i$i$i$i173) { | |
| break; | |
| } | |
| $2228 = $2225 + ($__i$0$i$i$i$i172 << 2) | 0; | |
| SAFE_HEAP_STORE($2228 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2229 = $__i$0$i$i$i$i172 + 1 | 0; | |
| $__i$0$i$i$i$i172 = $2229; | |
| } | |
| __THREW__ = 0; | |
| $2230 = (tempInt = invoke_iii(5, $67 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2231 = __THREW__; | |
| __THREW__ = 0; | |
| $2232 = $2231 & 1; | |
| if ($2232) { | |
| $2237 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2238 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($67), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i176 = $2238; | |
| $$12$i175 = $2237; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($66 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2230 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($66 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2230 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($66 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2230 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i5$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i6$i = ($__i$0$i$i$i5$i | 0) == 3; | |
| if ($exitcond$i$i$i6$i) { | |
| break; | |
| } | |
| $2233 = $2230 + ($__i$0$i$i$i5$i << 2) | 0; | |
| SAFE_HEAP_STORE($2233 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2234 = $__i$0$i$i$i5$i + 1 | 0; | |
| $__i$0$i$i$i5$i = $2234; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($65, $66), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($2224, $65), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($65), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($66), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($67), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($68), asyncState ? abort(-12) | 0 : 0; | |
| $$03$i177 = $2218; | |
| break L980; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($68), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$12$i175 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } else { | |
| $$03$i177 = $first; | |
| } | |
| } else { | |
| $$03$i177 = $first; | |
| } | |
| } else { | |
| $$03$i177 = $first; | |
| } | |
| } else { | |
| $$03$i177 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$03$i177; | |
| break L1; | |
| } else if (!(($2089 | 0) == 84)) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $2090 = ($144 | 0) > 2; | |
| L1004 : do { | |
| if ($2090) { | |
| $2091 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2092 = $2091 << 24 >> 24 == 115; | |
| if ($2092) { | |
| $2093 = $first + 1 | 0; | |
| $2094 = (tempInt = SAFE_HEAP_LOAD($2093 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2095 = $2094 << 24 >> 24 == 90; | |
| if ($2095) { | |
| $2096 = $first + 2 | 0; | |
| $2097 = (tempInt = SAFE_HEAP_LOAD($2096 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2098 = $2097 << 24 >> 24 == 84; | |
| if ($2098) { | |
| $2099 = $db + 4 | 0; | |
| $2100 = (tempInt = SAFE_HEAP_LOAD($2099 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2101 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2102 = $2100; | |
| $2103 = $2101; | |
| $2104 = $2102 - $2103 | 0; | |
| $2105 = ($2104 | 0) / 24 & -1; | |
| $2106 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_120parse_template_paramINS0_2DbEEEPKcS4_S4_RT_($2096, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2107 = (tempInt = SAFE_HEAP_LOAD($2099 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2108 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2109 = $2107; | |
| $2110 = $2108; | |
| $2111 = $2109 - $2110 | 0; | |
| $2112 = ($2111 | 0) / 24 & -1; | |
| $2113 = ($2106 | 0) == ($2096 | 0); | |
| if ($2113) { | |
| $$03$i = $first; | |
| } else { | |
| SAFE_HEAP_STORE($tmp$i >> 0 | 0, 20 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2114 = $tmp$i + 1 | 0; | |
| dest = $2114 + 0 | 0; | |
| src = 3240 + 0 | 0; | |
| stop = dest + 10 | 0; | |
| do { | |
| SAFE_HEAP_STORE(dest >> 0 | 0, (tempInt = SAFE_HEAP_LOAD(src >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| dest = dest + 1 | 0; | |
| src = src + 1 | 0; | |
| } while ((dest | 0) < (stop | 0)); | |
| $2115 = $tmp$i + 11 | 0; | |
| SAFE_HEAP_STORE($2115 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2116 = ($2105 | 0) == ($2112 | 0); | |
| do { | |
| if ($2116) { | |
| label = 1037; | |
| } else { | |
| $2117 = $2108 + ($2105 * 24 | 0) | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $69 | 0, $2117 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $2118 = __THREW__; | |
| __THREW__ = 0; | |
| $2119 = $2118 & 1; | |
| if ($2119) { | |
| label = 1030; | |
| } else { | |
| $2120 = (tempInt = SAFE_HEAP_LOAD($69 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2121 = $2120 & 1; | |
| $2122 = $2121 << 24 >> 24 == 0; | |
| if ($2122) { | |
| $2127 = $69 + 1 | 0; | |
| $2128 = $2120 & 255; | |
| $2129 = $2128 >>> 1; | |
| $2130 = $2127; | |
| $2131 = $2129; | |
| } else { | |
| $2123 = $69 + 8 | 0; | |
| $2124 = (tempInt = SAFE_HEAP_LOAD($2123 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2125 = $69 + 4 | 0; | |
| $2126 = (tempInt = SAFE_HEAP_LOAD($2125 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2130 = $2124; | |
| $2131 = $2126; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiii(3, $tmp$i | 0, $2130 | 0, $2131 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2132 = __THREW__; | |
| __THREW__ = 0; | |
| $2133 = $2132 & 1; | |
| if ($2133) { | |
| $2162 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2163 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($69), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i = $2163; | |
| $$12$i = $2162; | |
| break; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($69), asyncState ? abort(-12) | 0 : 0; | |
| $2134 = $70 + 1 | 0; | |
| $2135 = $70 + 8 | 0; | |
| $2136 = $70 + 4 | 0; | |
| $k$0$in$i = $2105; | |
| while (1) { | |
| $k$0$i = $k$0$in$i + 1 | 0; | |
| $2137 = ($k$0$i | 0) == ($2112 | 0); | |
| if ($2137) { | |
| label = 1036; | |
| break; | |
| } | |
| $2138 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2139 = $2138 + ($k$0$i * 24 | 0) | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $71 | 0, $2139 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $2140 = __THREW__; | |
| __THREW__ = 0; | |
| $2141 = $2140 & 1; | |
| if ($2141) { | |
| label = 1029; | |
| break; | |
| } | |
| __THREW__ = 0; | |
| $2142 = (tempInt = invoke_iiii(4, $71 | 0, 0, 3256 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2143 = __THREW__; | |
| __THREW__ = 0; | |
| $2144 = $2143 & 1; | |
| if ($2144) { | |
| label = 1033; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($70 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2142 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($70 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2142 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($70 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2142 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i167 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i168 = ($__i$0$i$i$i$i167 | 0) == 3; | |
| if ($exitcond$i$i$i$i168) { | |
| break; | |
| } | |
| $2145 = $2142 + ($__i$0$i$i$i$i167 << 2) | 0; | |
| SAFE_HEAP_STORE($2145 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2146 = $__i$0$i$i$i$i167 + 1 | 0; | |
| $__i$0$i$i$i$i167 = $2146; | |
| } | |
| $2147 = (tempInt = SAFE_HEAP_LOAD($70 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2148 = $2147 & 1; | |
| $2149 = $2148 << 24 >> 24 == 0; | |
| if ($2149) { | |
| $2152 = $2147 & 255; | |
| $2153 = $2152 >>> 1; | |
| $2154 = $2134; | |
| $2155 = $2153; | |
| } else { | |
| $2150 = (tempInt = SAFE_HEAP_LOAD($2135 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2151 = (tempInt = SAFE_HEAP_LOAD($2136 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2154 = $2150; | |
| $2155 = $2151; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiii(3, $tmp$i | 0, $2154 | 0, $2155 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2156 = __THREW__; | |
| __THREW__ = 0; | |
| $2157 = $2156 & 1; | |
| if ($2157) { | |
| label = 1034; | |
| break; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($70), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($71), asyncState ? abort(-12) | 0 : 0; | |
| $k$0$in$i = $k$0$i; | |
| } | |
| if ((label | 0) == 1029) { | |
| $2158 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2159 = tempRet0; | |
| $lpad$phi$i$index = $2158; | |
| $lpad$phi$i$index2 = $2159; | |
| label = 1031; | |
| break; | |
| } else if ((label | 0) == 1033) { | |
| $2164 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2165 = tempRet0; | |
| $$0$i = $2165; | |
| $$01$i = $2164; | |
| } else if ((label | 0) == 1034) { | |
| $2166 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2167 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($70), asyncState ? abort(-12) | 0 : 0; | |
| $$0$i = $2167; | |
| $$01$i = $2166; | |
| } else if ((label | 0) == 1036) { | |
| label = 1037; | |
| break; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($71), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i = $$0$i; | |
| $$12$i = $$01$i; | |
| } | |
| } | |
| } while (0); | |
| do { | |
| if ((label | 0) == 1037) { | |
| __THREW__ = 0; | |
| (tempInt = invoke_iii(5, $tmp$i | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2168 = __THREW__; | |
| __THREW__ = 0; | |
| $2169 = $2168 & 1; | |
| if ($2169) { | |
| label = 1030; | |
| } else { | |
| $k1$0$i = $2112; | |
| while (1) { | |
| $2170 = ($k1$0$i | 0) == ($2105 | 0); | |
| if ($2170) { | |
| break; | |
| } | |
| $2171 = (tempInt = SAFE_HEAP_LOAD($2099 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2172 = $2171 + -24 | 0; | |
| $2174 = $2171; | |
| while (1) { | |
| $2173 = ($2174 | 0) == ($2172 | 0); | |
| if ($2173) { | |
| break; | |
| } | |
| $2175 = $2174 + -24 | 0; | |
| SAFE_HEAP_STORE($2099 | 0, $2175 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($2175), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i = (tempInt = SAFE_HEAP_LOAD($2099 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2174 = $$pre$i$i; | |
| } | |
| $2176 = $k1$0$i + -1 | 0; | |
| $k1$0$i = $2176; | |
| } | |
| SAFE_HEAP_STORE($73 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($tmp$i + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($73 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($tmp$i + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($73 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($tmp$i + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i169 = 0; | |
| while (1) { | |
| $exitcond$i$i$i170 = ($__i$0$i$i$i169 | 0) == 3; | |
| if ($exitcond$i$i$i170) { | |
| break; | |
| } | |
| $2177 = $tmp$i + ($__i$0$i$i$i169 << 2) | 0; | |
| SAFE_HEAP_STORE($2177 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2178 = $__i$0$i$i$i169 + 1 | 0; | |
| $__i$0$i$i$i169 = $2178; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($72, $73), asyncState ? abort(-12) | 0 : 0; | |
| $2179 = (tempInt = SAFE_HEAP_LOAD($2099 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2180 = $db + 8 | 0; | |
| $2181 = (tempInt = SAFE_HEAP_LOAD($2180 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2182 = $2179 >>> 0 < $2181 >>> 0; | |
| if ($2182) { | |
| $2183 = ($2179 | 0) == (0 | 0); | |
| if ($2183) { | |
| $2185 = 0; | |
| } else { | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2EOS1_($2179, $72), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i8$i = (tempInt = SAFE_HEAP_LOAD($2099 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2185 = $$pre$i8$i; | |
| } | |
| $2184 = $2185 + 24 | 0; | |
| SAFE_HEAP_STORE($2099 | 0, $2184 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $2186 = $db + 12 | 0; | |
| $2187 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2188 = $2179; | |
| $2189 = $2187; | |
| $2190 = $2188 - $2189 | 0; | |
| $2191 = ($2190 | 0) / 24 & -1; | |
| $2192 = $2191 + 1 | 0; | |
| $2193 = ($2192 | 0) < 0; | |
| if ($2193) { | |
| __THREW__ = 0; | |
| invoke_vi(14, $db | 0), asyncState ? abort(-12) | 0 : 0; | |
| $2194 = __THREW__; | |
| __THREW__ = 0; | |
| $2195 = $2194 & 1; | |
| if ($2195) { | |
| $2207 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2208 = tempRet0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($72), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($73), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i = $2208; | |
| $$12$i = $2207; | |
| break; | |
| } else {} | |
| } | |
| $2196 = $2181; | |
| $2197 = $2196 - $2189 | 0; | |
| $2198 = ($2197 | 0) / 24 & -1; | |
| $2199 = $2198 >>> 0 < 1073741823; | |
| if ($2199) { | |
| $2200 = $2198 << 1; | |
| $2201 = $2200 >>> 0 < $2192 >>> 0; | |
| $2202 = $2201 ? $2192 : $2200; | |
| $$0$i$i$i$i = $2202; | |
| } else { | |
| $$0$i$i$i$i = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEEC2EjjS6_($__v$i$i$i, $$0$i$i$i$i, $2191, $2186), asyncState ? abort(-12) | 0 : 0; | |
| $2203 = $__v$i$i$i + 8 | 0; | |
| $2204 = (tempInt = SAFE_HEAP_LOAD($2203 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2205 = ($2204 | 0) == (0 | 0); | |
| if (!$2205) { | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2EOS1_($2204, $72), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $2206 = $2204 + 24 | 0; | |
| SAFE_HEAP_STORE($2203 | 0, $2206 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS3_RS5_EE($db, $__v$i$i$i), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i$i), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($72), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($73), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($tmp$i), asyncState ? abort(-12) | 0 : 0; | |
| $$03$i = $2106; | |
| break L1004; | |
| } | |
| } | |
| } while (0); | |
| if ((label | 0) == 1030) { | |
| $2160 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2161 = tempRet0; | |
| $lpad$phi$i$index = $2160; | |
| $lpad$phi$i$index2 = $2161; | |
| label = 1031; | |
| } | |
| if ((label | 0) == 1031) { | |
| $$1$i = $lpad$phi$i$index2; | |
| $$12$i = $lpad$phi$i$index; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($tmp$i), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$12$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } else { | |
| $$03$i = $first; | |
| } | |
| } else { | |
| $$03$i = $first; | |
| } | |
| } else { | |
| $$03$i = $first; | |
| } | |
| } else { | |
| $$03$i = $first; | |
| } | |
| } while (0); | |
| $$0 = $$03$i; | |
| break L1; | |
| break; | |
| } | |
| default: | |
| { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| } | |
| break; | |
| } | |
| case 116: | |
| { | |
| $2239 = $t$0 + 1 | 0; | |
| $2240 = (tempInt = SAFE_HEAP_LOAD($2239 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2241 = $2240 << 24 >> 24; | |
| if (($2241 | 0) == 105 | ($2241 | 0) == 101) { | |
| $2242 = ($144 | 0) > 2; | |
| L1083 : do { | |
| if ($2242) { | |
| $2243 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2244 = $2243 << 24 >> 24 == 116; | |
| if ($2244) { | |
| $2245 = $first + 1 | 0; | |
| $2246 = (tempInt = SAFE_HEAP_LOAD($2245 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2246 << 24 >> 24 == 105 | $2246 << 24 >> 24 == 101) { | |
| $2247 = $2246 << 24 >> 24 == 101; | |
| $2248 = $first + 2 | 0; | |
| if ($2247) { | |
| $2249 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($2248, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $t$0$i = $2249; | |
| } else { | |
| $2250 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($2248, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $t$0$i = $2250; | |
| } | |
| $2251 = ($t$0$i | 0) == ($2248 | 0); | |
| if ($2251) { | |
| $$03$i193 = $first; | |
| } else { | |
| $2252 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2253 = $db + 4 | 0; | |
| $2254 = (tempInt = SAFE_HEAP_LOAD($2253 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2255 = ($2252 | 0) == ($2254 | 0); | |
| if ($2255) { | |
| $$03$i193 = $first; | |
| } else { | |
| $2256 = $2254 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($61, $2256), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $2257 = (tempInt = invoke_iiii(4, $61 | 0, 0, 3232 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2258 = __THREW__; | |
| __THREW__ = 0; | |
| $2259 = $2258 & 1; | |
| do { | |
| if ($2259) { | |
| $2267 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2268 = tempRet0; | |
| $$1$i192 = $2268; | |
| $$12$i191 = $2267; | |
| } else { | |
| SAFE_HEAP_STORE($60 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2257 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($60 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2257 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($60 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2257 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i185 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i186 = ($__i$0$i$i$i$i185 | 0) == 3; | |
| if ($exitcond$i$i$i$i186) { | |
| break; | |
| } | |
| $2260 = $2257 + ($__i$0$i$i$i$i185 << 2) | 0; | |
| SAFE_HEAP_STORE($2260 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2261 = $__i$0$i$i$i$i185 + 1 | 0; | |
| $__i$0$i$i$i$i185 = $2261; | |
| } | |
| __THREW__ = 0; | |
| $2262 = (tempInt = invoke_iii(5, $60 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2263 = __THREW__; | |
| __THREW__ = 0; | |
| $2264 = $2263 & 1; | |
| if ($2264) { | |
| $2269 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2270 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($60), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i192 = $2270; | |
| $$12$i191 = $2269; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($59 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2262 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($59 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2262 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($59 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2262 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i5$i189 = 0; | |
| while (1) { | |
| $exitcond$i$i$i6$i190 = ($__i$0$i$i$i5$i189 | 0) == 3; | |
| if ($exitcond$i$i$i6$i190) { | |
| break; | |
| } | |
| $2265 = $2262 + ($__i$0$i$i$i5$i189 << 2) | 0; | |
| SAFE_HEAP_STORE($2265 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2266 = $__i$0$i$i$i5$i189 + 1 | 0; | |
| $__i$0$i$i$i5$i189 = $2266; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($58, $59), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($2256, $58), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($58), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($59), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($60), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($61), asyncState ? abort(-12) | 0 : 0; | |
| $$03$i193 = $t$0$i; | |
| break L1083; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($61), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$12$i191 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } else { | |
| $$03$i193 = $first; | |
| } | |
| } else { | |
| $$03$i193 = $first; | |
| } | |
| } else { | |
| $$03$i193 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$03$i193; | |
| break L1; | |
| } else if (($2241 | 0) == 114) { | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ILj6EEERAT__Kc($141, 3216), asyncState ? abort(-12) | 0 : 0; | |
| $2271 = $db + 4 | 0; | |
| $2272 = (tempInt = SAFE_HEAP_LOAD($2271 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2273 = $db + 8 | 0; | |
| $2274 = (tempInt = SAFE_HEAP_LOAD($2273 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2275 = $2272 >>> 0 < $2274 >>> 0; | |
| if ($2275) { | |
| $2276 = ($2272 | 0) == (0 | 0); | |
| if ($2276) { | |
| $2278 = 0; | |
| } else { | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2EOS1_($2272, $141), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i178 = (tempInt = SAFE_HEAP_LOAD($2271 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2278 = $$pre$i178; | |
| } | |
| $2277 = $2278 + 24 | 0; | |
| SAFE_HEAP_STORE($2271 | 0, $2277 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $2279 = $db + 12 | 0; | |
| $2280 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2281 = $2272; | |
| $2282 = $2280; | |
| $2283 = $2281 - $2282 | 0; | |
| $2284 = ($2283 | 0) / 24 & -1; | |
| $2285 = $2284 + 1 | 0; | |
| $2286 = ($2285 | 0) < 0; | |
| if ($2286) { | |
| __THREW__ = 0; | |
| invoke_vi(14, $db | 0), asyncState ? abort(-12) | 0 : 0; | |
| $2287 = __THREW__; | |
| __THREW__ = 0; | |
| $2288 = $2287 & 1; | |
| if ($2288) { | |
| $2301 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2302 = tempRet0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($141), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $2301; | |
| $$2332 = $2302; | |
| break L7; | |
| } else {} | |
| } | |
| $2289 = $2274; | |
| $2290 = $2289 - $2282 | 0; | |
| $2291 = ($2290 | 0) / 24 & -1; | |
| $2292 = $2291 >>> 0 < 1073741823; | |
| if ($2292) { | |
| $2293 = $2291 << 1; | |
| $2294 = $2293 >>> 0 < $2285 >>> 0; | |
| $2295 = $2294 ? $2285 : $2293; | |
| $$0$i$i$i = $2295; | |
| } else { | |
| $$0$i$i$i = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEEC2EjjS6_($__v$i$i, $$0$i$i$i, $2284, $2279), asyncState ? abort(-12) | 0 : 0; | |
| $2296 = $__v$i$i + 8 | 0; | |
| $2297 = (tempInt = SAFE_HEAP_LOAD($2296 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2298 = ($2297 | 0) == (0 | 0); | |
| if (!$2298) { | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2EOS1_($2297, $141), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $2299 = $2297 + 24 | 0; | |
| SAFE_HEAP_STORE($2296 | 0, $2299 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS3_RS5_EE($db, $__v$i$i), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($141), asyncState ? abort(-12) | 0 : 0; | |
| $2300 = $first + 2 | 0; | |
| $$0 = $2300; | |
| break L1; | |
| } else if (($2241 | 0) == 119) { | |
| $2303 = ($144 | 0) > 2; | |
| if ($2303) { | |
| $2304 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2305 = $2304 << 24 >> 24 == 116; | |
| if ($2305) { | |
| $2306 = $first + 1 | 0; | |
| $2307 = (tempInt = SAFE_HEAP_LOAD($2306 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2308 = $2307 << 24 >> 24 == 119; | |
| if ($2308) { | |
| $2309 = $first + 2 | 0; | |
| $2310 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($2309, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2311 = ($2310 | 0) == ($2309 | 0); | |
| if ($2311) { | |
| $$02$i = $first; | |
| } else { | |
| $2312 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2313 = $db + 4 | 0; | |
| $2314 = (tempInt = SAFE_HEAP_LOAD($2313 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2315 = ($2312 | 0) == ($2314 | 0); | |
| if ($2315) { | |
| $$02$i = $first; | |
| } else { | |
| $2316 = $2314 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($64, $2316), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $2317 = (tempInt = invoke_iiii(4, $64 | 0, 0, 3224 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2318 = __THREW__; | |
| __THREW__ = 0; | |
| $2319 = $2318 & 1; | |
| if ($2319) { | |
| $2322 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2323 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($64), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($2322 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| SAFE_HEAP_STORE($63 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2317 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($63 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2317 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($63 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2317 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i181 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i182 = ($__i$0$i$i$i$i181 | 0) == 3; | |
| if ($exitcond$i$i$i$i182) { | |
| break; | |
| } | |
| $2320 = $2317 + ($__i$0$i$i$i$i181 << 2) | 0; | |
| SAFE_HEAP_STORE($2320 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2321 = $__i$0$i$i$i$i181 + 1 | 0; | |
| $__i$0$i$i$i$i181 = $2321; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($62, $63), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($2316, $62), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($62), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($63), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($64), asyncState ? abort(-12) | 0 : 0; | |
| $$02$i = $2310; | |
| } | |
| } | |
| } else { | |
| $$02$i = $first; | |
| } | |
| } else { | |
| $$02$i = $first; | |
| } | |
| } else { | |
| $$02$i = $first; | |
| } | |
| $$0 = $$02$i; | |
| break L1; | |
| } else { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 57: | |
| case 56: | |
| case 55: | |
| case 54: | |
| case 53: | |
| case 52: | |
| case 51: | |
| case 50: | |
| case 49: | |
| { | |
| $2324 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_121parse_unresolved_nameINS0_2DbEEEPKcS4_S4_RT_($first, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $$0 = $2324; | |
| break L1; | |
| break; | |
| } | |
| case 76: | |
| { | |
| $155 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_118parse_expr_primaryINS0_2DbEEEPKcS4_S4_RT_($first, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $$0 = $155; | |
| break L1; | |
| break; | |
| } | |
| case 84: | |
| { | |
| $156 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_120parse_template_paramINS0_2DbEEEPKcS4_S4_RT_($first, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $$0 = $156; | |
| break L1; | |
| break; | |
| } | |
| case 102: | |
| { | |
| $157 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_120parse_function_paramINS0_2DbEEEPKcS4_S4_RT_($first, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $$0 = $157; | |
| break L1; | |
| break; | |
| } | |
| case 97: | |
| { | |
| $158 = $t$0 + 1 | 0; | |
| $159 = (tempInt = SAFE_HEAP_LOAD($158 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $160 = $159 << 24 >> 24; | |
| switch ($160 | 0) { | |
| case 97: | |
| { | |
| $161 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($74, 2776, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $162 = (tempInt = invoke_iiiii(21, $161 | 0, $last | 0, $74 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $163 = __THREW__; | |
| __THREW__ = 0; | |
| $164 = $163 & 1; | |
| if ($164) { | |
| $166 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $167 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($74), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $166; | |
| $$2332 = $167; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($74), asyncState ? abort(-12) | 0 : 0; | |
| $165 = ($162 | 0) == ($161 | 0); | |
| $first$ = $165 ? $first : $162; | |
| $$0 = $first$; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 100: | |
| { | |
| $168 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($75, 2816, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $169 = (tempInt = invoke_iiiii(22, $168 | 0, $last | 0, $75 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $170 = __THREW__; | |
| __THREW__ = 0; | |
| $171 = $170 & 1; | |
| if ($171) { | |
| $173 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $174 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($75), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $173; | |
| $$2332 = $174; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($75), asyncState ? abort(-12) | 0 : 0; | |
| $172 = ($169 | 0) == ($168 | 0); | |
| $first$33 = $172 ? $first : $169; | |
| $$0 = $first$33; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 110: | |
| { | |
| $175 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($76, 2816, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $176 = (tempInt = invoke_iiiii(21, $175 | 0, $last | 0, $76 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $177 = __THREW__; | |
| __THREW__ = 0; | |
| $178 = $177 & 1; | |
| if ($178) { | |
| $180 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $181 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($76), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $180; | |
| $$2332 = $181; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($76), asyncState ? abort(-12) | 0 : 0; | |
| $179 = ($176 | 0) == ($175 | 0); | |
| $first$34 = $179 ? $first : $176; | |
| $$0 = $first$34; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 78: | |
| { | |
| $182 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($77, 2904, 2), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $183 = (tempInt = invoke_iiiii(21, $182 | 0, $last | 0, $77 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $184 = __THREW__; | |
| __THREW__ = 0; | |
| $185 = $184 & 1; | |
| if ($185) { | |
| $187 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $188 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($77), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $187; | |
| $$2332 = $188; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($77), asyncState ? abort(-12) | 0 : 0; | |
| $186 = ($183 | 0) == ($182 | 0); | |
| $first$35 = $186 ? $first : $183; | |
| $$0 = $first$35; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 83: | |
| { | |
| $189 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($78, 2912, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $190 = (tempInt = invoke_iiiii(21, $189 | 0, $last | 0, $78 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $191 = __THREW__; | |
| __THREW__ = 0; | |
| $192 = $191 & 1; | |
| if ($192) { | |
| $194 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $195 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($78), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $194; | |
| $$2332 = $195; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($78), asyncState ? abort(-12) | 0 : 0; | |
| $193 = ($190 | 0) == ($189 | 0); | |
| $first$36 = $193 ? $first : $190; | |
| $$0 = $first$36; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 116: | |
| { | |
| $196 = ($144 | 0) > 2; | |
| L1171 : do { | |
| if ($196) { | |
| $197 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $198 = $197 << 24 >> 24 == 97; | |
| if ($198) { | |
| $199 = $first + 1 | 0; | |
| $200 = (tempInt = SAFE_HEAP_LOAD($199 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $201 = $200 << 24 >> 24 == 116; | |
| if ($201) { | |
| $202 = $first + 2 | 0; | |
| $203 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($202, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $204 = ($203 | 0) == ($202 | 0); | |
| if ($204) { | |
| $$03$i501 = $first; | |
| } else { | |
| $205 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $206 = $db + 4 | 0; | |
| $207 = (tempInt = SAFE_HEAP_LOAD($206 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $208 = ($205 | 0) == ($207 | 0); | |
| if ($208) { | |
| $$03$i501 = $first; | |
| } else { | |
| $209 = $207 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($2, $209), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $210 = (tempInt = invoke_iiii(4, $2 | 0, 0, 4656 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $211 = __THREW__; | |
| __THREW__ = 0; | |
| $212 = $211 & 1; | |
| do { | |
| if ($212) { | |
| $266 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $267 = tempRet0; | |
| $$1$i500 = $267; | |
| $$12$i499 = $266; | |
| } else { | |
| SAFE_HEAP_STORE($1 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($210 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($210 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($210 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i473 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i474 = ($__i$0$i$i$i$i473 | 0) == 3; | |
| if ($exitcond$i$i$i$i474) { | |
| break; | |
| } | |
| $213 = $210 + ($__i$0$i$i$i$i473 << 2) | 0; | |
| SAFE_HEAP_STORE($213 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $214 = $__i$0$i$i$i$i473 + 1 | 0; | |
| $__i$0$i$i$i$i473 = $214; | |
| } | |
| __THREW__ = 0; | |
| $215 = (tempInt = invoke_iii(5, $1 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $216 = __THREW__; | |
| __THREW__ = 0; | |
| $217 = $216 & 1; | |
| if ($217) { | |
| $268 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $269 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($1), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i500 = $269; | |
| $$12$i499 = $268; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($0 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($215 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($0 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($215 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($0 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($215 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i5$i477 = 0; | |
| while (1) { | |
| $exitcond$i$i$i6$i478 = ($__i$0$i$i$i5$i477 | 0) == 3; | |
| if ($exitcond$i$i$i6$i478) { | |
| break; | |
| } | |
| $218 = $215 + ($__i$0$i$i$i5$i477 << 2) | 0; | |
| SAFE_HEAP_STORE($218 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $219 = $__i$0$i$i$i5$i477 + 1 | 0; | |
| $__i$0$i$i$i5$i477 = $219; | |
| } | |
| $220 = (tempInt = SAFE_HEAP_LOAD($209 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $221 = $220 & 1; | |
| $222 = $221 << 24 >> 24 == 0; | |
| do { | |
| if ($222) { | |
| $223 = $209 + 1 | 0; | |
| SAFE_HEAP_STORE($223 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($209 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $224 = $207 + -16 | 0; | |
| $225 = (tempInt = SAFE_HEAP_LOAD($224 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($225 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $226 = $207 + -20 | 0; | |
| SAFE_HEAP_STORE($226 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i$i$i481 = (tempInt = SAFE_HEAP_LOAD($209 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $227 = $$pre$i$i$i$i481 & 1; | |
| $228 = $227 << 24 >> 24 == 0; | |
| if ($228) { | |
| $233 = $$pre$i$i$i$i481; | |
| $242 = 10; | |
| } else { | |
| $229 = (tempInt = SAFE_HEAP_LOAD($209 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $230 = $229 & -2; | |
| $phitmp$i$i$i$i$i$i$i483 = $230 + -1 | 0; | |
| $231 = $229 & 255; | |
| $233 = $231; | |
| $242 = $phitmp$i$i$i$i$i$i$i483; | |
| } | |
| $232 = $233 & 1; | |
| $234 = $232 << 24 >> 24 == 0; | |
| if ($234) { | |
| $235 = $233 & 255; | |
| $236 = $235 >>> 1; | |
| $237 = ($233 & 255) < 22; | |
| if ($237) { | |
| $2325 = 1; | |
| $241 = 10; | |
| $261 = $236; | |
| } else { | |
| $238 = $236 + 16 | 0; | |
| $239 = $238 & 240; | |
| $phitmp$i2$i$i$i$i$i$i486 = $239 + -1 | 0; | |
| $2325 = 1; | |
| $241 = $phitmp$i2$i$i$i$i$i$i486; | |
| $261 = $236; | |
| } | |
| } else { | |
| $2325 = 0; | |
| $241 = 10; | |
| $261 = 0; | |
| } | |
| $240 = ($241 | 0) == ($242 | 0); | |
| if (!$240) { | |
| $243 = ($241 | 0) == 10; | |
| if ($243) { | |
| $248 = $209 + 1 | 0; | |
| $249 = (tempInt = SAFE_HEAP_LOAD($224 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2325) { | |
| $250 = $233 & 255; | |
| $251 = $250 >>> 1; | |
| $252 = $251 + 1 | 0; | |
| (tempInt = _memcpy($248 | 0, $249 | 0, $252 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($249), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $257 = (tempInt = SAFE_HEAP_LOAD($249 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($248 >> 0 | 0, $257 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($249), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $262 = $261 << 1; | |
| $263 = $262 & 255; | |
| SAFE_HEAP_STORE($209 >> 0 | 0, $263 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $244 = $241 >>> 0 <= $242 >>> 0; | |
| $245 = $241 + 1 | 0; | |
| $246 = (tempInt = _malloc($245) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $247 = ($246 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i$i488 = $244 & $247; | |
| if ($or$cond$i$i$i$i$i$i488) { | |
| break; | |
| } | |
| if ($2325) { | |
| $253 = $209 + 1 | 0; | |
| $254 = $233 & 255; | |
| $255 = $254 >>> 1; | |
| $256 = $255 + 1 | 0; | |
| (tempInt = _memcpy($246 | 0, $253 | 0, $256 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } else { | |
| $258 = (tempInt = SAFE_HEAP_LOAD($224 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $259 = (tempInt = SAFE_HEAP_LOAD($258 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($246 >> 0 | 0, $259 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($258), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $260 = $245 | 1; | |
| SAFE_HEAP_STORE($209 | 0, $260 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($226 | 0, $261 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($224 | 0, $246 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($209 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($0 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($209 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($0 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($209 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($0 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i$i496 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i$i497 = ($__i$0$i$i$i$i$i496 | 0) == 3; | |
| if ($exitcond$i$i$i$i$i497) { | |
| break; | |
| } | |
| $264 = $0 + ($__i$0$i$i$i$i$i496 << 2) | 0; | |
| SAFE_HEAP_STORE($264 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $265 = $__i$0$i$i$i$i$i496 + 1 | 0; | |
| $__i$0$i$i$i$i$i496 = $265; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($1), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($2), asyncState ? abort(-12) | 0 : 0; | |
| $$03$i501 = $203; | |
| break L1171; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($2), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$12$i499 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } else { | |
| $$03$i501 = $first; | |
| } | |
| } else { | |
| $$03$i501 = $first; | |
| } | |
| } else { | |
| $$03$i501 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$03$i501; | |
| break L1; | |
| break; | |
| } | |
| case 122: | |
| { | |
| $270 = ($144 | 0) > 2; | |
| L1222 : do { | |
| if ($270) { | |
| $271 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $272 = $271 << 24 >> 24 == 97; | |
| if ($272) { | |
| $273 = $first + 1 | 0; | |
| $274 = (tempInt = SAFE_HEAP_LOAD($273 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $275 = $274 << 24 >> 24 == 122; | |
| if ($275) { | |
| $276 = $first + 2 | 0; | |
| $277 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($276, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $278 = ($277 | 0) == ($276 | 0); | |
| if ($278) { | |
| $$03$i471 = $first; | |
| } else { | |
| $279 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $280 = $db + 4 | 0; | |
| $281 = (tempInt = SAFE_HEAP_LOAD($280 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $282 = ($279 | 0) == ($281 | 0); | |
| if ($282) { | |
| $$03$i471 = $first; | |
| } else { | |
| $283 = $281 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($5, $283), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $284 = (tempInt = invoke_iiii(4, $5 | 0, 0, 4656 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $285 = __THREW__; | |
| __THREW__ = 0; | |
| $286 = $285 & 1; | |
| do { | |
| if ($286) { | |
| $340 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $341 = tempRet0; | |
| $$1$i470 = $341; | |
| $$12$i469 = $340; | |
| } else { | |
| SAFE_HEAP_STORE($4 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($284 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($4 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($284 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($4 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($284 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i443 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i444 = ($__i$0$i$i$i$i443 | 0) == 3; | |
| if ($exitcond$i$i$i$i444) { | |
| break; | |
| } | |
| $287 = $284 + ($__i$0$i$i$i$i443 << 2) | 0; | |
| SAFE_HEAP_STORE($287 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $288 = $__i$0$i$i$i$i443 + 1 | 0; | |
| $__i$0$i$i$i$i443 = $288; | |
| } | |
| __THREW__ = 0; | |
| $289 = (tempInt = invoke_iii(5, $4 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $290 = __THREW__; | |
| __THREW__ = 0; | |
| $291 = $290 & 1; | |
| if ($291) { | |
| $342 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $343 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($4), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i470 = $343; | |
| $$12$i469 = $342; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($3 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($289 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($3 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($289 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($3 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($289 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i5$i447 = 0; | |
| while (1) { | |
| $exitcond$i$i$i6$i448 = ($__i$0$i$i$i5$i447 | 0) == 3; | |
| if ($exitcond$i$i$i6$i448) { | |
| break; | |
| } | |
| $292 = $289 + ($__i$0$i$i$i5$i447 << 2) | 0; | |
| SAFE_HEAP_STORE($292 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $293 = $__i$0$i$i$i5$i447 + 1 | 0; | |
| $__i$0$i$i$i5$i447 = $293; | |
| } | |
| $294 = (tempInt = SAFE_HEAP_LOAD($283 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $295 = $294 & 1; | |
| $296 = $295 << 24 >> 24 == 0; | |
| do { | |
| if ($296) { | |
| $297 = $283 + 1 | 0; | |
| SAFE_HEAP_STORE($297 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($283 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $298 = $281 + -16 | 0; | |
| $299 = (tempInt = SAFE_HEAP_LOAD($298 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($299 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $300 = $281 + -20 | 0; | |
| SAFE_HEAP_STORE($300 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i$i$i451 = (tempInt = SAFE_HEAP_LOAD($283 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $301 = $$pre$i$i$i$i451 & 1; | |
| $302 = $301 << 24 >> 24 == 0; | |
| if ($302) { | |
| $307 = $$pre$i$i$i$i451; | |
| $316 = 10; | |
| } else { | |
| $303 = (tempInt = SAFE_HEAP_LOAD($283 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $304 = $303 & -2; | |
| $phitmp$i$i$i$i$i$i$i453 = $304 + -1 | 0; | |
| $305 = $303 & 255; | |
| $307 = $305; | |
| $316 = $phitmp$i$i$i$i$i$i$i453; | |
| } | |
| $306 = $307 & 1; | |
| $308 = $306 << 24 >> 24 == 0; | |
| if ($308) { | |
| $309 = $307 & 255; | |
| $310 = $309 >>> 1; | |
| $311 = ($307 & 255) < 22; | |
| if ($311) { | |
| $2326 = 1; | |
| $315 = 10; | |
| $335 = $310; | |
| } else { | |
| $312 = $310 + 16 | 0; | |
| $313 = $312 & 240; | |
| $phitmp$i2$i$i$i$i$i$i456 = $313 + -1 | 0; | |
| $2326 = 1; | |
| $315 = $phitmp$i2$i$i$i$i$i$i456; | |
| $335 = $310; | |
| } | |
| } else { | |
| $2326 = 0; | |
| $315 = 10; | |
| $335 = 0; | |
| } | |
| $314 = ($315 | 0) == ($316 | 0); | |
| if (!$314) { | |
| $317 = ($315 | 0) == 10; | |
| if ($317) { | |
| $322 = $283 + 1 | 0; | |
| $323 = (tempInt = SAFE_HEAP_LOAD($298 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2326) { | |
| $324 = $307 & 255; | |
| $325 = $324 >>> 1; | |
| $326 = $325 + 1 | 0; | |
| (tempInt = _memcpy($322 | 0, $323 | 0, $326 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($323), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $331 = (tempInt = SAFE_HEAP_LOAD($323 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($322 >> 0 | 0, $331 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($323), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $336 = $335 << 1; | |
| $337 = $336 & 255; | |
| SAFE_HEAP_STORE($283 >> 0 | 0, $337 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $318 = $315 >>> 0 <= $316 >>> 0; | |
| $319 = $315 + 1 | 0; | |
| $320 = (tempInt = _malloc($319) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $321 = ($320 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i$i458 = $318 & $321; | |
| if ($or$cond$i$i$i$i$i$i458) { | |
| break; | |
| } | |
| if ($2326) { | |
| $327 = $283 + 1 | 0; | |
| $328 = $307 & 255; | |
| $329 = $328 >>> 1; | |
| $330 = $329 + 1 | 0; | |
| (tempInt = _memcpy($320 | 0, $327 | 0, $330 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } else { | |
| $332 = (tempInt = SAFE_HEAP_LOAD($298 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $333 = (tempInt = SAFE_HEAP_LOAD($332 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($320 >> 0 | 0, $333 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($332), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $334 = $319 | 1; | |
| SAFE_HEAP_STORE($283 | 0, $334 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($300 | 0, $335 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($298 | 0, $320 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($283 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($3 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($283 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($3 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($283 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($3 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i$i466 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i$i467 = ($__i$0$i$i$i$i$i466 | 0) == 3; | |
| if ($exitcond$i$i$i$i$i467) { | |
| break; | |
| } | |
| $338 = $3 + ($__i$0$i$i$i$i$i466 << 2) | 0; | |
| SAFE_HEAP_STORE($338 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $339 = $__i$0$i$i$i$i$i466 + 1 | 0; | |
| $__i$0$i$i$i$i$i466 = $339; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($3), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($4), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($5), asyncState ? abort(-12) | 0 : 0; | |
| $$03$i471 = $277; | |
| break L1222; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($5), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$12$i469 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } else { | |
| $$03$i471 = $first; | |
| } | |
| } else { | |
| $$03$i471 = $first; | |
| } | |
| } else { | |
| $$03$i471 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$03$i471; | |
| break L1; | |
| break; | |
| } | |
| default: | |
| { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| } | |
| break; | |
| } | |
| case 99: | |
| { | |
| $344 = $t$0 + 1 | 0; | |
| $345 = (tempInt = SAFE_HEAP_LOAD($344 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $346 = $345 << 24 >> 24; | |
| switch ($346 | 0) { | |
| case 118: | |
| { | |
| $553 = ($144 | 0) > 2; | |
| L1275 : do { | |
| if ($553) { | |
| $554 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $555 = $554 << 24 >> 24 == 99; | |
| if ($555) { | |
| $556 = $first + 1 | 0; | |
| $557 = (tempInt = SAFE_HEAP_LOAD($556 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $558 = $557 << 24 >> 24 == 118; | |
| if ($558) { | |
| $559 = $db + 63 | 0; | |
| $560 = (tempInt = SAFE_HEAP_LOAD($559 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($559 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $561 = $first + 2 | 0; | |
| $562 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($561, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| SAFE_HEAP_STORE($559 >> 0 | 0, $560 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $563 = ($562 | 0) == ($561 | 0); | |
| $564 = ($562 | 0) == ($last | 0); | |
| $or$cond$i360 = $563 | $564; | |
| if ($or$cond$i360) { | |
| $$311$i = $first; | |
| } else { | |
| $565 = (tempInt = SAFE_HEAP_LOAD($562 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $566 = $565 << 24 >> 24 == 95; | |
| if ($566) { | |
| $569 = $562 + 1 | 0; | |
| $570 = ($569 | 0) == ($last | 0); | |
| if ($570) { | |
| $$311$i = $first; | |
| break; | |
| } | |
| $571 = (tempInt = SAFE_HEAP_LOAD($569 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $572 = $571 << 24 >> 24 == 69; | |
| do { | |
| if ($572) { | |
| $573 = $db + 4 | 0; | |
| $574 = (tempInt = SAFE_HEAP_LOAD($573 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $575 = $db + 8 | 0; | |
| $576 = (tempInt = SAFE_HEAP_LOAD($575 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $577 = $574 >>> 0 < $576 >>> 0; | |
| if ($577) { | |
| $578 = ($574 | 0) == (0 | 0); | |
| if ($578) { | |
| $585 = 0; | |
| } else { | |
| SAFE_HEAP_STORE($574 + 0 | 0, 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($574 + 4 | 0, 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($574 + 8 | 0, 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($574 + 12 | 0, 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($574 + 16 | 0, 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($574 + 20 | 0, 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i$i$i$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i$i$i$i = ($__i$0$i$i$i$i$i$i$i | 0) == 3; | |
| if ($exitcond$i$i$i$i$i$i$i) { | |
| break; | |
| } | |
| $579 = $574 + ($__i$0$i$i$i$i$i$i$i << 2) | 0; | |
| SAFE_HEAP_STORE($579 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $580 = $__i$0$i$i$i$i$i$i$i + 1 | 0; | |
| $__i$0$i$i$i$i$i$i$i = $580; | |
| } | |
| $581 = $574 + 12 | 0; | |
| $__i$0$i$i1$i$i$i$i$i = 0; | |
| while (1) { | |
| $exitcond$i$i2$i$i$i$i$i = ($__i$0$i$i1$i$i$i$i$i | 0) == 3; | |
| if ($exitcond$i$i2$i$i$i$i$i) { | |
| break; | |
| } | |
| $582 = $581 + ($__i$0$i$i1$i$i$i$i$i << 2) | 0; | |
| SAFE_HEAP_STORE($582 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $583 = $__i$0$i$i1$i$i$i$i$i + 1 | 0; | |
| $__i$0$i$i1$i$i$i$i$i = $583; | |
| } | |
| $$pre$i$i361 = (tempInt = SAFE_HEAP_LOAD($573 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $585 = $$pre$i$i361; | |
| } | |
| $584 = $585 + 24 | 0; | |
| SAFE_HEAP_STORE($573 | 0, $584 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $t$1$i365 = $569; | |
| break; | |
| } | |
| $586 = $db + 12 | 0; | |
| $587 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $588 = $574; | |
| $589 = $587; | |
| $590 = $588 - $589 | 0; | |
| $591 = ($590 | 0) / 24 & -1; | |
| $592 = $591 + 1 | 0; | |
| $593 = ($592 | 0) < 0; | |
| if ($593) { | |
| __ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv($db), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $594 = $576; | |
| $595 = $594 - $589 | 0; | |
| $596 = ($595 | 0) / 24 & -1; | |
| $597 = $596 >>> 0 < 1073741823; | |
| if ($597) { | |
| $598 = $596 << 1; | |
| $599 = $598 >>> 0 < $592 >>> 0; | |
| $600 = $599 ? $592 : $598; | |
| $$0$i$i$i$i362 = $600; | |
| } else { | |
| $$0$i$i$i$i362 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEEC2EjjS6_($__v$i$i$i359, $$0$i$i$i$i362, $591, $586), asyncState ? abort(-12) | 0 : 0; | |
| $601 = $__v$i$i$i359 + 8 | 0; | |
| $602 = (tempInt = SAFE_HEAP_LOAD($601 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $603 = ($602 | 0) == (0 | 0); | |
| if (!$603) { | |
| SAFE_HEAP_STORE($602 + 0 | 0, 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($602 + 4 | 0, 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($602 + 8 | 0, 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($602 + 12 | 0, 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($602 + 16 | 0, 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($602 + 20 | 0, 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i$i$i$i$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i$i$i$i$i = ($__i$0$i$i$i$i$i$i$i$i | 0) == 3; | |
| if ($exitcond$i$i$i$i$i$i$i$i) { | |
| break; | |
| } | |
| $604 = $602 + ($__i$0$i$i$i$i$i$i$i$i << 2) | 0; | |
| SAFE_HEAP_STORE($604 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $605 = $__i$0$i$i$i$i$i$i$i$i + 1 | 0; | |
| $__i$0$i$i$i$i$i$i$i$i = $605; | |
| } | |
| $606 = $602 + 12 | 0; | |
| $__i$0$i$i1$i$i$i$i$i$i = 0; | |
| while (1) { | |
| $exitcond$i$i2$i$i$i$i$i$i = ($__i$0$i$i1$i$i$i$i$i$i | 0) == 3; | |
| if ($exitcond$i$i2$i$i$i$i$i$i) { | |
| break; | |
| } | |
| $607 = $606 + ($__i$0$i$i1$i$i$i$i$i$i << 2) | 0; | |
| SAFE_HEAP_STORE($607 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $608 = $__i$0$i$i1$i$i$i$i$i$i + 1 | 0; | |
| $__i$0$i$i1$i$i$i$i$i$i = $608; | |
| } | |
| } | |
| $609 = $602 + 24 | 0; | |
| SAFE_HEAP_STORE($601 | 0, $609 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS3_RS5_EE($db, $__v$i$i$i359), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i$i359), asyncState ? abort(-12) | 0 : 0; | |
| $t$1$i365 = $569; | |
| } else { | |
| $611 = $571; | |
| $t$0$i364 = $569; | |
| while (1) { | |
| $610 = $611 << 24 >> 24 == 69; | |
| if ($610) { | |
| $t$0$i364$lcssa = $t$0$i364; | |
| label = 240; | |
| break; | |
| } | |
| $612 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($t$0$i364, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $613 = ($612 | 0) == ($t$0$i364 | 0); | |
| $614 = ($612 | 0) == ($last | 0); | |
| $or$cond13$i = $613 | $614; | |
| if ($or$cond13$i) { | |
| label = 276; | |
| break; | |
| } | |
| $$pre = (tempInt = SAFE_HEAP_LOAD($612 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $611 = $$pre; | |
| $t$0$i364 = $612; | |
| } | |
| if ((label | 0) == 240) { | |
| $t$1$i365 = $t$0$i364$lcssa; | |
| break; | |
| } else if ((label | 0) == 276) { | |
| $$311$i = $first; | |
| break L1275; | |
| } | |
| } | |
| } while (0); | |
| $615 = $t$1$i365 + 1 | 0; | |
| $t$2$i366 = $615; | |
| } else { | |
| $567 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($562, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $568 = ($567 | 0) == ($562 | 0); | |
| if ($568) { | |
| $$311$i = $first; | |
| break; | |
| } else { | |
| $t$2$i366 = $567; | |
| } | |
| } | |
| $616 = $db + 4 | 0; | |
| $617 = (tempInt = SAFE_HEAP_LOAD($616 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $618 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $619 = $617; | |
| $620 = $618; | |
| $621 = $619 - $620 | 0; | |
| $622 = ($621 | 0) / 24 & -1; | |
| $623 = $622 >>> 0 < 2; | |
| if ($623) { | |
| $$311$i = $first; | |
| } else { | |
| $624 = $617 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($tmp2$i, $624), asyncState ? abort(-12) | 0 : 0; | |
| $625 = (tempInt = SAFE_HEAP_LOAD($616 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $626 = $625 + -24 | 0; | |
| $628 = $625; | |
| while (1) { | |
| $627 = ($628 | 0) == ($626 | 0); | |
| if ($627) { | |
| break; | |
| } | |
| $629 = $628 + -24 | 0; | |
| SAFE_HEAP_STORE($616 | 0, $629 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($629), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i14$i = (tempInt = SAFE_HEAP_LOAD($616 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $628 = $$pre$i14$i; | |
| } | |
| $630 = $625 + -48 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $18 | 0, $630 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $631 = __THREW__; | |
| __THREW__ = 0; | |
| $632 = $631 & 1; | |
| if ($632) { | |
| $665 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $666 = tempRet0; | |
| $$4$i378 = $666; | |
| $$46$i = $665; | |
| } else { | |
| __THREW__ = 0; | |
| $633 = (tempInt = invoke_iiii(4, $18 | 0, 0, 2768 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $634 = __THREW__; | |
| __THREW__ = 0; | |
| $635 = $634 & 1; | |
| if ($635) { | |
| $667 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $668 = tempRet0; | |
| $$3$i377 = $668; | |
| $$35$i = $667; | |
| } else { | |
| SAFE_HEAP_STORE($17 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($633 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($17 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($633 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($17 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($633 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i369 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i370 = ($__i$0$i$i$i$i369 | 0) == 3; | |
| if ($exitcond$i$i$i$i370) { | |
| break; | |
| } | |
| $636 = $633 + ($__i$0$i$i$i$i369 << 2) | 0; | |
| SAFE_HEAP_STORE($636 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $637 = $__i$0$i$i$i$i369 + 1 | 0; | |
| $__i$0$i$i$i$i369 = $637; | |
| } | |
| __THREW__ = 0; | |
| $638 = (tempInt = invoke_iii(5, $17 | 0, 4528 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $639 = __THREW__; | |
| __THREW__ = 0; | |
| $640 = $639 & 1; | |
| if ($640) { | |
| $669 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $670 = tempRet0; | |
| $$2$i376 = $670; | |
| $$24$i = $669; | |
| } else { | |
| SAFE_HEAP_STORE($16 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($638 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($16 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($638 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($16 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($638 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i15$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i16$i = ($__i$0$i$i$i15$i | 0) == 3; | |
| if ($exitcond$i$i$i16$i) { | |
| break; | |
| } | |
| $641 = $638 + ($__i$0$i$i$i15$i << 2) | 0; | |
| SAFE_HEAP_STORE($641 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $642 = $__i$0$i$i$i15$i + 1 | 0; | |
| $__i$0$i$i$i15$i = $642; | |
| } | |
| $643 = (tempInt = SAFE_HEAP_LOAD($tmp2$i >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $644 = $643 & 1; | |
| $645 = $644 << 24 >> 24 == 0; | |
| if ($645) { | |
| $650 = $tmp2$i + 1 | 0; | |
| $651 = $643 & 255; | |
| $652 = $651 >>> 1; | |
| $653 = $650; | |
| $654 = $652; | |
| } else { | |
| $646 = $tmp2$i + 8 | 0; | |
| $647 = (tempInt = SAFE_HEAP_LOAD($646 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $648 = $tmp2$i + 4 | 0; | |
| $649 = (tempInt = SAFE_HEAP_LOAD($648 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $653 = $647; | |
| $654 = $649; | |
| } | |
| __THREW__ = 0; | |
| $655 = (tempInt = invoke_iiii(3, $16 | 0, $653 | 0, $654 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $656 = __THREW__; | |
| __THREW__ = 0; | |
| $657 = $656 & 1; | |
| do { | |
| if ($657) { | |
| $671 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $672 = tempRet0; | |
| $$1$i375 = $672; | |
| $$13$i = $671; | |
| } else { | |
| SAFE_HEAP_STORE($15 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($655 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($15 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($655 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($15 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($655 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i18$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i19$i = ($__i$0$i$i$i18$i | 0) == 3; | |
| if ($exitcond$i$i$i19$i) { | |
| break; | |
| } | |
| $658 = $655 + ($__i$0$i$i$i18$i << 2) | 0; | |
| SAFE_HEAP_STORE($658 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $659 = $__i$0$i$i$i18$i + 1 | 0; | |
| $__i$0$i$i$i18$i = $659; | |
| } | |
| __THREW__ = 0; | |
| $660 = (tempInt = invoke_iii(5, $15 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $661 = __THREW__; | |
| __THREW__ = 0; | |
| $662 = $661 & 1; | |
| if ($662) { | |
| $673 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $674 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($15), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i375 = $674; | |
| $$13$i = $673; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($14 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($660 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($14 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($660 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($14 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($660 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i21$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i22$i = ($__i$0$i$i$i21$i | 0) == 3; | |
| if ($exitcond$i$i$i22$i) { | |
| break; | |
| } | |
| $663 = $660 + ($__i$0$i$i$i21$i << 2) | 0; | |
| SAFE_HEAP_STORE($663 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $664 = $__i$0$i$i$i21$i + 1 | 0; | |
| $__i$0$i$i$i21$i = $664; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($13, $14), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($630, $13), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($13), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($14), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($15), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($16), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($17), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($18), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($tmp2$i), asyncState ? abort(-12) | 0 : 0; | |
| $$311$i = $t$2$i366; | |
| break L1275; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($16), asyncState ? abort(-12) | 0 : 0; | |
| $$2$i376 = $$1$i375; | |
| $$24$i = $$13$i; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($17), asyncState ? abort(-12) | 0 : 0; | |
| $$3$i377 = $$2$i376; | |
| $$35$i = $$24$i; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($18), asyncState ? abort(-12) | 0 : 0; | |
| $$4$i378 = $$3$i377; | |
| $$46$i = $$35$i; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($tmp2$i), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$46$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } else { | |
| $$311$i = $first; | |
| } | |
| } else { | |
| $$311$i = $first; | |
| } | |
| } else { | |
| $$311$i = $first; | |
| } | |
| } while (0); | |
| $$0 = $$311$i; | |
| break L1; | |
| break; | |
| } | |
| case 111: | |
| { | |
| $546 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($80, 2928, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $547 = (tempInt = invoke_iiiii(22, $546 | 0, $last | 0, $80 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $548 = __THREW__; | |
| __THREW__ = 0; | |
| $549 = $548 & 1; | |
| if ($549) { | |
| $551 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $552 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($80), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $551; | |
| $$2332 = $552; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($80), asyncState ? abort(-12) | 0 : 0; | |
| $550 = ($547 | 0) == ($546 | 0); | |
| $first$38 = $550 ? $first : $547; | |
| $$0 = $first$38; | |
| break L1; | |
| } | |
| break; | |
| } | |
| case 99: | |
| { | |
| $347 = ($144 | 0) > 2; | |
| L1377 : do { | |
| if ($347) { | |
| $348 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $349 = $348 << 24 >> 24 == 99; | |
| if ($349) { | |
| $350 = $first + 1 | 0; | |
| $351 = (tempInt = SAFE_HEAP_LOAD($350 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $352 = $351 << 24 >> 24 == 99; | |
| if ($352) { | |
| $353 = $first + 2 | 0; | |
| $354 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($353, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $355 = ($354 | 0) == ($353 | 0); | |
| if ($355) { | |
| $$06$i441 = $first; | |
| } else { | |
| $356 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($354, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $357 = ($356 | 0) == ($354 | 0); | |
| if ($357) { | |
| $$06$i441 = $first; | |
| } else { | |
| $358 = $db + 4 | 0; | |
| $359 = (tempInt = SAFE_HEAP_LOAD($358 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $360 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $361 = $359; | |
| $362 = $360; | |
| $363 = $361 - $362 | 0; | |
| $364 = ($363 | 0) / 24 & -1; | |
| $365 = $364 >>> 0 < 2; | |
| if ($365) { | |
| $$06$i441 = $first; | |
| } else { | |
| $366 = $359 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($expr$i413, $366), asyncState ? abort(-12) | 0 : 0; | |
| $367 = (tempInt = SAFE_HEAP_LOAD($358 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $368 = $367 + -24 | 0; | |
| $370 = $367; | |
| while (1) { | |
| $369 = ($370 | 0) == ($368 | 0); | |
| if ($369) { | |
| break; | |
| } | |
| $371 = $370 + -24 | 0; | |
| SAFE_HEAP_STORE($358 | 0, $371 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($371), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i414 = (tempInt = SAFE_HEAP_LOAD($358 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $370 = $$pre$i$i414; | |
| } | |
| $372 = $367 + -48 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $11 | 0, $372 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $373 = __THREW__; | |
| __THREW__ = 0; | |
| $374 = $373 & 1; | |
| if ($374) { | |
| $407 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $408 = tempRet0; | |
| $$4$i440 = $408; | |
| $$45$i439 = $407; | |
| } else { | |
| __THREW__ = 0; | |
| $375 = (tempInt = invoke_iiii(4, $11 | 0, 0, 4640 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $376 = __THREW__; | |
| __THREW__ = 0; | |
| $377 = $376 & 1; | |
| if ($377) { | |
| $409 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $410 = tempRet0; | |
| $$3$i438 = $410; | |
| $$34$i437 = $409; | |
| } else { | |
| SAFE_HEAP_STORE($10 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($375 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($10 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($375 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($10 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($375 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i417 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i418 = ($__i$0$i$i$i$i417 | 0) == 3; | |
| if ($exitcond$i$i$i$i418) { | |
| break; | |
| } | |
| $378 = $375 + ($__i$0$i$i$i$i417 << 2) | 0; | |
| SAFE_HEAP_STORE($378 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $379 = $__i$0$i$i$i$i417 + 1 | 0; | |
| $__i$0$i$i$i$i417 = $379; | |
| } | |
| __THREW__ = 0; | |
| $380 = (tempInt = invoke_iii(5, $10 | 0, 3296 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $381 = __THREW__; | |
| __THREW__ = 0; | |
| $382 = $381 & 1; | |
| if ($382) { | |
| $411 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $412 = tempRet0; | |
| $$2$i436 = $412; | |
| $$23$i435 = $411; | |
| } else { | |
| SAFE_HEAP_STORE($9 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($380 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($9 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($380 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($9 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($380 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i8$i421 = 0; | |
| while (1) { | |
| $exitcond$i$i$i9$i422 = ($__i$0$i$i$i8$i421 | 0) == 3; | |
| if ($exitcond$i$i$i9$i422) { | |
| break; | |
| } | |
| $383 = $380 + ($__i$0$i$i$i8$i421 << 2) | 0; | |
| SAFE_HEAP_STORE($383 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $384 = $__i$0$i$i$i8$i421 + 1 | 0; | |
| $__i$0$i$i$i8$i421 = $384; | |
| } | |
| $385 = (tempInt = SAFE_HEAP_LOAD($expr$i413 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $386 = $385 & 1; | |
| $387 = $386 << 24 >> 24 == 0; | |
| if ($387) { | |
| $392 = $expr$i413 + 1 | 0; | |
| $393 = $385 & 255; | |
| $394 = $393 >>> 1; | |
| $395 = $392; | |
| $396 = $394; | |
| } else { | |
| $388 = $expr$i413 + 8 | 0; | |
| $389 = (tempInt = SAFE_HEAP_LOAD($388 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $390 = $expr$i413 + 4 | 0; | |
| $391 = (tempInt = SAFE_HEAP_LOAD($390 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $395 = $389; | |
| $396 = $391; | |
| } | |
| __THREW__ = 0; | |
| $397 = (tempInt = invoke_iiii(3, $9 | 0, $395 | 0, $396 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $398 = __THREW__; | |
| __THREW__ = 0; | |
| $399 = $398 & 1; | |
| do { | |
| if ($399) { | |
| $413 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $414 = tempRet0; | |
| $$1$i434 = $414; | |
| $$12$i433 = $413; | |
| } else { | |
| SAFE_HEAP_STORE($8 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($397 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($8 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($397 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($8 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($397 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i11$i426 = 0; | |
| while (1) { | |
| $exitcond$i$i$i12$i427 = ($__i$0$i$i$i11$i426 | 0) == 3; | |
| if ($exitcond$i$i$i12$i427) { | |
| break; | |
| } | |
| $400 = $397 + ($__i$0$i$i$i11$i426 << 2) | 0; | |
| SAFE_HEAP_STORE($400 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $401 = $__i$0$i$i$i11$i426 + 1 | 0; | |
| $__i$0$i$i$i11$i426 = $401; | |
| } | |
| __THREW__ = 0; | |
| $402 = (tempInt = invoke_iii(5, $8 | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $403 = __THREW__; | |
| __THREW__ = 0; | |
| $404 = $403 & 1; | |
| if ($404) { | |
| $415 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $416 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($8), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i434 = $416; | |
| $$12$i433 = $415; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($7 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($402 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($7 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($402 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($7 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($402 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i14$i430 = 0; | |
| while (1) { | |
| $exitcond$i$i$i15$i431 = ($__i$0$i$i$i14$i430 | 0) == 3; | |
| if ($exitcond$i$i$i15$i431) { | |
| break; | |
| } | |
| $405 = $402 + ($__i$0$i$i$i14$i430 << 2) | 0; | |
| SAFE_HEAP_STORE($405 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $406 = $__i$0$i$i$i14$i430 + 1 | 0; | |
| $__i$0$i$i$i14$i430 = $406; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($6, $7), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($372, $6), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($6), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($7), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($8), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($9), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($10), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($11), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($expr$i413), asyncState ? abort(-12) | 0 : 0; | |
| $$06$i441 = $356; | |
| break L1377; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($9), asyncState ? abort(-12) | 0 : 0; | |
| $$2$i436 = $$1$i434; | |
| $$23$i435 = $$12$i433; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($10), asyncState ? abort(-12) | 0 : 0; | |
| $$3$i438 = $$2$i436; | |
| $$34$i437 = $$23$i435; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($11), asyncState ? abort(-12) | 0 : 0; | |
| $$4$i440 = $$3$i438; | |
| $$45$i439 = $$34$i437; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($expr$i413), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$45$i439 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } | |
| } else { | |
| $$06$i441 = $first; | |
| } | |
| } else { | |
| $$06$i441 = $first; | |
| } | |
| } else { | |
| $$06$i441 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$06$i441; | |
| break L1; | |
| break; | |
| } | |
| case 108: | |
| { | |
| do { | |
| if ($146) { | |
| $417 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $418 = $417 << 24 >> 24 == 99; | |
| if ($418) { | |
| $419 = $first + 1 | 0; | |
| $420 = (tempInt = SAFE_HEAP_LOAD($419 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $421 = $420 << 24 >> 24 == 108; | |
| if ($421) { | |
| $422 = $first + 2 | 0; | |
| $423 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($422, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $424 = ($423 | 0) == ($422 | 0); | |
| $425 = ($423 | 0) == ($last | 0); | |
| $or$cond5$i = $424 | $425; | |
| if ($or$cond5$i) { | |
| $$2$i412 = $first; | |
| } else { | |
| $426 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $427 = $db + 4 | 0; | |
| $428 = (tempInt = SAFE_HEAP_LOAD($427 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $429 = ($426 | 0) == ($428 | 0); | |
| if ($429) { | |
| $$2$i412 = $first; | |
| } else { | |
| $430 = $428 + -24 | 0; | |
| $431 = $428 + -12 | 0; | |
| $432 = (tempInt = SAFE_HEAP_LOAD($431 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $433 = $432 & 1; | |
| $434 = $433 << 24 >> 24 == 0; | |
| if ($434) { | |
| $439 = $431 + 1 | 0; | |
| $440 = $432 & 255; | |
| $441 = $440 >>> 1; | |
| $442 = $439; | |
| $443 = $441; | |
| } else { | |
| $435 = $428 + -4 | 0; | |
| $436 = (tempInt = SAFE_HEAP_LOAD($435 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $437 = $428 + -8 | 0; | |
| $438 = (tempInt = SAFE_HEAP_LOAD($437 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $442 = $436; | |
| $443 = $438; | |
| } | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKcj($430, $442, $443) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $444 = (tempInt = SAFE_HEAP_LOAD($427 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $__i$0$i$i$i381 = 0; | |
| while (1) { | |
| $exitcond$i$i$i382 = ($__i$0$i$i$i381 | 0) == 3; | |
| if ($exitcond$i$i$i382) { | |
| break; | |
| } | |
| $445 = $12 + ($__i$0$i$i$i381 << 2) | 0; | |
| SAFE_HEAP_STORE($445 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $446 = $__i$0$i$i$i381 + 1 | 0; | |
| $__i$0$i$i$i381 = $446; | |
| } | |
| $447 = $444 + -12 | 0; | |
| $448 = (tempInt = SAFE_HEAP_LOAD($447 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $449 = $448 & 1; | |
| $450 = $449 << 24 >> 24 == 0; | |
| do { | |
| if ($450) { | |
| $451 = $447 + 1 | 0; | |
| SAFE_HEAP_STORE($451 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($447 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $452 = $444 + -4 | 0; | |
| $453 = (tempInt = SAFE_HEAP_LOAD($452 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($453 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $454 = $444 + -8 | 0; | |
| SAFE_HEAP_STORE($454 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i$i$i385 = (tempInt = SAFE_HEAP_LOAD($447 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $455 = $$pre$i$i$i$i385 & 1; | |
| $456 = $455 << 24 >> 24 == 0; | |
| if ($456) { | |
| $461 = $$pre$i$i$i$i385; | |
| $470 = 10; | |
| } else { | |
| $457 = (tempInt = SAFE_HEAP_LOAD($447 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $458 = $457 & -2; | |
| $phitmp$i$i$i$i$i$i$i387 = $458 + -1 | 0; | |
| $459 = $457 & 255; | |
| $461 = $459; | |
| $470 = $phitmp$i$i$i$i$i$i$i387; | |
| } | |
| $460 = $461 & 1; | |
| $462 = $460 << 24 >> 24 == 0; | |
| if ($462) { | |
| $463 = $461 & 255; | |
| $464 = $463 >>> 1; | |
| $465 = ($461 & 255) < 22; | |
| if ($465) { | |
| $2327 = 1; | |
| $469 = 10; | |
| $489 = $464; | |
| } else { | |
| $466 = $464 + 16 | 0; | |
| $467 = $466 & 240; | |
| $phitmp$i2$i$i$i$i$i$i390 = $467 + -1 | 0; | |
| $2327 = 1; | |
| $469 = $phitmp$i2$i$i$i$i$i$i390; | |
| $489 = $464; | |
| } | |
| } else { | |
| $2327 = 0; | |
| $469 = 10; | |
| $489 = 0; | |
| } | |
| $468 = ($469 | 0) == ($470 | 0); | |
| if (!$468) { | |
| $471 = ($469 | 0) == 10; | |
| if ($471) { | |
| $476 = $447 + 1 | 0; | |
| $477 = (tempInt = SAFE_HEAP_LOAD($452 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2327) { | |
| $478 = $461 & 255; | |
| $479 = $478 >>> 1; | |
| $480 = $479 + 1 | 0; | |
| (tempInt = _memcpy($476 | 0, $477 | 0, $480 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($477), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $485 = (tempInt = SAFE_HEAP_LOAD($477 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($476 >> 0 | 0, $485 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($477), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $490 = $489 << 1; | |
| $491 = $490 & 255; | |
| SAFE_HEAP_STORE($447 >> 0 | 0, $491 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $472 = $469 >>> 0 <= $470 >>> 0; | |
| $473 = $469 + 1 | 0; | |
| $474 = (tempInt = _malloc($473) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $475 = ($474 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i$i392 = $472 & $475; | |
| if (!$or$cond$i$i$i$i$i$i392) { | |
| if ($2327) { | |
| $481 = $447 + 1 | 0; | |
| $482 = $461 & 255; | |
| $483 = $482 >>> 1; | |
| $484 = $483 + 1 | 0; | |
| (tempInt = _memcpy($474 | 0, $481 | 0, $484 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } else { | |
| $486 = (tempInt = SAFE_HEAP_LOAD($452 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $487 = (tempInt = SAFE_HEAP_LOAD($486 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($474 >> 0 | 0, $487 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($486), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $488 = $473 | 1; | |
| SAFE_HEAP_STORE($447 | 0, $488 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($454 | 0, $489 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($452 | 0, $474 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($447 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($12 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($447 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($12 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($447 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($12 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i$i400 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i$i401 = ($__i$0$i$i$i$i$i400 | 0) == 3; | |
| if ($exitcond$i$i$i$i$i401) { | |
| break; | |
| } | |
| $492 = $12 + ($__i$0$i$i$i$i$i400 << 2) | 0; | |
| SAFE_HEAP_STORE($492 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $493 = $__i$0$i$i$i$i$i400 + 1 | 0; | |
| $__i$0$i$i$i$i$i400 = $493; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($12), asyncState ? abort(-12) | 0 : 0; | |
| $494 = (tempInt = SAFE_HEAP_LOAD($427 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $495 = $494 + -24 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($495, 2768) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $496 = $tmp$i379 + 1 | 0; | |
| $497 = $tmp$i379 + 8 | 0; | |
| $498 = $tmp$i379 + 4 | 0; | |
| $t$0$i403 = $423; | |
| while (1) { | |
| $499 = (tempInt = SAFE_HEAP_LOAD($t$0$i403 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $500 = $499 << 24 >> 24 == 69; | |
| if ($500) { | |
| $t$0$i403$lcssa = $t$0$i403; | |
| label = 195; | |
| break; | |
| } | |
| $501 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($t$0$i403, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $502 = ($501 | 0) == ($t$0$i403 | 0); | |
| $503 = ($501 | 0) == ($last | 0); | |
| $or$cond$i405 = $502 | $503; | |
| if ($or$cond$i405) { | |
| label = 197; | |
| break; | |
| } | |
| $504 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $505 = (tempInt = SAFE_HEAP_LOAD($427 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $506 = ($504 | 0) == ($505 | 0); | |
| if ($506) { | |
| label = 197; | |
| break; | |
| } | |
| $507 = $505 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($tmp$i379, $507), asyncState ? abort(-12) | 0 : 0; | |
| $508 = (tempInt = SAFE_HEAP_LOAD($427 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $509 = $508 + -24 | 0; | |
| $511 = $508; | |
| while (1) { | |
| $510 = ($511 | 0) == ($509 | 0); | |
| if ($510) { | |
| break; | |
| } | |
| $512 = $511 + -24 | 0; | |
| SAFE_HEAP_STORE($427 | 0, $512 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($512), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i406 = (tempInt = SAFE_HEAP_LOAD($427 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $511 = $$pre$i$i406; | |
| } | |
| $513 = (tempInt = SAFE_HEAP_LOAD($tmp$i379 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $514 = $513 & 1; | |
| $515 = $514 << 24 >> 24 == 0; | |
| if ($515) { | |
| $517 = $513 & 255; | |
| $518 = $517 >>> 1; | |
| $520 = $518; | |
| } else { | |
| $516 = (tempInt = SAFE_HEAP_LOAD($498 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $520 = $516; | |
| } | |
| $519 = ($520 | 0) == 0; | |
| if (!$519) { | |
| $521 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $522 = ($521 | 0) == ($509 | 0); | |
| if ($522) { | |
| label = 194; | |
| break; | |
| } | |
| $525 = $508 + -48 | 0; | |
| if ($515) { | |
| $528 = $513 & 255; | |
| $529 = $528 >>> 1; | |
| $530 = $496; | |
| $531 = $529; | |
| } else { | |
| $526 = (tempInt = SAFE_HEAP_LOAD($497 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $527 = (tempInt = SAFE_HEAP_LOAD($498 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $530 = $526; | |
| $531 = $527; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiii(3, $525 | 0, $530 | 0, $531 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $532 = __THREW__; | |
| __THREW__ = 0; | |
| $533 = $532 & 1; | |
| if ($533) { | |
| label = 188; | |
| break; | |
| } | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($tmp$i379), asyncState ? abort(-12) | 0 : 0; | |
| $t$0$i403 = $501; | |
| } | |
| if ((label | 0) == 188) { | |
| $523 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $524 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($tmp$i379), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($523 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } else if ((label | 0) == 194) { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($tmp$i379), asyncState ? abort(-12) | 0 : 0; | |
| $$2$i412 = $first; | |
| break; | |
| } else if ((label | 0) == 195) { | |
| $534 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $535 = (tempInt = SAFE_HEAP_LOAD($427 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $536 = ($534 | 0) == ($535 | 0); | |
| if ($536) { | |
| $$2$i412 = $first; | |
| break; | |
| } | |
| $537 = $t$0$i403$lcssa + 1 | 0; | |
| $538 = $535 + -24 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($538, 2760) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $$2$i412 = $537; | |
| break; | |
| } else if ((label | 0) == 197) { | |
| $$2$i412 = $first; | |
| break; | |
| } | |
| } | |
| } | |
| } else { | |
| $$2$i412 = $first; | |
| } | |
| } else { | |
| $$2$i412 = $first; | |
| } | |
| } else { | |
| $$2$i412 = $first; | |
| } | |
| } while (0); | |
| $$0 = $$2$i412; | |
| break L1; | |
| break; | |
| } | |
| case 109: | |
| { | |
| $539 = $first + 2 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($79, 2920, 1), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $540 = (tempInt = invoke_iiiii(21, $539 | 0, $last | 0, $79 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $541 = __THREW__; | |
| __THREW__ = 0; | |
| $542 = $541 & 1; | |
| if ($542) { | |
| $544 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $545 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($79), asyncState ? abort(-12) | 0 : 0; | |
| $$23 = $544; | |
| $$2332 = $545; | |
| break L7; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($79), asyncState ? abort(-12) | 0 : 0; | |
| $543 = ($540 | 0) == ($539 | 0); | |
| $first$37 = $543 ? $first : $540; | |
| $$0 = $first$37; | |
| break L1; | |
| } | |
| break; | |
| } | |
| default: | |
| { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| } | |
| break; | |
| } | |
| default: | |
| { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| } | |
| } while (0); | |
| ___resumeException($$23 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $$0 = $first; | |
| } | |
| } while (0); | |
| STACKTOP = sp; | |
| return $$0 | 0; | |
| } | |
| function __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($first, $last, $db) { | |
| $first = $first | 0; | |
| $last = $last | 0; | |
| $db = $db | 0; | |
| var $$ = 0, $$$$i$i$i$i = 0, $$$$i$i$i$i234 = 0, $$$i$i$i$i = 0, $$$i$i$i$i234 = 0, $$0 = 0, $$0$i = 0, $$0$i$i = 0, $$0$i$i$i = 0, $$0$i$i$i$i = 0, $$0$i$i$i103 = 0, $$0$i$i$i111 = 0, $$0$i$i$i119 = 0, $$0$i$i$i128 = 0, $$0$i$i$i138 = 0, $$0$i$i$i155 = 0, $$0$i$i$i165 = 0, $$0$i$i$i181 = 0, $$0$i$i$i19 = 0, $$0$i$i$i191 = 0, $$0$i$i$i199 = 0, $$0$i$i$i214 = 0, $$0$i$i$i222 = 0, $$0$i$i$i258 = 0, $$0$i$i$i27 = 0, $$0$i$i$i272 = 0, $$0$i$i$i34 = 0, $$0$i$i$i37 = 0, $$0$i$i$i42 = 0, $$0$i$i$i53 = 0, $$0$i$i$i61 = 0, $$0$i$i$i71 = 0, $$0$i$i$i79 = 0, $$0$i$i$i87 = 0, $$0$i$i$i95 = 0, $$01$i$i = 0, $$01$i280 = 0, $$02 = 0, $$02$i = 0, $$03 = 0, $$03$i$i = 0, $$04$i = 0, $$04$i316 = 0, $$05$i = 0, $$07$i = 0, $$08$i = 0, $$1$i = 0, $$1$i$i = 0, $$1$i281 = 0, $$1$i349 = 0, $$10 = 0, $$1013 = 0, $$12$i = 0, $$12$i$i = 0, $$13$i = 0, $$13$i345$ph = 0, $$14$i$i = 0, $$15$i = 0, $$18$i = 0, $$2 = 0, $$2$i = 0, $$2$i$i = 0, $$23$i = 0, $$25 = 0, $$26$i = 0, $$29$i = 0, $$3$i = 0, $$3$i321 = 0, $$310$i = 0, $$35$i = 0, $$4 = 0, $$4$i = 0, $$4$i305 = 0, $$4$i344 = 0, $$411$i = 0, $$45$i = 0, $$46$i = 0, $$47 = 0, $$5 = 0, $$5$i = 0, $$5$i306 = 0, $$5$i347 = 0, $$512$i = 0, $$56$i = 0, $$57$i = 0, $$58 = 0, $$6 = 0, $$6$i = 0, $$6$i307 = 0, $$6$i350 = 0, $$613$i = 0, $$67$i = 0, $$68$i = 0, $$69 = 0, $$7 = 0, $$710 = 0, $$8 = 0, $$811 = 0, $$9 = 0, $$912 = 0, $$in = 0, $$lcssa = 0, $$lcssa574 = 0, $$lcssa578 = 0, $$lcssa580 = 0, $$lcssa583 = 0, $$lcssa585 = 0, $$lcssa587 = 0, $$lcssa590 = 0, $$lcssa592 = 0, $$lcssa594 = 0, $$lcssa597 = 0, $$lcssa599 = 0, $$lcssa601 = 0, $$lcssa604 = 0, $$lcssa606 = 0, $$lcssa608 = 0, $$lcssa611 = 0, $$lcssa613 = 0, $$off = 0, $$off364 = 0, $$ph493 = 0, $$pn = 0, $$pre = 0, $$pre$i = 0, $$pre$i$i = 0, $$pre$i$i$i$i = 0, $$pre$i$i$i$i285 = 0, $$pre$i$i$i21$i = 0, $$pre$i$i$i42$i = 0, $$pre$i$i$i53$i = 0, $$pre$i$i$i72$i = 0, $$pre$i$i261 = 0, $$pre$i$i282 = 0, $$pre$i$i320 = 0, $$pre$i101 = 0, $$pre$i109 = 0, $$pre$i117 = 0, $$pre$i125 = 0, $$pre$i136 = 0, $$pre$i152 = 0, $$pre$i163 = 0, $$pre$i17 = 0, $$pre$i178 = 0, $$pre$i189 = 0, $$pre$i196 = 0, $$pre$i206 = 0, $$pre$i212 = 0, $$pre$i220 = 0, $$pre$i227 = 0, $$pre$i239 = 0, $$pre$i25 = 0, $$pre$i257 = 0, $$pre$i27$i = 0, $$pre$i33 = 0, $$pre$i36 = 0, $$pre$i40 = 0, $$pre$i48 = 0, $$pre$i49 = 0, $$pre$i51 = 0, $$pre$i58 = 0, $$pre$i69 = 0, $$pre$i7$i = 0, $$pre$i77 = 0, $$pre$i85 = 0, $$pre$i93 = 0, $$sum$i = 0, $$sum$i$i = 0, $$sum1$i$i = 0, $0 = 0, $1 = 0, $10 = 0, $100 = 0, $1000 = 0, $1001 = 0, $1002 = 0, $1003 = 0, $1004 = 0, $1005 = 0, $1006 = 0, $1007 = 0, $1008 = 0, $1009 = 0, $101 = 0, $1010 = 0, $1011 = 0, $1012 = 0, $1013 = 0, $1014 = 0, $1015 = 0, $1016 = 0, $1017 = 0, $1018 = 0, $1019 = 0, $102 = 0, $1020 = 0, $1021 = 0, $1022 = 0, $1023 = 0, $1024 = 0, $1025 = 0, $1026 = 0, $1027 = 0, $1028 = 0, $1029 = 0, $103 = 0, $1030 = 0, $1031 = 0, $1032 = 0, $1033 = 0, $1034 = 0, $1035 = 0, $1036 = 0, $1037 = 0, $1038 = 0, $1039 = 0, $104 = 0, $1040 = 0, $1041 = 0, $1042 = 0, $1043 = 0, $1044 = 0, $1045 = 0, $1046 = 0, $1047 = 0, $1048 = 0, $1049 = 0, $105 = 0, $1050 = 0, $1051 = 0, $1052 = 0, $1053 = 0, $1054 = 0, $1055 = 0, $1056 = 0, $1057 = 0, $1058 = 0, $1059 = 0, $106 = 0, $1060 = 0, $1061 = 0, $1062 = 0, $1063 = 0, $1064 = 0, $1065 = 0, $1066 = 0, $1067 = 0, $1068 = 0, $1069 = 0, $107 = 0, $1070 = 0, $1071 = 0, $1072 = 0, $1073 = 0, $1074 = 0, $1075 = 0, $1076 = 0, $1077 = 0, $1078 = 0, $1079 = 0, $108 = 0, $1080 = 0, $1081 = 0, $1082 = 0, $1083 = 0, $1084 = 0, $1085 = 0, $1086 = 0, $1087 = 0, $1088 = 0, $1089 = 0, $109 = 0, $1090 = 0, $1091 = 0, $1092 = 0, $1093 = 0, $1094 = 0, $1095 = 0, $1096 = 0, $1097 = 0, $1098 = 0, $1099 = 0, $11 = 0, $110 = 0, $1100 = 0, $1101 = 0, $1102 = 0, $1103 = 0, $1104 = 0, $1105 = 0, $1106 = 0, $1107 = 0, $1108 = 0, $1109 = 0, $111 = 0, $1110 = 0, $1111 = 0, $1112 = 0, $1113 = 0, $1114 = 0, $1115 = 0, $1116 = 0, $1117 = 0, $1118 = 0, $1119 = 0, $112 = 0, $1120 = 0, $1121 = 0, $1122 = 0, $1123 = 0, $1124 = 0, $1125 = 0, $1126 = 0, $1127 = 0, $1128 = 0, $1129 = 0, $113 = 0, $1130 = 0, $1131 = 0, $1132 = 0, $1133 = 0, $1134 = 0, $1135 = 0, $1136 = 0, $1137 = 0, $1138 = 0, $1139 = 0, $114 = 0, $1140 = 0, $1141 = 0, $1142 = 0, $1143 = 0, $1144 = 0, $1145 = 0, $1146 = 0, $1147 = 0, $1148 = 0, $1149 = 0, $115 = 0, $1150 = 0, $1151 = 0, $1152 = 0, $1153 = 0, $1154 = 0, $1155 = 0, $1156 = 0, $1157 = 0, $1158 = 0, $1159 = 0, $116 = 0, $1160 = 0, $1161 = 0, $1162 = 0, $1163 = 0, $1164 = 0, $1165 = 0, $1166 = 0, $1167 = 0, $1168 = 0, $1169 = 0, $117 = 0, $1170 = 0, $1171 = 0, $1172 = 0, $1173 = 0, $1174 = 0, $1175 = 0, $1176 = 0, $1177 = 0, $1178 = 0, $1179 = 0, $118 = 0, $1180 = 0, $1181 = 0, $1182 = 0, $1183 = 0, $1184 = 0, $1185 = 0, $1186 = 0, $1187 = 0, $1188 = 0, $1189 = 0, $119 = 0, $1190 = 0, $1191 = 0, $1192 = 0, $1193 = 0, $1194 = 0, $1195 = 0, $1196 = 0, $1197 = 0, $1198 = 0, $1199 = 0, $12 = 0, $120 = 0, $1200 = 0, $1201 = 0, $1202 = 0, $1203 = 0, $1204 = 0, $1205 = 0, $1206 = 0, $1207 = 0, $1208 = 0, $1209 = 0, $121 = 0, $1210 = 0, $1211 = 0, $1212 = 0, $1213 = 0, $1214 = 0, $1215 = 0, $1216 = 0, $1217 = 0, $1218 = 0, $1219 = 0, $122 = 0, $1220 = 0, $1221 = 0, $1222 = 0, $1223 = 0, $1224 = 0, $1225 = 0, $1226 = 0, $1227 = 0, $1228 = 0, $1229 = 0, $123 = 0, $1230 = 0, $1231 = 0, $1232 = 0, $1233 = 0, $1234 = 0, $1235 = 0, $1236 = 0, $1237 = 0, $1238 = 0, $1239 = 0, $124 = 0, $1240 = 0, $1241 = 0, $1242 = 0, $1243 = 0, $1244 = 0, $1245 = 0, $1246 = 0, $1247 = 0, $1248 = 0, $1249 = 0, $125 = 0, $1250 = 0, $1251 = 0, $1252 = 0, $1253 = 0, $1254 = 0, $1255 = 0, $1256 = 0, $1257 = 0, $1258 = 0, $1259 = 0, $126 = 0, $1260 = 0, $1261 = 0, $1262 = 0, $1263 = 0, $1264 = 0, $1265 = 0, $1266 = 0, $1267 = 0, $1268 = 0, $1269 = 0, $127 = 0, $1270 = 0, $1271 = 0, $1272 = 0, $1273 = 0, $1274 = 0, $1275 = 0, $1276 = 0, $1277 = 0, $1278 = 0, $1279 = 0, $128 = 0, $1280 = 0, $1281 = 0, $1282 = 0, $1283 = 0, $1284 = 0, $1285 = 0, $1286 = 0, $1287 = 0, $1288 = 0, $1289 = 0, $129 = 0, $1290 = 0, $1291 = 0, $1292 = 0, $1293 = 0, $1294 = 0, $1295 = 0, $1296 = 0, $1297 = 0, $1298 = 0, $1299 = 0, $13 = 0, $130 = 0, $1300 = 0, $1301 = 0, $1302 = 0, $1303 = 0, $1304 = 0, $1305 = 0, $1306 = 0, $1307 = 0, $1308 = 0, $1309 = 0, $131 = 0, $1310 = 0, $1311 = 0, $1312 = 0, $1313 = 0, $1314 = 0, $1315 = 0, $1316 = 0, $1317 = 0, $1318 = 0, $1319 = 0, $132 = 0, $1320 = 0, $1321 = 0, $1322 = 0, $1323 = 0, $1324 = 0, $1325 = 0, $1326 = 0, $1327 = 0, $1328 = 0, $1329 = 0, $133 = 0, $1330 = 0, $1331 = 0, $1332 = 0, $1333 = 0, $1334 = 0, $1335 = 0, $1336 = 0, $1337 = 0, $1338 = 0, $1339 = 0, $134 = 0, $1340 = 0, $1341 = 0, $1342 = 0, $1343 = 0, $1344 = 0, $1345 = 0, $1346 = 0, $1347 = 0, $1348 = 0, $1349 = 0, $135 = 0, $1350 = 0, $1351 = 0, $1352 = 0, $1353 = 0, $1354 = 0, $1355 = 0, $1356 = 0, $1357 = 0, $1358 = 0, $1359 = 0, $136 = 0, $1360 = 0, $1361 = 0, $1362 = 0, $1363 = 0, $1364 = 0, $1365 = 0, $1366 = 0, $1367 = 0, $1368 = 0, $1369 = 0, $137 = 0, $1370 = 0, $1371 = 0, $1372 = 0, $1373 = 0, $1374 = 0, $1375 = 0, $1376 = 0, $1377 = 0, $1378 = 0, $1379 = 0, $138 = 0, $1380 = 0, $1381 = 0, $1382 = 0, $1383 = 0, $1384 = 0, $1385 = 0, $1386 = 0, $1387 = 0, $1388 = 0, $1389 = 0, $139 = 0, $1390 = 0, $1391 = 0, $1392 = 0, $1393 = 0, $1394 = 0, $1395 = 0, $1396 = 0, $1397 = 0, $1398 = 0, $1399 = 0, $14 = 0, $140 = 0, $1400 = 0, $1401 = 0, $1402 = 0, $1403 = 0, $1404 = 0, $1405 = 0, $1406 = 0, $1407 = 0, $1408 = 0, $1409 = 0, $141 = 0, $1410 = 0, $1411 = 0, $1412 = 0, $1413 = 0, $1414 = 0, $1415 = 0, $1416 = 0, $1417 = 0, $1418 = 0, $1419 = 0, $142 = 0, $1420 = 0, $1421 = 0, $1422 = 0, $1423 = 0, $1424 = 0, $1425 = 0, $1426 = 0, $1427 = 0, $1428 = 0, $1429 = 0, $143 = 0, $1430 = 0, $1431 = 0, $1432 = 0, $1433 = 0, $1434 = 0, $1435 = 0, $1436 = 0, $1437 = 0, $1438 = 0, $1439 = 0, $144 = 0, $1440 = 0, $1441 = 0, $1442 = 0, $1443 = 0, $1444 = 0, $1445 = 0, $1446 = 0, $1447 = 0, $1448 = 0, $1449 = 0, $145 = 0, $1450 = 0, $1451 = 0, $1452 = 0, $1453 = 0, $1454 = 0, $1455 = 0, $1456 = 0, $1457 = 0, $1458 = 0, $1459 = 0, $146 = 0, $1460 = 0, $1461 = 0, $1462 = 0, $1463 = 0, $1464 = 0, $1465 = 0, $1466 = 0, $1467 = 0, $1468 = 0, $1469 = 0, $147 = 0, $1470 = 0, $1471 = 0, $1472 = 0, $1473 = 0, $1474 = 0, $1475 = 0, $1476 = 0, $1477 = 0, $1478 = 0, $1479 = 0, $148 = 0, $1480 = 0, $1481 = 0, $1482 = 0, $1483 = 0, $1484 = 0, $1485 = 0, $1486 = 0, $1487 = 0, $1488 = 0, $1489 = 0, $149 = 0, $1490 = 0, $1491 = 0, $1492 = 0, $1493 = 0, $1494 = 0, $1495 = 0, $1496 = 0, $1497 = 0, $1498 = 0, $1499 = 0, $15 = 0, $150 = 0, $1500 = 0, $1501 = 0, $1502 = 0, $1503 = 0, $1504 = 0, $1505 = 0, $1506 = 0, $1507 = 0, $1508 = 0, $1509 = 0, $151 = 0, $1510 = 0, $1511 = 0, $1512 = 0, $1513 = 0, $1514 = 0, $1515 = 0, $1516 = 0, $1517 = 0, $1518 = 0, $1519 = 0, $152 = 0, $1520 = 0, $1521 = 0, $1522 = 0, $1523 = 0, $1524 = 0, $1525 = 0, $1526 = 0, $1527 = 0, $1528 = 0, $1529 = 0, $153 = 0, $1530 = 0, $1531 = 0, $1532 = 0, $1533 = 0, $1534 = 0, $1535 = 0, $1536 = 0, $1537 = 0, $1538 = 0, $1539 = 0, $154 = 0, $1540 = 0, $1541 = 0, $1542 = 0, $1543 = 0, $1544 = 0, $1545 = 0, $1546 = 0, $1547 = 0, $1548 = 0, $1549 = 0, $155 = 0, $1550 = 0, $1551 = 0, $1552 = 0, $1553 = 0, $1554 = 0, $1555 = 0, $1556 = 0, $1557 = 0, $1558 = 0, $1559 = 0, $156 = 0, $1560 = 0, $1561 = 0, $1562 = 0, $1563 = 0, $1564 = 0, $1565 = 0, $1566 = 0, $1567 = 0, $1568 = 0, $1569 = 0, $157 = 0, $1570 = 0, $1571 = 0, $1572 = 0, $1573 = 0, $1574 = 0, $1575 = 0, $1576 = 0, $1577 = 0, $1578 = 0, $1579 = 0, $158 = 0, $1580 = 0, $1581 = 0, $1582 = 0, $1583 = 0, $1584 = 0, $1585 = 0, $1586 = 0, $1587 = 0, $1588 = 0, $1589 = 0, $159 = 0, $1590 = 0, $1591 = 0, $1592 = 0, $1593 = 0, $1594 = 0, $1595 = 0, $1596 = 0, $1597 = 0, $1598 = 0, $1599 = 0, $16 = 0, $160 = 0, $1600 = 0, $1601 = 0, $1602 = 0, $1603 = 0, $1604 = 0, $1605 = 0, $1606 = 0, $1607 = 0, $1608 = 0, $1609 = 0, $161 = 0, $1610 = 0, $1611 = 0, $1612 = 0, $1613 = 0, $1614 = 0, $1615 = 0, $1616 = 0, $1617 = 0, $1618 = 0, $1619 = 0, $162 = 0, $1620 = 0, $1621 = 0, $1622 = 0, $1623 = 0, $1624 = 0, $1625 = 0, $1626 = 0, $1627 = 0, $1628 = 0, $1629 = 0, $163 = 0, $1630 = 0, $1631 = 0, $1632 = 0, $1633 = 0, $1634 = 0, $1635 = 0, $1636 = 0, $1637 = 0, $1638 = 0, $1639 = 0, $164 = 0, $1640 = 0, $1641 = 0, $1642 = 0, $1643 = 0, $1644 = 0, $1645 = 0, $1646 = 0, $1647 = 0, $1648 = 0, $1649 = 0, $165 = 0, $1650 = 0, $1651 = 0, $1652 = 0, $1653 = 0, $1654 = 0, $1655 = 0, $1656 = 0, $1657 = 0, $1658 = 0, $1659 = 0, $166 = 0, $1660 = 0, $1661 = 0, $1662 = 0, $1663 = 0, $1664 = 0, $1665 = 0, $1666 = 0, $1667 = 0, $1668 = 0, $1669 = 0, $167 = 0, $1670 = 0, $1671 = 0, $1672 = 0, $1673 = 0, $1674 = 0, $1675 = 0, $1676 = 0, $1677 = 0, $1678 = 0, $1679 = 0, $168 = 0, $1680 = 0, $1681 = 0, $1682 = 0, $1683 = 0, $1684 = 0, $1685 = 0, $1686 = 0, $1687 = 0, $1688 = 0, $1689 = 0, $169 = 0, $1690 = 0, $1691 = 0, $1692 = 0, $1693 = 0, $1694 = 0, $1695 = 0, $1696 = 0, $1697 = 0, $1698 = 0, $1699 = 0, $17 = 0, $170 = 0, $1700 = 0, $1701 = 0, $1702 = 0, $1703 = 0, $1704 = 0, $1705 = 0, $1706 = 0, $1707 = 0, $1708 = 0, $1709 = 0, $171 = 0, $1710 = 0, $1711 = 0, $1712 = 0, $1713 = 0, $1714 = 0, $1715 = 0, $1716 = 0, $1717 = 0, $1718 = 0, $1719 = 0, $172 = 0, $1720 = 0, $1721 = 0, $1722 = 0, $1723 = 0, $1724 = 0, $1725 = 0, $1726 = 0, $1727 = 0, $1728 = 0, $1729 = 0, $173 = 0, $1730 = 0, $1731 = 0, $1732 = 0, $1733 = 0, $1734 = 0, $1735 = 0, $1736 = 0, $1737 = 0, $1738 = 0, $1739 = 0, $174 = 0, $1740 = 0, $1741 = 0, $1742 = 0, $1743 = 0, $1744 = 0, $1745 = 0, $1746 = 0, $1747 = 0, $1748 = 0, $1749 = 0, $175 = 0, $1750 = 0, $1751 = 0, $1752 = 0, $1753 = 0, $1754 = 0, $1755 = 0, $1756 = 0, $1757 = 0, $1758 = 0, $1759 = 0, $176 = 0, $1760 = 0, $1761 = 0, $1762 = 0, $1763 = 0, $1764 = 0, $1765 = 0, $1766 = 0, $1767 = 0, $1768 = 0, $1769 = 0, $177 = 0, $1770 = 0, $1771 = 0, $1772 = 0, $1773 = 0, $1774 = 0, $1775 = 0, $1776 = 0, $1777 = 0, $1778 = 0, $1779 = 0, $178 = 0, $1780 = 0, $1781 = 0, $1782 = 0, $1783 = 0, $1784 = 0, $1785 = 0, $1786 = 0, $1787 = 0, $1788 = 0, $1789 = 0, $179 = 0, $1790 = 0, $1791 = 0, $1792 = 0, $1793 = 0, $1794 = 0, $1795 = 0, $1796 = 0, $1797 = 0, $1798 = 0, $1799 = 0, $18 = 0, $180 = 0, $1800 = 0, $1801 = 0, $1802 = 0, $1803 = 0, $1804 = 0, $1805 = 0, $1806 = 0, $1807 = 0, $1808 = 0, $1809 = 0, $181 = 0, $1810 = 0, $1811 = 0, $1812 = 0, $1813 = 0, $1814 = 0, $1815 = 0, $1816 = 0, $1817 = 0, $1818 = 0, $1819 = 0, $182 = 0, $1820 = 0, $1821 = 0, $1822 = 0, $1823 = 0, $1824 = 0, $1825 = 0, $1826 = 0, $1827 = 0, $1828 = 0, $1829 = 0, $183 = 0, $1830 = 0, $1831 = 0, $1832 = 0, $1833 = 0, $1834 = 0, $1835 = 0, $1836 = 0, $1837 = 0, $1838 = 0, $1839 = 0, $184 = 0, $1840 = 0, $1841 = 0, $1842 = 0, $1843 = 0, $1844 = 0, $1845 = 0, $1846 = 0, $1847 = 0, $1848 = 0, $1849 = 0, $185 = 0, $1850 = 0, $1851 = 0, $1852 = 0, $1853 = 0, $1854 = 0, $1855 = 0, $1856 = 0, $1857 = 0, $1858 = 0, $1859 = 0, $186 = 0, $1860 = 0, $1861 = 0, $1862 = 0, $1863 = 0, $1864 = 0, $1865 = 0, $1866 = 0, $1867 = 0, $1868 = 0, $1869 = 0, $187 = 0, $1870 = 0, $1871 = 0, $1872 = 0, $1873 = 0, $1874 = 0, $1875 = 0, $1876 = 0, $1877 = 0, $1878 = 0, $1879 = 0, $188 = 0, $1880 = 0, $1881 = 0, $1882 = 0, $1883 = 0, $1884 = 0, $1885 = 0, $1886 = 0, $1887 = 0, $1888 = 0, $1889 = 0, $189 = 0, $1890 = 0, $1891 = 0, $1892 = 0, $1893 = 0, $1894 = 0, $1895 = 0, $1896 = 0, $1897 = 0, $1898 = 0, $1899 = 0, $19 = 0, $190 = 0, $1900 = 0, $1901 = 0, $1902 = 0, $1903 = 0, $1904 = 0, $1905 = 0, $1906 = 0, $1907 = 0, $1908 = 0, $1909 = 0, $191 = 0, $1910 = 0, $1911 = 0, $1912 = 0, $1913 = 0, $1914 = 0, $1915 = 0, $1916 = 0, $1917 = 0, $1918 = 0, $1919 = 0, $192 = 0, $1920 = 0, $1921 = 0, $1922 = 0, $1923 = 0, $1924 = 0, $1925 = 0, $1926 = 0, $1927 = 0, $1928 = 0, $1929 = 0, $193 = 0, $1930 = 0, $1931 = 0, $1932 = 0, $1933 = 0, $1934 = 0, $1935 = 0, $1936 = 0, $1937 = 0, $1938 = 0, $1939 = 0, $194 = 0, $1940 = 0, $1941 = 0, $1942 = 0, $1943 = 0, $1944 = 0, $1945 = 0, $1946 = 0, $1947 = 0, $1948 = 0, $1949 = 0, $195 = 0, $1950 = 0, $1951 = 0, $1952 = 0, $1953 = 0, $1954 = 0, $1955 = 0, $1956 = 0, $1957 = 0, $1958 = 0, $1959 = 0, $196 = 0, $1960 = 0, $1961 = 0, $1962 = 0, $1963 = 0, $1964 = 0, $1965 = 0, $1966 = 0, $1967 = 0, $1968 = 0, $1969 = 0, $197 = 0, $1970 = 0, $1971 = 0, $1972 = 0, $1973 = 0, $1974 = 0, $1975 = 0, $1976 = 0, $1977 = 0, $1978 = 0, $1979 = 0, $198 = 0, $1980 = 0, $1981 = 0, $1982 = 0, $1983 = 0, $1984 = 0, $1985 = 0, $1986 = 0, $1987 = 0, $1988 = 0, $1989 = 0, $199 = 0, $1990 = 0, $1991 = 0, $1992 = 0, $1993 = 0, $1994 = 0, $1995 = 0, $1996 = 0, $1997 = 0, $1998 = 0, $1999 = 0, $2 = 0, $20 = 0, $200 = 0, $2000 = 0, $2001 = 0, $2002 = 0, $2003 = 0, $2004 = 0, $2005 = 0, $2006 = 0, $2007 = 0, $2008 = 0, $2009 = 0, $201 = 0, $2010 = 0, $2011 = 0, $2012 = 0, $2013 = 0, $2014 = 0, $2015 = 0, $2016 = 0, $2017 = 0, $2018 = 0, $2019 = 0, $202 = 0, $2020 = 0, $2021 = 0, $2022 = 0, $2023 = 0, $2024 = 0, $2025 = 0, $2026 = 0, $2027 = 0, $2028 = 0, $2029 = 0, $203 = 0, $2030 = 0, $2031 = 0, $2032 = 0, $2033 = 0, $2034 = 0, $2035 = 0, $2036 = 0, $2037 = 0, $2038 = 0, $2039 = 0, $204 = 0, $2040 = 0, $2041 = 0, $2042 = 0, $2043 = 0, $2044 = 0, $2045 = 0, $2046 = 0, $2047 = 0, $2048 = 0, $2049 = 0, $205 = 0, $2050 = 0, $2051 = 0, $2052 = 0, $2053 = 0, $2054 = 0, $2055 = 0, $2056 = 0, $2057 = 0, $2058 = 0, $2059 = 0, $206 = 0, $2060 = 0, $2061 = 0, $2062 = 0, $2063 = 0, $2064 = 0, $2065 = 0, $2066 = 0, $2067 = 0, $2068 = 0, $2069 = 0, $207 = 0, $2070 = 0, $2071 = 0, $2072 = 0, $2073 = 0, $2074 = 0, $2075 = 0, $2076 = 0, $2077 = 0, $2078 = 0, $2079 = 0, $208 = 0, $2080 = 0, $2081 = 0, $2082 = 0, $2083 = 0, $2084 = 0, $2085 = 0, $2086 = 0, $2087 = 0, $2088 = 0, $2089 = 0, $209 = 0, $2090 = 0, $2091 = 0, $2092 = 0, $2093 = 0, $2094 = 0, $2095 = 0, $2096 = 0, $2097 = 0, $2098 = 0, $2099 = 0, $21 = 0, $210 = 0, $2100 = 0, $2101 = 0, $2102 = 0, $2103 = 0, $2104 = 0, $2105 = 0, $2106 = 0, $2107 = 0, $2108 = 0, $2109 = 0, $211 = 0, $2110 = 0, $2111 = 0, $2112 = 0, $2113 = 0, $2114 = 0, $2115 = 0, $2116 = 0, $2117 = 0, $2118 = 0, $2119 = 0, $212 = 0, $2120 = 0, $2121 = 0, $2122 = 0, $2123 = 0, $2124 = 0, $2125 = 0, $2126 = 0, $2127 = 0, $2128 = 0, $2129 = 0, $213 = 0, $2130 = 0, $2131 = 0, $2132 = 0, $2133 = 0, $2134 = 0, $2135 = 0, $2136 = 0, $2137 = 0, $2138 = 0, $2139 = 0, $214 = 0, $2140 = 0, $2141 = 0, $2142 = 0, $2143 = 0, $2144 = 0, $2145 = 0, $2146 = 0, $2147 = 0, $2148 = 0, $2149 = 0, $215 = 0, $2150 = 0, $2151 = 0, $2152 = 0, $2153 = 0, $2154 = 0, $2155 = 0, $2156 = 0, $2157 = 0, $2158 = 0, $2159 = 0, $216 = 0, $2160 = 0, $2161 = 0, $2162 = 0, $2163 = 0, $2164 = 0, $2165 = 0, $2166 = 0, $2167 = 0, $2168 = 0, $2169 = 0, $217 = 0, $2170 = 0, $2171 = 0, $2172 = 0, $2173 = 0, $2174 = 0, $2175 = 0, $2176 = 0, $2177 = 0, $2178 = 0, $2179 = 0, $218 = 0, $2180 = 0, $2181 = 0, $2182 = 0, $2183 = 0, $2184 = 0, $2185 = 0, $2186 = 0, $2187 = 0, $2188 = 0, $2189 = 0, $219 = 0, $2190 = 0, $2191 = 0, $2192 = 0, $2193 = 0, $2194 = 0, $2195 = 0, $2196 = 0, $2197 = 0, $2198 = 0, $2199 = 0, $22 = 0, $220 = 0, $2200 = 0, $2201 = 0, $2202 = 0, $2203 = 0, $2204 = 0, $2205 = 0, $2206 = 0, $2207 = 0, $2208 = 0, $2209 = 0, $221 = 0, $2210 = 0, $2211 = 0, $2212 = 0, $2213 = 0, $2214 = 0, $2215 = 0, $2216 = 0, $2217 = 0, $2218 = 0, $2219 = 0, $222 = 0, $2220 = 0, $2221 = 0, $2222 = 0, $2223 = 0, $2224 = 0, $2225 = 0, $2226 = 0, $2227 = 0, $2228 = 0, $2229 = 0, $223 = 0, $2230 = 0, $2231 = 0, $2232 = 0, $2233 = 0, $2234 = 0, $2235 = 0, $2236 = 0, $2237 = 0, $2238 = 0, $2239 = 0, $224 = 0, $2240 = 0, $2241 = 0, $2242 = 0, $2243 = 0, $2244 = 0, $2245 = 0, $2246 = 0, $2247 = 0, $2248 = 0, $2249 = 0, $225 = 0, $2250 = 0, $2251 = 0, $2252 = 0, $2253 = 0, $2254 = 0, $2255 = 0, $2256 = 0, $2257 = 0, $2258 = 0, $2259 = 0, $226 = 0, $2260 = 0, $2261 = 0, $2262 = 0, $2263 = 0, $2264 = 0, $2265 = 0, $2266 = 0, $2267 = 0, $2268 = 0, $2269 = 0, $227 = 0, $2270 = 0, $2271 = 0, $2272 = 0, $2273 = 0, $2274 = 0, $2275 = 0, $2276 = 0, $2277 = 0, $2278 = 0, $2279 = 0, $228 = 0, $2280 = 0, $2281 = 0, $2282 = 0, $2283 = 0, $2284 = 0, $2285 = 0, $2286 = 0, $2287 = 0, $2288 = 0, $2289 = 0, $229 = 0, $2290 = 0, $2291 = 0, $2292 = 0, $2293 = 0, $2294 = 0, $2295 = 0, $2296 = 0, $2297 = 0, $2298 = 0, $2299 = 0, $23 = 0, $230 = 0, $2300 = 0, $2301 = 0, $2302 = 0, $2303 = 0, $2304 = 0, $2305 = 0, $2306 = 0, $2307 = 0, $2308 = 0, $2309 = 0, $231 = 0, $2310 = 0, $2311 = 0, $2312 = 0, $2313 = 0, $2314 = 0, $2315 = 0, $2316 = 0, $2317 = 0, $2318 = 0, $2319 = 0, $232 = 0, $2320 = 0, $2321 = 0, $2322 = 0, $2323 = 0, $2324 = 0, $2325 = 0, $2326 = 0, $2327 = 0, $2328 = 0, $2329 = 0, $233 = 0, $2330 = 0, $2331 = 0, $2332 = 0, $2333 = 0, $2334 = 0, $2335 = 0, $2336 = 0, $2337 = 0, $2338 = 0, $2339 = 0, $234 = 0, $2340 = 0, $2341 = 0, $2342 = 0, $2343 = 0, $2344 = 0, $2345 = 0, $2346 = 0, $2347 = 0, $2348 = 0, $2349 = 0, $235 = 0, $2350 = 0, $2351 = 0, $2352 = 0, $2353 = 0, $2354 = 0, $2355 = 0, $2356 = 0, $2357 = 0, $2358 = 0, $2359 = 0, $236 = 0, $2360 = 0, $2361 = 0, $2362 = 0, $2363 = 0, $2364 = 0, $2365 = 0, $2366 = 0, $2367 = 0, $2368 = 0, $2369 = 0, $237 = 0, $2370 = 0, $2371 = 0, $2372 = 0, $2373 = 0, $2374 = 0, $2375 = 0, $2376 = 0, $2377 = 0, $2378 = 0, $2379 = 0, $238 = 0, $2380 = 0, $2381 = 0, $2382 = 0, $2383 = 0, $2384 = 0, $2385 = 0, $2386 = 0, $2387 = 0, $2388 = 0, $2389 = 0, $239 = 0, $2390 = 0, $2391 = 0, $2392 = 0, $2393 = 0, $2394 = 0, $2395 = 0, $2396 = 0, $2397 = 0, $2398 = 0, $2399 = 0, $24 = 0, $240 = 0, $2400 = 0, $2401 = 0, $2402 = 0, $2403 = 0, $2404 = 0, $2405 = 0, $2406 = 0, $2407 = 0, $2408 = 0, $2409 = 0, $241 = 0, $2410 = 0, $2411 = 0, $2412 = 0, $2413 = 0, $2414 = 0, $2415 = 0, $2416 = 0, $2417 = 0, $2418 = 0, $2419 = 0, $242 = 0, $2420 = 0, $2421 = 0, $2422 = 0, $2423 = 0, $2424 = 0, $2425 = 0, $2426 = 0, $2427 = 0, $2428 = 0, $2429 = 0, $243 = 0, $2430 = 0, $2431 = 0, $2432 = 0, $2433 = 0, $2434 = 0, $2435 = 0, $2436 = 0, $2437 = 0, $2438 = 0, $2439 = 0, $244 = 0, $2440 = 0, $2441 = 0, $2442 = 0, $2443 = 0, $2444 = 0, $2445 = 0, $2446 = 0, $2447 = 0, $2448 = 0, $2449 = 0, $245 = 0, $2450 = 0, $2451 = 0, $2452 = 0, $2453 = 0, $2454 = 0, $2455 = 0, $2456 = 0, $2457 = 0, $2458 = 0, $2459 = 0, $246 = 0, $2460 = 0, $2461 = 0, $2462 = 0, $2463 = 0, $2464 = 0, $2465 = 0, $2466 = 0, $2467 = 0, $2468 = 0, $2469 = 0, $247 = 0, $2470 = 0, $2471 = 0, $2472 = 0, $2473 = 0, $2474 = 0, $2475 = 0, $2476 = 0, $2477 = 0, $2478 = 0, $2479 = 0, $248 = 0, $2480 = 0, $2481 = 0, $2482 = 0, $2483 = 0, $2484 = 0, $2485 = 0, $2486 = 0, $2487 = 0, $2488 = 0, $2489 = 0, $249 = 0, $2490 = 0, $2491 = 0, $2492 = 0, $2493 = 0, $2494 = 0, $2495 = 0, $2496 = 0, $2497 = 0, $2498 = 0, $2499 = 0, $25 = 0, $250 = 0, $2500 = 0, $2501 = 0, $2502 = 0, $2503 = 0, $2504 = 0, $2505 = 0, $2506 = 0, $2507 = 0, $2508 = 0, $2509 = 0, $251 = 0, $2510 = 0, $2511 = 0, $2512 = 0, $2513 = 0, $2514 = 0, $2515 = 0, $2516 = 0, $2517 = 0, $2518 = 0, $2519 = 0, $252 = 0, $2520 = 0, $2521 = 0, $2522 = 0, $2523 = 0, $2524 = 0, $2525 = 0, $2526 = 0, $2527 = 0, $2528 = 0, $2529 = 0, $253 = 0, $2530 = 0, $2531 = 0, $2532 = 0, $2533 = 0, $2534 = 0, $2535 = 0, $2536 = 0, $2537 = 0, $2538 = 0, $2539 = 0, $254 = 0, $2540 = 0, $2541 = 0, $2542 = 0, $2543 = 0, $2544 = 0, $2545 = 0, $2546 = 0, $2547 = 0, $2548 = 0, $2549 = 0, $255 = 0, $2550 = 0, $2551 = 0, $2552 = 0, $2553 = 0, $2554 = 0, $2555 = 0, $2556 = 0, $2557 = 0, $2558 = 0, $2559 = 0, $256 = 0, $2560 = 0, $2561 = 0, $2562 = 0, $2563 = 0, $2564 = 0, $2565 = 0, $2566 = 0, $2567 = 0, $2568 = 0, $2569 = 0, $257 = 0, $2570 = 0, $2571 = 0, $2572 = 0, $2573 = 0, $2574 = 0, $2575 = 0, $2576 = 0, $2577 = 0, $2578 = 0, $2579 = 0, $258 = 0, $2580 = 0, $2581 = 0, $2582 = 0, $2583 = 0, $2584 = 0, $2585 = 0, $2586 = 0, $2587 = 0, $2588 = 0, $2589 = 0, $259 = 0, $2590 = 0, $2591 = 0, $2592 = 0, $2593 = 0, $2594 = 0, $2595 = 0, $2596 = 0, $2597 = 0, $2598 = 0, $2599 = 0, $26 = 0, $260 = 0, $2600 = 0, $2601 = 0, $2602 = 0, $2603 = 0, $2604 = 0, $2605 = 0, $2606 = 0, $2607 = 0, $2608 = 0, $2609 = 0, $261 = 0, $2610 = 0, $2611 = 0, $2612 = 0, $2613 = 0, $2614 = 0, $2615 = 0, $2616 = 0, $2617 = 0, $2618 = 0, $2619 = 0, $262 = 0, $2620 = 0, $2621 = 0, $2622 = 0, $2623 = 0, $2624 = 0, $2625 = 0, $2626 = 0, $2627 = 0, $2628 = 0, $2629 = 0, $263 = 0, $2630 = 0, $2631 = 0, $2632 = 0, $2633 = 0, $2634 = 0, $2635 = 0, $2636 = 0, $2637 = 0, $2638 = 0, $2639 = 0, $264 = 0, $2640 = 0, $2641 = 0, $2642 = 0, $2643 = 0, $2644 = 0, $2645 = 0, $2646 = 0, $2647 = 0, $2648 = 0, $2649 = 0, $265 = 0, $2650 = 0, $2651 = 0, $2652 = 0, $2653 = 0, $2654 = 0, $2655 = 0, $2656 = 0, $2657 = 0, $2658 = 0, $2659 = 0, $266 = 0, $2660 = 0, $2661 = 0, $2662 = 0, $2663 = 0, $2664 = 0, $2665 = 0, $2666 = 0, $2667 = 0, $2668 = 0, $2669 = 0, $267 = 0, $2670 = 0, $2671 = 0, $2672 = 0, $2673 = 0, $2674 = 0, $2675 = 0, $2676 = 0, $2677 = 0, $2678 = 0, $2679 = 0, $268 = 0, $2680 = 0, $2681 = 0, $2682 = 0, $2683 = 0, $2684 = 0, $2685 = 0, $2686 = 0, $2687 = 0, $2688 = 0, $2689 = 0, $269 = 0, $2690 = 0, $2691 = 0, $2692 = 0, $2693 = 0, $2694 = 0, $2695 = 0, $2696 = 0, $2697 = 0, $2698 = 0, $2699 = 0, $27 = 0, $270 = 0, $2700 = 0, $2701 = 0, $2702 = 0, $2703 = 0, $2704 = 0, $2705 = 0, $2706 = 0, $2707 = 0, $2708 = 0, $2709 = 0, $271 = 0, $2710 = 0, $2711 = 0, $2712 = 0, $2713 = 0, $2714 = 0, $2715 = 0, $2716 = 0, $2717 = 0, $2718 = 0, $2719 = 0, $272 = 0, $2720 = 0, $2721 = 0, $2722 = 0, $2723 = 0, $2724 = 0, $2725 = 0, $2726 = 0, $2727 = 0, $2728 = 0, $2729 = 0, $273 = 0, $2730 = 0, $2731 = 0, $2732 = 0, $2733 = 0, $2734 = 0, $2735 = 0, $2736 = 0, $2737 = 0, $2738 = 0, $2739 = 0, $274 = 0, $2740 = 0, $2741 = 0, $2742 = 0, $2743 = 0, $2744 = 0, $2745 = 0, $2746 = 0, $2747 = 0, $2748 = 0, $2749 = 0, $275 = 0, $2750 = 0, $2751 = 0, $2752 = 0, $2753 = 0, $2754 = 0, $2755 = 0, $2756 = 0, $2757 = 0, $2758 = 0, $2759 = 0, $276 = 0, $2760 = 0, $2761 = 0, $2762 = 0, $2763 = 0, $2764 = 0, $2765 = 0, $2766 = 0, $2767 = 0, $2768 = 0, $2769 = 0, $277 = 0, $2770 = 0, $2771 = 0, $2772 = 0, $2773 = 0, $2774 = 0, $2775 = 0, $2776 = 0, $2777 = 0, $2778 = 0, $2779 = 0, $278 = 0, $2780 = 0, $2781 = 0, $2782 = 0, $2783 = 0, $2784 = 0, $2785 = 0, $2786 = 0, $2787 = 0, $2788 = 0, $2789 = 0, $279 = 0, $2790 = 0, $2791 = 0, $2792 = 0, $2793 = 0, $2794 = 0, $2795 = 0, $2796 = 0, $2797 = 0, $2798 = 0, $2799 = 0, $28 = 0, $280 = 0, $2800 = 0, $2801 = 0, $2802 = 0, $2803 = 0, $2804 = 0, $2805 = 0, $2806 = 0, $2807 = 0, $2808 = 0, $2809 = 0, $281 = 0, $2810 = 0, $2811 = 0, $2812 = 0, $2813 = 0, $2814 = 0, $2815 = 0, $2816 = 0, $2817 = 0, $2818 = 0, $2819 = 0, $282 = 0, $2820 = 0, $2821 = 0, $2822 = 0, $2823 = 0, $2824 = 0, $2825 = 0, $2826 = 0, $2827 = 0, $2828 = 0, $2829 = 0, $283 = 0, $2830 = 0, $2831 = 0, $2832 = 0, $2833 = 0, $2834 = 0, $2835 = 0, $2836 = 0, $2837 = 0, $2838 = 0, $2839 = 0, $284 = 0, $2840 = 0, $2841 = 0, $2842 = 0, $2843 = 0, $2844 = 0, $2845 = 0, $2846 = 0, $2847 = 0, $2848 = 0, $2849 = 0, $285 = 0, $2850 = 0, $2851 = 0, $2852 = 0, $2853 = 0, $2854 = 0, $2855 = 0, $2856 = 0, $2857 = 0, $2858 = 0, $2859 = 0, $286 = 0, $2860 = 0, $2861 = 0, $2862 = 0, $2863 = 0, $2864 = 0, $2865 = 0, $2866 = 0, $2867 = 0, $2868 = 0, $2869 = 0, $287 = 0, $2870 = 0, $2871 = 0, $2872 = 0, $2873 = 0, $2874 = 0, $2875 = 0, $2876 = 0, $2877 = 0, $2878 = 0, $2879 = 0, $288 = 0, $2880 = 0, $2881 = 0, $2882 = 0, $2883 = 0, $2884 = 0, $2885 = 0, $2886 = 0, $2887 = 0, $2888 = 0, $2889 = 0, $289 = 0, $2890 = 0, $2891 = 0, $2892 = 0, $2893 = 0, $2894 = 0, $2895 = 0, $2896 = 0, $2897 = 0, $2898 = 0, $2899 = 0, $29 = 0, $290 = 0, $2900 = 0, $2901 = 0, $2902 = 0, $2903 = 0, $2904 = 0, $2905 = 0, $2906 = 0, $2907 = 0, $2908 = 0, $2909 = 0, $291 = 0, $2910 = 0, $2911 = 0, $2912 = 0, $2913 = 0, $2914 = 0, $2915 = 0, $2916 = 0, $2917 = 0, $2918 = 0, $2919 = 0, $292 = 0, $2920 = 0, $2921 = 0, $2922 = 0, $2923 = 0, $2924 = 0, $2925 = 0, $2926 = 0, $2927 = 0, $2928 = 0, $2929 = 0, $293 = 0, $2930 = 0, $2931 = 0, $2932 = 0, $2933 = 0, $2934 = 0, $2935 = 0, $2936 = 0, $2937 = 0, $2938 = 0, $2939 = 0, $294 = 0, $2940 = 0, $2941 = 0, $295 = 0, $296 = 0, $297 = 0, $298 = 0, $299 = 0, $3 = 0, $30 = 0, $300 = 0, $301 = 0, $302 = 0, $303 = 0, $304 = 0, $305 = 0, $306 = 0, $307 = 0, $308 = 0, $309 = 0, $31 = 0, $310 = 0, $311 = 0, $312 = 0, $313 = 0, $314 = 0, $315 = 0, $316 = 0, $317 = 0, $318 = 0, $319 = 0, $32 = 0, $320 = 0, $321 = 0, $322 = 0, $323 = 0, $324 = 0, $325 = 0, $326 = 0, $327 = 0, $328 = 0, $329 = 0, $33 = 0, $330 = 0, $331 = 0, $332 = 0, $333 = 0, $334 = 0, $335 = 0, $336 = 0, $337 = 0, $338 = 0, $339 = 0, $34 = 0, $340 = 0, $341 = 0, $342 = 0, $343 = 0, $344 = 0, $345 = 0, $346 = 0, $347 = 0, $348 = 0, $349 = 0, $349$phi = 0, $35 = 0, $350 = 0, $351 = 0, $352 = 0, $353 = 0, $354 = 0, $355 = 0, $356 = 0, $357 = 0, $358 = 0, $359 = 0, $36 = 0, $360 = 0, $361 = 0, $362 = 0, $363 = 0, $364 = 0, $365 = 0, $366 = 0, $367 = 0, $368 = 0, $369 = 0, $37 = 0, $370 = 0, $371 = 0, $372 = 0, $373 = 0, $374 = 0, $375 = 0, $376 = 0, $377 = 0, $378 = 0, $379 = 0, $38 = 0, $380 = 0, $381 = 0, $382 = 0, $383 = 0, $384 = 0, $385 = 0, $386 = 0, $387 = 0, $388 = 0, $389 = 0, $39 = 0, $390 = 0, $391 = 0, $392 = 0, $393 = 0, $394 = 0, $395 = 0, $396 = 0, $397 = 0, $398 = 0, $399 = 0, $4 = 0, $40 = 0, $400 = 0, $401 = 0, $402 = 0, $403 = 0, $404 = 0, $405 = 0, $406 = 0, $407 = 0, $408 = 0, $409 = 0, $41 = 0, $410 = 0, $411 = 0, $412 = 0, $413 = 0, $414 = 0, $415 = 0, $416 = 0, $417 = 0, $418 = 0, $419 = 0, $42 = 0, $420 = 0, $421 = 0, $422 = 0, $423 = 0, $424 = 0, $425 = 0, $426 = 0, $427 = 0, $428 = 0, $429 = 0, $43 = 0, $430 = 0, $431 = 0, $432 = 0, $433 = 0, $434 = 0, $435 = 0, $436 = 0, $437 = 0, $438 = 0, $439 = 0, $44 = 0, $440 = 0, $441 = 0, $442 = 0, $443 = 0, $444 = 0, $445 = 0, $446 = 0, $447 = 0, $448 = 0, $449 = 0, $45 = 0, $450 = 0, $451 = 0, $452 = 0, $453 = 0, $454 = 0, $455 = 0, $456 = 0, $457 = 0, $458 = 0, $459 = 0, $46 = 0, $460 = 0, $461 = 0, $462 = 0, $463 = 0, $464 = 0, $465 = 0, $466 = 0, $467 = 0, $468 = 0, $469 = 0, $47 = 0, $470 = 0, $471 = 0, $472 = 0, $473 = 0, $474 = 0, $475 = 0, $476 = 0, $477 = 0, $478 = 0, $479 = 0, $48 = 0, $480 = 0, $481 = 0, $482 = 0, $483 = 0, $484 = 0, $485 = 0, $486 = 0, $487 = 0, $488 = 0, $489 = 0, $49 = 0, $490 = 0, $491 = 0, $492 = 0, $493 = 0, $494 = 0, $495 = 0, $496 = 0, $497 = 0, $498 = 0, $499 = 0, $5 = 0, $50 = 0, $500 = 0, $501 = 0, $502 = 0, $503 = 0, $504 = 0, $505 = 0, $506 = 0, $507 = 0, $508 = 0, $509 = 0, $51 = 0, $510 = 0, $511 = 0, $512 = 0, $513 = 0, $514 = 0, $515 = 0, $516 = 0, $517 = 0, $518 = 0, $519 = 0, $52 = 0, $520 = 0, $521 = 0, $522 = 0, $523 = 0, $524 = 0, $525 = 0, $526 = 0, $527 = 0, $528 = 0, $529 = 0, $53 = 0, $530 = 0, $531 = 0, $532 = 0, $533 = 0, $534 = 0, $535 = 0, $536 = 0, $537 = 0, $538 = 0, $539 = 0, $54 = 0, $540 = 0, $541 = 0, $542 = 0, $543 = 0, $544 = 0, $545 = 0, $546 = 0, $547 = 0, $548 = 0, $549 = 0, $55 = 0, $550 = 0, $551 = 0, $552 = 0, $553 = 0, $554 = 0, $555 = 0, $556 = 0, $557 = 0, $558 = 0, $559 = 0, $56 = 0, $560 = 0, $561 = 0, $562 = 0, $563 = 0, $564 = 0, $565 = 0, $566 = 0, $567 = 0, $568 = 0, $569 = 0, $57 = 0, $570 = 0, $571 = 0, $572 = 0, $573 = 0, $574 = 0, $575 = 0, $576 = 0, $577 = 0, $578 = 0, $579 = 0, $58 = 0, $580 = 0, $581 = 0, $582 = 0, $583 = 0, $584 = 0, $585 = 0, $586 = 0, $587 = 0, $588 = 0, $589 = 0, $59 = 0, $590 = 0, $591 = 0, $592 = 0, $593 = 0, $594 = 0, $595 = 0, $596 = 0, $597 = 0, $598 = 0, $599 = 0, $6 = 0, $60 = 0, $600 = 0, $601 = 0, $602 = 0, $603 = 0, $604 = 0, $605 = 0, $606 = 0, $607 = 0, $608 = 0, $609 = 0, $61 = 0, $610 = 0, $611 = 0, $612 = 0, $613 = 0, $614 = 0, $615 = 0, $616 = 0, $617 = 0, $618 = 0, $619 = 0, $62 = 0, $620 = 0, $621 = 0, $622 = 0, $623 = 0, $624 = 0, $625 = 0, $626 = 0, $627 = 0, $628 = 0, $629 = 0, $63 = 0, $630 = 0, $631 = 0, $632 = 0, $633 = 0, $634 = 0, $635 = 0, $636 = 0, $637 = 0, $638 = 0, $639 = 0, $64 = 0, $640 = 0, $641 = 0, $642 = 0, $643 = 0, $644 = 0, $645 = 0, $646 = 0, $647 = 0, $648 = 0, $649 = 0, $65 = 0, $650 = 0, $651 = 0, $652 = 0, $653 = 0, $654 = 0, $655 = 0, $656 = 0, $657 = 0, $658 = 0, $659 = 0, $66 = 0, $660 = 0, $661 = 0, $662 = 0, $663 = 0, $664 = 0, $665 = 0, $666 = 0, $667 = 0, $668 = 0, $669 = 0, $67 = 0, $670 = 0, $671 = 0, $672 = 0, $673 = 0, $674 = 0, $675 = 0, $676 = 0, $677 = 0, $678 = 0, $679 = 0, $68 = 0, $680 = 0, $681 = 0, $682 = 0, $683 = 0, $684 = 0, $685 = 0, $686 = 0, $687 = 0, $688 = 0, $689 = 0, $69 = 0, $690 = 0, $691 = 0, $692 = 0, $693 = 0, $694 = 0, $695 = 0, $696 = 0, $697 = 0, $698 = 0, $699 = 0, $7 = 0, $70 = 0, $700 = 0, $701 = 0, $702 = 0, $703 = 0, $704 = 0, $705 = 0, $706 = 0, $707 = 0, $708 = 0, $709 = 0, $71 = 0, $710 = 0, $711 = 0, $712 = 0, $713 = 0, $714 = 0, $715 = 0, $716 = 0, $717 = 0, $718 = 0, $719 = 0, $72 = 0, $720 = 0, $721 = 0, $722 = 0, $723 = 0, $724 = 0, $725 = 0, $726 = 0, $727 = 0, $728 = 0, $729 = 0, $73 = 0, $730 = 0, $731 = 0, $732 = 0, $733 = 0, $734 = 0, $735 = 0, $736 = 0, $737 = 0, $738 = 0, $739 = 0, $74 = 0, $740 = 0, $741 = 0, $742 = 0, $743 = 0, $744 = 0, $745 = 0, $746 = 0, $747 = 0, $748 = 0, $749 = 0, $75 = 0, $750 = 0, $751 = 0, $752 = 0, $753 = 0, $754 = 0, $755 = 0, $756 = 0, $757 = 0, $758 = 0, $759 = 0, $76 = 0, $760 = 0, $761 = 0, $762 = 0, $763 = 0, $764 = 0, $765 = 0, $766 = 0, $767 = 0, $768 = 0, $769 = 0, $77 = 0, $770 = 0, $771 = 0, $772 = 0, $773 = 0, $774 = 0, $775 = 0, $776 = 0, $777 = 0, $778 = 0, $779 = 0, $78 = 0, $780 = 0, $781 = 0, $782 = 0, $783 = 0, $784 = 0, $785 = 0, $786 = 0, $787 = 0, $788 = 0, $789 = 0, $79 = 0, $790 = 0, $791 = 0, $792 = 0, $793 = 0, $794 = 0, $795 = 0, $796 = 0, $797 = 0, $798 = 0, $799 = 0, $8 = 0, $80 = 0, $800 = 0, $801 = 0, $802 = 0, $803 = 0, $804 = 0, $805 = 0, $806 = 0, $807 = 0, $808 = 0, $809 = 0, $81 = 0, $810 = 0, $811 = 0, $812 = 0, $813 = 0, $814 = 0, $815 = 0, $816 = 0, $817 = 0, $818 = 0, $819 = 0, $82 = 0, $820 = 0, $821 = 0, $822 = 0, $823 = 0, $824 = 0, $825 = 0, $826 = 0, $827 = 0, $828 = 0, $829 = 0, $83 = 0, $830 = 0, $831 = 0, $832 = 0, $833 = 0, $834 = 0, $835 = 0, $836 = 0, $837 = 0, $838 = 0, $839 = 0, $84 = 0, $840 = 0, $841 = 0, $842 = 0, $843 = 0, $844 = 0, $845 = 0, $846 = 0, $847 = 0, $848 = 0, $849 = 0, $85 = 0, $850 = 0, $851 = 0, $852 = 0, $853 = 0, $854 = 0, $855 = 0, $856 = 0, $857 = 0, $858 = 0, $859 = 0, $86 = 0, $860 = 0, $861 = 0, $862 = 0, $863 = 0, $864 = 0, $865 = 0, $866 = 0, $867 = 0, $868 = 0, $869 = 0, $87 = 0, $870 = 0, $871 = 0, $872 = 0, $873 = 0, $874 = 0, $875 = 0, $876 = 0, $877 = 0, $878 = 0, $879 = 0, $88 = 0, $880 = 0, $881 = 0, $882 = 0, $883 = 0, $884 = 0, $885 = 0, $886 = 0, $887 = 0, $888 = 0, $889 = 0, $89 = 0, $890 = 0, $891 = 0, $892 = 0, $893 = 0, $894 = 0, $895 = 0, $896 = 0, $897 = 0, $898 = 0, $899 = 0, $9 = 0, $90 = 0, $900 = 0, $901 = 0, $902 = 0, $903 = 0, $904 = 0, $905 = 0, $906 = 0, $907 = 0, $908 = 0, $909 = 0, $91 = 0, $910 = 0, $911 = 0, $912 = 0, $913 = 0, $914 = 0, $915 = 0, $916 = 0, $917 = 0, $918 = 0, $919 = 0, $92 = 0, $920 = 0, $921 = 0, $922 = 0, $923 = 0, $924 = 0, $925 = 0, $926 = 0, $927 = 0, $928 = 0, $929 = 0, $93 = 0, $930 = 0, $931 = 0, $932 = 0, $933 = 0, $934 = 0, $935 = 0, $936 = 0, $937 = 0, $938 = 0, $939 = 0, $94 = 0, $940 = 0, $941 = 0, $942 = 0, $943 = 0, $944 = 0, $945 = 0, $946 = 0, $947 = 0, $948 = 0, $949 = 0, $95 = 0, $950 = 0, $951 = 0, $952 = 0, $953 = 0, $954 = 0, $955 = 0, $956 = 0, $957 = 0, $958 = 0, $959 = 0, $96 = 0, $960 = 0, $961 = 0, $962 = 0, $963 = 0, $964 = 0, $965 = 0, $966 = 0, $967 = 0, $968 = 0, $969 = 0, $97 = 0, $970 = 0, $971 = 0, $972 = 0, $973 = 0, $974 = 0, $975 = 0, $976 = 0, $977 = 0, $978 = 0, $979 = 0, $98 = 0, $980 = 0, $981 = 0, $982 = 0, $983 = 0, $984 = 0, $985 = 0, $986 = 0, $987 = 0, $988 = 0, $989 = 0, $99 = 0, $990 = 0, $991 = 0, $992 = 0, $993 = 0, $994 = 0, $995 = 0, $996 = 0, $997 = 0, $998 = 0, $999 = 0, $__i$0$i$i$i = 0, $__i$0$i$i$i$i = 0, $__i$0$i$i$i$i$i = 0, $__i$0$i$i$i$i$i300 = 0, $__i$0$i$i$i$i$i340 = 0, $__i$0$i$i$i$i274 = 0, $__i$0$i$i$i$i310 = 0, $__i$0$i$i$i$i36$i = 0, $__i$0$i$i$i$i57$i = 0, $__i$0$i$i$i$i68$i = 0, $__i$0$i$i$i$i87$i = 0, $__i$0$i$i$i10$i = 0, $__i$0$i$i$i13$i = 0, $__i$0$i$i$i14$i = 0, $__i$0$i$i$i17$i = 0, $__i$0$i$i$i18$i = 0, $__i$0$i$i$i18$i318 = 0, $__i$0$i$i$i22$i = 0, $__i$0$i$i$i245 = 0, $__i$0$i$i$i249 = 0, $__i$0$i$i$i253 = 0, $__i$0$i$i$i28$i = 0, $__i$0$i$i$i30$i = 0, $__i$0$i$i$i322 = 0, $__i$0$i$i$i34$i = 0, $__i$0$i$i$i38$i = 0, $__i$0$i$i$i39$i = 0, $__i$0$i$i$i44$i = 0, $__i$0$i$i$i48$i = 0, $__p$0$i$i$i = 0, $__p$0$ph$i$i$i = 0, $__v$i$i = 0, $__v$i$i$i = 0, $__v$i$i100 = 0, $__v$i$i108 = 0, $__v$i$i116 = 0, $__v$i$i124 = 0, $__v$i$i135 = 0, $__v$i$i151 = 0, $__v$i$i16 = 0, $__v$i$i162 = 0, $__v$i$i177 = 0, $__v$i$i188 = 0, $__v$i$i195 = 0, $__v$i$i211 = 0, $__v$i$i219 = 0, $__v$i$i24 = 0, $__v$i$i256 = 0, $__v$i$i32 = 0, $__v$i$i35 = 0, $__v$i$i39 = 0, $__v$i$i50 = 0, $__v$i$i57 = 0, $__v$i$i68 = 0, $__v$i$i76 = 0, $__v$i$i84 = 0, $__v$i$i92 = 0, $args = 0, $class_type$i = 0, $cv = 0, $eh$lpad$body$i$i$index34Z2D = 0, $eh$lpad$body$i$i$indexZ2D = 0, $eh$lpad$body$i$i131$index14Z2D = 0, $eh$lpad$body$i$i131$indexZ2D = 0, $eh$lpad$body$i$i158$index19Z2D = 0, $eh$lpad$body$i$i158$indexZ2D = 0, $eh$lpad$body$i$i184$index24Z2D = 0, $eh$lpad$body$i$i184$indexZ2D = 0, $eh$lpad$body$i$i202$index29Z2D = 0, $eh$lpad$body$i$i202$indexZ2D = 0, $eh$lpad$body$i$i64$index2Z2D = 0, $eh$lpad$body$i$i64$indexZ2D = 0, $exitcond$i$i$i = 0, $exitcond$i$i$i$i = 0, $exitcond$i$i$i$i$i = 0, $exitcond$i$i$i$i$i301 = 0, $exitcond$i$i$i$i$i341 = 0, $exitcond$i$i$i$i275 = 0, $exitcond$i$i$i$i311 = 0, $exitcond$i$i$i$i37$i = 0, $exitcond$i$i$i$i58$i = 0, $exitcond$i$i$i$i69$i = 0, $exitcond$i$i$i$i88$i = 0, $exitcond$i$i$i11$i = 0, $exitcond$i$i$i14$i = 0, $exitcond$i$i$i15$i = 0, $exitcond$i$i$i18$i = 0, $exitcond$i$i$i19$i = 0, $exitcond$i$i$i19$i319 = 0, $exitcond$i$i$i23$i = 0, $exitcond$i$i$i246 = 0, $exitcond$i$i$i250 = 0, $exitcond$i$i$i254 = 0, $exitcond$i$i$i29$i = 0, $exitcond$i$i$i31$i = 0, $exitcond$i$i$i323 = 0, $exitcond$i$i$i35$i = 0, $exitcond$i$i$i39$i = 0, $exitcond$i$i$i40$i = 0, $exitcond$i$i$i45$i = 0, $exitcond$i$i$i49$i = 0, $expr$i = 0, $func$i = 0, $k$0 = 0, $k$0$i = 0, $k11$0 = 0, $k15$0 = 0, $k2$0$i = 0, $k20$0 = 0, $k5$0 = 0, $k8$0 = 0, $lpad$phi$index = 0, $lpad$phi$index8 = 0, $num1$i = 0, $or$cond = 0, $or$cond$i = 0, $or$cond$i$i = 0, $or$cond$i$i$i$i$i$i = 0, $or$cond$i$i$i$i$i$i292 = 0, $or$cond$i$i$i$i$i$i332 = 0, $or$cond$i$i$i$i$i28$i = 0, $or$cond$i$i$i$i$i49$i = 0, $or$cond$i$i$i$i$i60$i = 0, $or$cond$i$i$i$i$i79$i = 0, $or$cond10$i = 0, $or$cond495 = 0, $or$cond496 = 0, $p$0 = 0, $p$1 = 0, $p$2 = 0, $phitmp$i$i$i = 0, $phitmp$i$i$i$i$i$i$i = 0, $phitmp$i$i$i$i$i$i$i287 = 0, $phitmp$i$i$i$i$i$i$i327 = 0, $phitmp$i$i$i$i$i$i23$i = 0, $phitmp$i$i$i$i$i$i44$i = 0, $phitmp$i$i$i$i$i$i55$i = 0, $phitmp$i$i$i$i$i$i74$i = 0, $phitmp$i2$i$i$i$i$i$i = 0, $phitmp$i2$i$i$i$i$i$i290 = 0, $phitmp$i2$i$i$i$i$i$i330 = 0, $phitmp$i2$i$i$i$i$i26$i = 0, $phitmp$i2$i$i$i$i$i47$i = 0, $phitmp$i2$i$i$i$i$i58$i = 0, $phitmp$i2$i$i$i$i$i77$i = 0, $proto = 0, $ref_qual$0$i$ph = 0, $ref_qual$0$i$ph$lcssa569 = 0, $ref_qual$0$i$ph$ph = 0, $scevgep2$i$i$i = 0, $sig$i = 0, $t$0$i = 0, $t$1$i = 0, $t$1$i$be = 0, $t$1$i$lcssa563 = 0, $t$1$i$ph = 0, $t$1$i$ph$ph = 0, $t12$0$i = 0, $template_args = 0, $type = 0, $type$i = 0, label = 0, sp = 0; | |
| label = 0; | |
| sp = STACKTOP; | |
| STACKTOP = STACKTOP + 1584 | 0; | |
| asyncState ? abort(-12) | 0 : 0; | |
| if ((STACKTOP | 0) >= (STACK_MAX | 0)) abort(), asyncState ? abort(-12) | 0 : 0; | |
| $__v$i$i$i = sp + 756 | 0; | |
| $0 = sp + 728 | 0; | |
| $1 = sp + 1352 | 0; | |
| $2 = sp + 32 | 0; | |
| $3 = sp + 48 | 0; | |
| $4 = sp + 76 | 0; | |
| $5 = sp + 1420 | 0; | |
| $6 = sp + 1532 | 0; | |
| $num1$i = sp + 744 | 0; | |
| $7 = sp + 96 | 0; | |
| $8 = sp + 108 | 0; | |
| $9 = sp + 120 | 0; | |
| $10 = sp + 132 | 0; | |
| $11 = sp + 144 | 0; | |
| $12 = sp + 156 | 0; | |
| $13 = sp + 168 | 0; | |
| $14 = sp + 180 | 0; | |
| $type$i = sp + 192 | 0; | |
| $expr$i = sp + 216 | 0; | |
| $15 = sp + 240 | 0; | |
| $16 = sp + 252 | 0; | |
| $17 = sp + 264 | 0; | |
| $18 = sp + 276 | 0; | |
| $19 = sp + 288 | 0; | |
| $sig$i = sp + 300 | 0; | |
| $20 = sp + 312 | 0; | |
| $func$i = sp + 328 | 0; | |
| $class_type$i = sp + 352 | 0; | |
| $21 = sp + 376 | 0; | |
| $22 = sp + 388 | 0; | |
| $23 = sp + 400 | 0; | |
| $24 = sp + 412 | 0; | |
| $25 = sp + 424 | 0; | |
| $26 = sp + 436 | 0; | |
| $27 = sp + 448 | 0; | |
| $28 = sp + 460 | 0; | |
| $29 = sp + 472 | 0; | |
| $__v$i$i256 = sp + 484 | 0; | |
| $__v$i$i219 = sp + 504 | 0; | |
| $__v$i$i211 = sp + 524 | 0; | |
| $__v$i$i195 = sp + 544 | 0; | |
| $__v$i$i188 = sp + 564 | 0; | |
| $__v$i$i177 = sp + 584 | 0; | |
| $__v$i$i162 = sp + 604 | 0; | |
| $__v$i$i151 = sp + 624 | 0; | |
| $__v$i$i135 = sp + 644 | 0; | |
| $__v$i$i124 = sp + 664 | 0; | |
| $__v$i$i116 = sp + 684 | 0; | |
| $__v$i$i108 = sp + 1364 | 0; | |
| $__v$i$i100 = sp + 1400 | 0; | |
| $__v$i$i92 = sp + 1432 | 0; | |
| $__v$i$i84 = sp + 1472 | 0; | |
| $__v$i$i76 = sp + 1512 | 0; | |
| $__v$i$i68 = sp + 1544 | 0; | |
| $__v$i$i57 = sp + 1564 | 0; | |
| $__v$i$i50 = sp + 776 | 0; | |
| $__v$i$i39 = sp + 796 | 0; | |
| $__v$i$i35 = sp + 816 | 0; | |
| $__v$i$i32 = sp + 836 | 0; | |
| $__v$i$i24 = sp + 856 | 0; | |
| $__v$i$i16 = sp + 876 | 0; | |
| $__v$i$i = sp + 896 | 0; | |
| $cv = sp + 916 | 0; | |
| $30 = sp + 920 | 0; | |
| $31 = sp + 936 | 0; | |
| $32 = sp + 944 | 0; | |
| $33 = sp + 960 | 0; | |
| $34 = sp + 968 | 0; | |
| $35 = sp + 984 | 0; | |
| $36 = sp + 992 | 0; | |
| $37 = sp + 1008 | 0; | |
| $38 = sp + 1016 | 0; | |
| $39 = sp + 1032 | 0; | |
| $40 = sp + 1036 | 0; | |
| $41 = sp + 1048 | 0; | |
| $42 = sp + 1060 | 0; | |
| $43 = sp + 1072 | 0; | |
| $args = sp + 1084 | 0; | |
| $44 = sp + 1096 | 0; | |
| $45 = sp + 1112 | 0; | |
| $type = sp + 1116 | 0; | |
| $46 = sp + 1128 | 0; | |
| $47 = sp + 1144 | 0; | |
| $48 = sp + 1168 | 0; | |
| $49 = sp + 1180 | 0; | |
| $50 = sp + 1192 | 0; | |
| $proto = sp + 1204 | 0; | |
| $51 = sp + 1216 | 0; | |
| $52 = sp + 1240 | 0; | |
| $53 = sp + 1252 | 0; | |
| $54 = sp + 1264 | 0; | |
| $55 = sp + 1276 | 0; | |
| $56 = sp + 1288 | 0; | |
| $57 = sp + 1312 | 0; | |
| $58 = sp + 1324 | 0; | |
| $59 = sp + 1336 | 0; | |
| $60 = sp + 88 | 0; | |
| $61 = sp + 16 | 0; | |
| $62 = sp + 72 | 0; | |
| $template_args = sp; | |
| $63 = sp + 704 | 0; | |
| $64 = sp + 720 | 0; | |
| $65 = sp + 1384 | 0; | |
| $66 = sp + 724 | 0; | |
| $67 = sp + 1456 | 0; | |
| $68 = sp + 740 | 0; | |
| $69 = sp + 1496 | 0; | |
| $70 = sp + 92 | 0; | |
| $71 = ($first | 0) == ($last | 0); | |
| L1 : do { | |
| if ($71) { | |
| $$0 = $first; | |
| } else { | |
| $72 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $73 = $72 << 24 >> 24; | |
| if (($73 | 0) == 75 | ($73 | 0) == 86 | ($73 | 0) == 114) { | |
| SAFE_HEAP_STORE($cv | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $74 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_119parse_cv_qualifiersEPKcS2_Rj($first, $last, $cv) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $75 = ($74 | 0) == ($first | 0); | |
| if ($75) { | |
| $$0 = $first; | |
| break; | |
| } | |
| $76 = (tempInt = SAFE_HEAP_LOAD($74 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $77 = $db + 4 | 0; | |
| $78 = (tempInt = SAFE_HEAP_LOAD($77 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $79 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $80 = $78; | |
| $81 = $79; | |
| $82 = $80 - $81 | 0; | |
| $83 = ($82 | 0) / 24 & -1; | |
| $84 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($74, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $85 = (tempInt = SAFE_HEAP_LOAD($77 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $86 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $87 = $85; | |
| $88 = $86; | |
| $89 = $87 - $88 | 0; | |
| $90 = ($89 | 0) / 24 & -1; | |
| $91 = ($84 | 0) == ($74 | 0); | |
| if ($91) { | |
| $$0 = $first; | |
| break; | |
| } | |
| $92 = $76 << 24 >> 24 == 70; | |
| $93 = $db + 20 | 0; | |
| $94 = (tempInt = SAFE_HEAP_LOAD($93 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($92) { | |
| $95 = $94 + -16 | 0; | |
| $97 = $94; | |
| while (1) { | |
| $96 = ($97 | 0) == ($95 | 0); | |
| if ($96) { | |
| break; | |
| } | |
| $98 = $97 + -16 | 0; | |
| SAFE_HEAP_STORE($93 | 0, $98 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($98), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i49 = (tempInt = SAFE_HEAP_LOAD($93 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $97 = $$pre$i49; | |
| } | |
| $106 = $95; | |
| } else { | |
| $106 = $94; | |
| } | |
| $99 = $db + 16 | 0; | |
| $100 = $db + 12 | 0; | |
| $101 = (tempInt = SAFE_HEAP_LOAD($100 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $102 = $db + 20 | 0; | |
| $103 = $db + 24 | 0; | |
| $104 = (tempInt = SAFE_HEAP_LOAD($103 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $105 = $106 >>> 0 < $104 >>> 0; | |
| if ($105) { | |
| $107 = ($106 | 0) == (0 | 0); | |
| if ($107) { | |
| $112 = 0; | |
| } else { | |
| SAFE_HEAP_STORE($106 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $108 = $106 + 4 | 0; | |
| SAFE_HEAP_STORE($108 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $109 = $106 + 8 | 0; | |
| SAFE_HEAP_STORE($109 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $110 = $106 + 12 | 0; | |
| SAFE_HEAP_STORE($110 | 0, $101 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i51 = (tempInt = SAFE_HEAP_LOAD($102 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $112 = $$pre$i51; | |
| } | |
| $111 = $112 + 16 | 0; | |
| SAFE_HEAP_STORE($102 | 0, $111 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $113 = $db + 28 | 0; | |
| $114 = (tempInt = SAFE_HEAP_LOAD($99 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $115 = $106; | |
| $116 = $114; | |
| $117 = $115 - $116 | 0; | |
| $118 = $117 >> 4; | |
| $119 = $118 + 1 | 0; | |
| $120 = ($117 | 0) < -16; | |
| if ($120) { | |
| __ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv($99), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $121 = $104; | |
| $122 = $121 - $116 | 0; | |
| $123 = $122 >> 4; | |
| $124 = $123 >>> 0 < 1073741823; | |
| if ($124) { | |
| $125 = $122 >> 3; | |
| $126 = $125 >>> 0 < $119 >>> 0; | |
| $127 = $126 ? $119 : $125; | |
| $$0$i$i$i53 = $127; | |
| } else { | |
| $$0$i$i$i53 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEEC2EjjS9_($__v$i$i50, $$0$i$i$i53, $118, $113), asyncState ? abort(-12) | 0 : 0; | |
| $128 = $__v$i$i50 + 8 | 0; | |
| $129 = (tempInt = SAFE_HEAP_LOAD($128 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $130 = ($129 | 0) == (0 | 0); | |
| if (!$130) { | |
| SAFE_HEAP_STORE($129 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $131 = $129 + 4 | 0; | |
| SAFE_HEAP_STORE($131 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $132 = $129 + 8 | 0; | |
| SAFE_HEAP_STORE($132 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $133 = $129 + 12 | 0; | |
| SAFE_HEAP_STORE($133 | 0, $101 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $134 = $129 + 16 | 0; | |
| SAFE_HEAP_STORE($128 | 0, $134 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorINS0_IN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEENS4_IS6_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS6_RS7_EE($99, $__v$i$i50), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEED2Ev($__v$i$i50), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $135 = (tempInt = SAFE_HEAP_LOAD($cv | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $136 = $135 & 1; | |
| $137 = ($136 | 0) == 0; | |
| $138 = $135 & 2; | |
| $139 = ($138 | 0) == 0; | |
| $140 = $135 & 4; | |
| $141 = ($140 | 0) == 0; | |
| $142 = $__v$i$i57 + 8 | 0; | |
| $k$0 = $83; | |
| while (1) { | |
| $143 = $k$0 >>> 0 < $90 >>> 0; | |
| if (!$143) { | |
| label = 1052; | |
| break; | |
| } | |
| if ($92) { | |
| $144 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $145 = ($144 + ($k$0 * 24 | 0) | 0) + 12 | 0; | |
| $146 = (tempInt = SAFE_HEAP_LOAD($145 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $147 = $146 & 1; | |
| $148 = $147 << 24 >> 24 == 0; | |
| if ($148) { | |
| $153 = $146 & 255; | |
| $154 = $153 >>> 1; | |
| $155 = $145 + 1 | 0; | |
| $$in = $154; | |
| $158 = $155; | |
| } else { | |
| $149 = ($144 + ($k$0 * 24 | 0) | 0) + 16 | 0; | |
| $150 = (tempInt = SAFE_HEAP_LOAD($149 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $151 = ($144 + ($k$0 * 24 | 0) | 0) + 20 | 0; | |
| $152 = (tempInt = SAFE_HEAP_LOAD($151 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $$in = $150; | |
| $158 = $152; | |
| } | |
| $156 = $$in + -2 | 0; | |
| $157 = $158 + $156 | 0; | |
| $159 = (tempInt = SAFE_HEAP_LOAD($157 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $160 = $159 << 24 >> 24 == 38; | |
| if ($160) { | |
| $161 = $$in + -3 | 0; | |
| $p$0 = $161; | |
| } else { | |
| if ($148) { | |
| $166 = $145 + 1 | 0; | |
| $167 = $146 & 255; | |
| $168 = $167 >>> 1; | |
| $169 = $168; | |
| $171 = $166; | |
| } else { | |
| $162 = ($144 + ($k$0 * 24 | 0) | 0) + 20 | 0; | |
| $163 = (tempInt = SAFE_HEAP_LOAD($162 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $164 = ($144 + ($k$0 * 24 | 0) | 0) + 16 | 0; | |
| $165 = (tempInt = SAFE_HEAP_LOAD($164 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $169 = $165; | |
| $171 = $163; | |
| } | |
| $$sum$i = $169 + -1 | 0; | |
| $170 = $171 + $$sum$i | 0; | |
| $172 = (tempInt = SAFE_HEAP_LOAD($170 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $173 = $172 << 24 >> 24 == 38; | |
| $$ = $173 ? $156 : $$in; | |
| $p$0 = $$; | |
| } | |
| if ($137) { | |
| $p$1 = $p$0; | |
| } else { | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6insertEjPKc($145, $p$0, 2672) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $174 = $p$0 + 6 | 0; | |
| $p$1 = $174; | |
| } | |
| if ($139) { | |
| $p$2 = $p$1; | |
| } else { | |
| $175 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $176 = ($175 + ($k$0 * 24 | 0) | 0) + 12 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6insertEjPKc($176, $p$1, 2680) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $177 = $p$1 + 9 | 0; | |
| $p$2 = $177; | |
| } | |
| if (!$141) { | |
| $178 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $179 = ($178 + ($k$0 * 24 | 0) | 0) + 12 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6insertEjPKc($179, $p$2, 2696) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } | |
| } else { | |
| if (!$137) { | |
| $180 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $181 = $180 + ($k$0 * 24 | 0) | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($181, 2672) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } | |
| if (!$139) { | |
| $182 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $183 = $182 + ($k$0 * 24 | 0) | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($183, 2680) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } | |
| if (!$141) { | |
| $184 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $185 = $184 + ($k$0 * 24 | 0) | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($185, 2696) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } | |
| } | |
| $186 = (tempInt = SAFE_HEAP_LOAD($102 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $187 = $186 + -16 | 0; | |
| $188 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $189 = $188 + ($k$0 * 24 | 0) | 0; | |
| $190 = $186 + -12 | 0; | |
| $191 = (tempInt = SAFE_HEAP_LOAD($190 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $192 = $186 + -8 | 0; | |
| $193 = (tempInt = SAFE_HEAP_LOAD($192 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $194 = ($191 | 0) == ($193 | 0); | |
| if ($194) { | |
| $204 = $186 + -4 | 0; | |
| $205 = (tempInt = SAFE_HEAP_LOAD($187 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $206 = $191; | |
| $207 = $205; | |
| $208 = $206 - $207 | 0; | |
| $209 = ($208 | 0) / 24 & -1; | |
| $210 = $209 + 1 | 0; | |
| $211 = ($210 | 0) < 0; | |
| if ($211) { | |
| $$lcssa608 = $187; | |
| label = 52; | |
| break; | |
| } | |
| $212 = $209 >>> 0 < 1073741823; | |
| if ($212) { | |
| $213 = $209 << 1; | |
| $214 = $213 >>> 0 < $210 >>> 0; | |
| $215 = $214 ? $210 : $213; | |
| $$0$i$i$i61 = $215; | |
| } else { | |
| $$0$i$i$i61 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEEC2EjjS6_($__v$i$i57, $$0$i$i$i61, $209, $204), asyncState ? abort(-12) | 0 : 0; | |
| $216 = (tempInt = SAFE_HEAP_LOAD($142 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $217 = ($216 | 0) == (0 | 0); | |
| if (!$217) { | |
| __THREW__ = 0; | |
| invoke_vii(12, $216 | 0, $189 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $218 = __THREW__; | |
| __THREW__ = 0; | |
| $219 = $218 & 1; | |
| if ($219) { | |
| label = 59; | |
| break; | |
| } | |
| $220 = $216 + 12 | 0; | |
| $221 = ($188 + ($k$0 * 24 | 0) | 0) + 12 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(12, $220 | 0, $221 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $222 = __THREW__; | |
| __THREW__ = 0; | |
| $223 = $222 & 1; | |
| if ($223) { | |
| $$lcssa613 = $216; | |
| label = 58; | |
| break; | |
| } | |
| } | |
| $228 = $216 + 24 | 0; | |
| SAFE_HEAP_STORE($142 | 0, $228 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS3_RS5_EE($187, $__v$i$i57), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i57), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $195 = ($191 | 0) == (0 | 0); | |
| if ($195) { | |
| $203 = 0; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEEC2ERKS7_($191, $189), asyncState ? abort(-12) | 0 : 0; | |
| $196 = $191 + 12 | 0; | |
| $197 = ($188 + ($k$0 * 24 | 0) | 0) + 12 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(12, $196 | 0, $197 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $198 = __THREW__; | |
| __THREW__ = 0; | |
| $199 = $198 & 1; | |
| if ($199) { | |
| $$lcssa611 = $191; | |
| label = 49; | |
| break; | |
| } | |
| $$pre$i58 = (tempInt = SAFE_HEAP_LOAD($190 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $203 = $$pre$i58; | |
| } | |
| $202 = $203 + 24 | 0; | |
| SAFE_HEAP_STORE($190 | 0, $202 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $229 = $k$0 + 1 | 0; | |
| $k$0 = $229; | |
| } | |
| if ((label | 0) == 49) { | |
| $200 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $201 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($$lcssa611), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($200 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } else if ((label | 0) == 52) { | |
| __ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv($$lcssa608), asyncState ? abort(-12) | 0 : 0; | |
| } else if ((label | 0) == 58) { | |
| $224 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $225 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($$lcssa613), asyncState ? abort(-12) | 0 : 0; | |
| $eh$lpad$body$i$i64$index2Z2D = $225; | |
| $eh$lpad$body$i$i64$indexZ2D = $224; | |
| } else if ((label | 0) == 59) { | |
| $226 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $227 = tempRet0; | |
| $eh$lpad$body$i$i64$index2Z2D = $227; | |
| $eh$lpad$body$i$i64$indexZ2D = $226; | |
| } else if ((label | 0) == 1052) { | |
| $$0 = $84; | |
| break; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i57), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($eh$lpad$body$i$i64$indexZ2D | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $230 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_118parse_builtin_typeINS0_2DbEEEPKcS4_S4_RT_($first, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $231 = ($230 | 0) == ($first | 0); | |
| if ($231) { | |
| $232 = (tempInt = SAFE_HEAP_LOAD($first >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $233 = $232 << 24 >> 24; | |
| L88 : do { | |
| switch ($233 | 0) { | |
| case 65: | |
| { | |
| $234 = $232 << 24 >> 24 == 65; | |
| L90 : do { | |
| if ($234) { | |
| $235 = $first + 1 | 0; | |
| $236 = ($235 | 0) == ($last | 0); | |
| if ($236) { | |
| $$0$i = $first; | |
| } else { | |
| $237 = (tempInt = SAFE_HEAP_LOAD($235 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $238 = $237 << 24 >> 24 == 95; | |
| if ($238) { | |
| $239 = $first + 2 | 0; | |
| $240 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($239, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $241 = ($240 | 0) == ($239 | 0); | |
| if ($241) { | |
| $$0$i = $first; | |
| break; | |
| } | |
| $242 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $243 = $db + 4 | 0; | |
| $244 = (tempInt = SAFE_HEAP_LOAD($243 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $245 = ($242 | 0) == ($244 | 0); | |
| if ($245) { | |
| $$0$i = $first; | |
| break; | |
| } | |
| $246 = $244 + -12 | 0; | |
| $247 = (tempInt = SAFE_HEAP_LOAD($246 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $248 = $247 & 1; | |
| $249 = $248 << 24 >> 24 == 0; | |
| if ($249) { | |
| $254 = $247 & 255; | |
| $255 = $254 >>> 1; | |
| $256 = $246 + 1 | 0; | |
| $258 = $255; | |
| $260 = $256; | |
| } else { | |
| $250 = $244 + -8 | 0; | |
| $251 = (tempInt = SAFE_HEAP_LOAD($250 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $252 = $244 + -4 | 0; | |
| $253 = (tempInt = SAFE_HEAP_LOAD($252 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $258 = $251; | |
| $260 = $253; | |
| } | |
| $257 = $258 >>> 0 < 2; | |
| $259 = $257 ? $258 : 2; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($10, $260, $259), asyncState ? abort(-12) | 0 : 0; | |
| $261 = (tempInt = SAFE_HEAP_LOAD($10 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $262 = $261 & 1; | |
| $263 = $262 << 24 >> 24 == 0; | |
| if ($263) { | |
| $268 = $261 & 255; | |
| $269 = $268 >>> 1; | |
| $270 = $10 + 1 | 0; | |
| $272 = $269; | |
| $274 = $270; | |
| } else { | |
| $264 = $10 + 4 | 0; | |
| $265 = (tempInt = SAFE_HEAP_LOAD($264 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $266 = $10 + 8 | 0; | |
| $267 = (tempInt = SAFE_HEAP_LOAD($266 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $272 = $265; | |
| $274 = $267; | |
| } | |
| $271 = $272 >>> 0 > 2; | |
| $273 = $271 ? 2 : $272; | |
| $275 = (tempInt = _memcmp($274, 2744, $273) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $276 = ($275 | 0) != 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($10), asyncState ? abort(-12) | 0 : 0; | |
| $277 = ($272 | 0) != 2; | |
| $278 = $277 | $276; | |
| if (!$278) { | |
| $279 = (tempInt = SAFE_HEAP_LOAD($243 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $280 = $279 + -12 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE5eraseEjj($280), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $281 = (tempInt = SAFE_HEAP_LOAD($243 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $282 = $281 + -12 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6insertEjPKc($282, 0, 5096) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $$0$i = $240; | |
| break; | |
| } | |
| $$off364 = $237 + -49 << 24 >> 24; | |
| $283 = ($$off364 & 255) < 9; | |
| if ($283) { | |
| $284 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_112parse_numberEPKcS2_($235, $last) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $285 = ($284 | 0) == ($last | 0); | |
| if ($285) { | |
| $$0$i = $first; | |
| break; | |
| } | |
| $286 = (tempInt = SAFE_HEAP_LOAD($284 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $287 = $286 << 24 >> 24 == 95; | |
| if (!$287) { | |
| $$0$i = $first; | |
| break; | |
| } | |
| $288 = $284 + 1 | 0; | |
| $289 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($288, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $290 = ($289 | 0) == ($288 | 0); | |
| if ($290) { | |
| $$0$i = $first; | |
| break; | |
| } | |
| $291 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $292 = $db + 4 | 0; | |
| $293 = (tempInt = SAFE_HEAP_LOAD($292 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $294 = ($291 | 0) == ($293 | 0); | |
| if ($294) { | |
| $$0$i = $first; | |
| break; | |
| } | |
| $295 = $293 + -12 | 0; | |
| $296 = (tempInt = SAFE_HEAP_LOAD($295 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $297 = $296 & 1; | |
| $298 = $297 << 24 >> 24 == 0; | |
| if ($298) { | |
| $303 = $296 & 255; | |
| $304 = $303 >>> 1; | |
| $305 = $295 + 1 | 0; | |
| $307 = $304; | |
| $309 = $305; | |
| } else { | |
| $299 = $293 + -8 | 0; | |
| $300 = (tempInt = SAFE_HEAP_LOAD($299 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $301 = $293 + -4 | 0; | |
| $302 = (tempInt = SAFE_HEAP_LOAD($301 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $307 = $300; | |
| $309 = $302; | |
| } | |
| $306 = $307 >>> 0 < 2; | |
| $308 = $306 ? $307 : 2; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($11, $309, $308), asyncState ? abort(-12) | 0 : 0; | |
| $310 = (tempInt = SAFE_HEAP_LOAD($11 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $311 = $310 & 1; | |
| $312 = $311 << 24 >> 24 == 0; | |
| if ($312) { | |
| $317 = $310 & 255; | |
| $318 = $317 >>> 1; | |
| $319 = $11 + 1 | 0; | |
| $321 = $318; | |
| $323 = $319; | |
| } else { | |
| $313 = $11 + 4 | 0; | |
| $314 = (tempInt = SAFE_HEAP_LOAD($313 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $315 = $11 + 8 | 0; | |
| $316 = (tempInt = SAFE_HEAP_LOAD($315 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $321 = $314; | |
| $323 = $316; | |
| } | |
| $320 = $321 >>> 0 > 2; | |
| $322 = $320 ? 2 : $321; | |
| $324 = (tempInt = _memcmp($323, 2744, $322) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $325 = ($324 | 0) != 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($11), asyncState ? abort(-12) | 0 : 0; | |
| $326 = ($321 | 0) != 2; | |
| $327 = $326 | $325; | |
| if (!$327) { | |
| $328 = (tempInt = SAFE_HEAP_LOAD($292 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $329 = $328 + -12 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE5eraseEjj($329), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $330 = (tempInt = SAFE_HEAP_LOAD($292 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $331 = $330 + -12 | 0; | |
| $332 = $235; | |
| $333 = $284; | |
| $334 = $333 - $332 | 0; | |
| $335 = $334 >>> 0 > 4294967279; | |
| if ($335) { | |
| __ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv($14), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $336 = $334 >>> 0 < 11; | |
| if ($336) { | |
| $337 = $334 << 1; | |
| $338 = $337 & 255; | |
| SAFE_HEAP_STORE($14 >> 0 | 0, $338 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $339 = $14 + 1 | 0; | |
| $__p$0$ph$i$i$i = $339; | |
| } else { | |
| $340 = $334 + 16 | 0; | |
| $341 = $340 & -16; | |
| $342 = (tempInt = _malloc($341) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $343 = $14 + 8 | 0; | |
| SAFE_HEAP_STORE($343 | 0, $342 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $344 = $341 | 1; | |
| SAFE_HEAP_STORE($14 | 0, $344 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $345 = $14 + 4 | 0; | |
| SAFE_HEAP_STORE($345 | 0, $334 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__p$0$ph$i$i$i = $342; | |
| } | |
| $$0$i$i$i272 = $235; | |
| $349 = $first; | |
| $__p$0$i$i$i = $__p$0$ph$i$i$i; | |
| while (1) { | |
| $346 = ($$0$i$i$i272 | 0) == ($284 | 0); | |
| if ($346) { | |
| break; | |
| } | |
| $347 = (tempInt = SAFE_HEAP_LOAD($$0$i$i$i272 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($__p$0$i$i$i >> 0 | 0, $347 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $348 = $349 + 2 | 0; | |
| $350 = $__p$0$i$i$i + 1 | 0; | |
| $349$phi = $$0$i$i$i272; | |
| $$0$i$i$i272 = $348; | |
| $__p$0$i$i$i = $350; | |
| $349 = $349$phi; | |
| } | |
| $scevgep2$i$i$i = $__p$0$ph$i$i$i + $334 | 0; | |
| SAFE_HEAP_STORE($scevgep2$i$i$i >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| $351 = (tempInt = invoke_iiii(4, $14 | 0, 0, 2744 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $352 = __THREW__; | |
| __THREW__ = 0; | |
| $353 = $352 & 1; | |
| if ($353) { | |
| $375 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $376 = tempRet0; | |
| $$1$i281 = $376; | |
| $$13$i = $375; | |
| } else { | |
| SAFE_HEAP_STORE($13 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($351 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($13 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($351 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($13 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($351 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i274 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i275 = ($__i$0$i$i$i$i274 | 0) == 3; | |
| if ($exitcond$i$i$i$i275) { | |
| break; | |
| } | |
| $354 = $351 + ($__i$0$i$i$i$i274 << 2) | 0; | |
| SAFE_HEAP_STORE($354 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $355 = $__i$0$i$i$i$i274 + 1 | 0; | |
| $__i$0$i$i$i$i274 = $355; | |
| } | |
| __THREW__ = 0; | |
| $356 = (tempInt = invoke_iii(5, $13 | 0, 2880 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $357 = __THREW__; | |
| __THREW__ = 0; | |
| $358 = $357 & 1; | |
| do { | |
| if ($358) { | |
| $377 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $378 = tempRet0; | |
| $$01$i280 = $378; | |
| $$02$i = $377; | |
| } else { | |
| SAFE_HEAP_STORE($12 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($356 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($12 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($356 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($12 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($356 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i18$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i19$i = ($__i$0$i$i$i18$i | 0) == 3; | |
| if ($exitcond$i$i$i19$i) { | |
| break; | |
| } | |
| $359 = $356 + ($__i$0$i$i$i18$i << 2) | 0; | |
| SAFE_HEAP_STORE($359 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $360 = $__i$0$i$i$i18$i + 1 | 0; | |
| $__i$0$i$i$i18$i = $360; | |
| } | |
| $361 = (tempInt = SAFE_HEAP_LOAD($12 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $362 = $361 & 1; | |
| $363 = $362 << 24 >> 24 == 0; | |
| if ($363) { | |
| $368 = $12 + 1 | 0; | |
| $369 = $361 & 255; | |
| $370 = $369 >>> 1; | |
| $371 = $368; | |
| $372 = $370; | |
| } else { | |
| $364 = $12 + 8 | 0; | |
| $365 = (tempInt = SAFE_HEAP_LOAD($364 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $366 = $12 + 4 | 0; | |
| $367 = (tempInt = SAFE_HEAP_LOAD($366 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $371 = $365; | |
| $372 = $367; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiiii(11, $331 | 0, 0, $371 | 0, $372 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $373 = __THREW__; | |
| __THREW__ = 0; | |
| $374 = $373 & 1; | |
| if ($374) { | |
| $379 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $380 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($12), asyncState ? abort(-12) | 0 : 0; | |
| $$01$i280 = $380; | |
| $$02$i = $379; | |
| break; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($12), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($13), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($14), asyncState ? abort(-12) | 0 : 0; | |
| $$0$i = $289; | |
| break L90; | |
| } | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($13), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i281 = $$01$i280; | |
| $$13$i = $$02$i; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($14), asyncState ? abort(-12) | 0 : 0; | |
| $$6$i307 = $$1$i281; | |
| $$68$i = $$13$i; | |
| } else { | |
| $381 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_116parse_expressionINS0_2DbEEEPKcS4_S4_RT_($235, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $382 = ($381 | 0) == ($235 | 0); | |
| $383 = ($381 | 0) == ($last | 0); | |
| $or$cond10$i = $382 | $383; | |
| if ($or$cond10$i) { | |
| $$0$i = $first; | |
| break; | |
| } | |
| $384 = (tempInt = SAFE_HEAP_LOAD($381 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $385 = $384 << 24 >> 24 == 95; | |
| if (!$385) { | |
| $$0$i = $first; | |
| break; | |
| } | |
| $386 = $381 + 1 | 0; | |
| $387 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($386, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $388 = ($387 | 0) == ($386 | 0); | |
| if ($388) { | |
| $$0$i = $first; | |
| break; | |
| } | |
| $389 = $db + 4 | 0; | |
| $390 = (tempInt = SAFE_HEAP_LOAD($389 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $391 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $392 = $390; | |
| $393 = $391; | |
| $394 = $392 - $393 | 0; | |
| $395 = ($394 | 0) / 24 & -1; | |
| $396 = $395 >>> 0 < 2; | |
| if ($396) { | |
| $$0$i = $first; | |
| break; | |
| } | |
| $397 = $390 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2EOS1_($type$i, $397), asyncState ? abort(-12) | 0 : 0; | |
| $398 = (tempInt = SAFE_HEAP_LOAD($389 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $399 = $398 + -24 | 0; | |
| $401 = $398; | |
| while (1) { | |
| $400 = ($401 | 0) == ($399 | 0); | |
| if ($400) { | |
| break; | |
| } | |
| $402 = $401 + -24 | 0; | |
| SAFE_HEAP_STORE($389 | 0, $402 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($402), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i282 = (tempInt = SAFE_HEAP_LOAD($389 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $401 = $$pre$i$i282; | |
| } | |
| $403 = $398 + -48 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2EOS1_($expr$i, $403), asyncState ? abort(-12) | 0 : 0; | |
| $404 = (tempInt = SAFE_HEAP_LOAD($389 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $405 = $404 + -24 | 0; | |
| $406 = (tempInt = SAFE_HEAP_LOAD($405 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $407 = $406 & 1; | |
| $408 = $407 << 24 >> 24 == 0; | |
| do { | |
| if ($408) { | |
| $409 = $405 + 1 | 0; | |
| SAFE_HEAP_STORE($409 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($405 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $410 = $404 + -16 | 0; | |
| $411 = (tempInt = SAFE_HEAP_LOAD($410 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($411 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $412 = $404 + -20 | 0; | |
| SAFE_HEAP_STORE($412 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i$i$i285 = (tempInt = SAFE_HEAP_LOAD($405 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $413 = $$pre$i$i$i$i285 & 1; | |
| $414 = $413 << 24 >> 24 == 0; | |
| if ($414) { | |
| $419 = $$pre$i$i$i$i285; | |
| $428 = 10; | |
| } else { | |
| $415 = (tempInt = SAFE_HEAP_LOAD($405 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $416 = $415 & -2; | |
| $phitmp$i$i$i$i$i$i$i287 = $416 + -1 | 0; | |
| $417 = $415 & 255; | |
| $419 = $417; | |
| $428 = $phitmp$i$i$i$i$i$i$i287; | |
| } | |
| $418 = $419 & 1; | |
| $420 = $418 << 24 >> 24 == 0; | |
| do { | |
| if ($420) { | |
| $421 = $419 & 255; | |
| $422 = $421 >>> 1; | |
| $423 = ($419 & 255) < 22; | |
| if ($423) { | |
| $2935 = 1; | |
| $427 = 10; | |
| $447 = $422; | |
| break; | |
| } | |
| $424 = $422 + 16 | 0; | |
| $425 = $424 & 240; | |
| $phitmp$i2$i$i$i$i$i$i290 = $425 + -1 | 0; | |
| $2935 = 1; | |
| $427 = $phitmp$i2$i$i$i$i$i$i290; | |
| $447 = $422; | |
| } else { | |
| $2935 = 0; | |
| $427 = 10; | |
| $447 = 0; | |
| } | |
| } while (0); | |
| $426 = ($427 | 0) == ($428 | 0); | |
| if (!$426) { | |
| $429 = ($427 | 0) == 10; | |
| if ($429) { | |
| $434 = $405 + 1 | 0; | |
| $435 = (tempInt = SAFE_HEAP_LOAD($410 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2935) { | |
| $436 = $419 & 255; | |
| $437 = $436 >>> 1; | |
| $438 = $437 + 1 | 0; | |
| (tempInt = _memcpy($434 | 0, $435 | 0, $438 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($435), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $443 = (tempInt = SAFE_HEAP_LOAD($435 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($434 >> 0 | 0, $443 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($435), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $448 = $447 << 1; | |
| $449 = $448 & 255; | |
| SAFE_HEAP_STORE($405 >> 0 | 0, $449 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $430 = $427 >>> 0 <= $428 >>> 0; | |
| $431 = $427 + 1 | 0; | |
| $432 = (tempInt = _malloc($431) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $433 = ($432 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i$i292 = $430 & $433; | |
| if ($or$cond$i$i$i$i$i$i292) { | |
| break; | |
| } | |
| if ($2935) { | |
| $439 = $405 + 1 | 0; | |
| $440 = $419 & 255; | |
| $441 = $440 >>> 1; | |
| $442 = $441 + 1 | 0; | |
| (tempInt = _memcpy($432 | 0, $439 | 0, $442 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } else { | |
| $444 = (tempInt = SAFE_HEAP_LOAD($410 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $445 = (tempInt = SAFE_HEAP_LOAD($444 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($432 >> 0 | 0, $445 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($444), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $446 = $431 | 1; | |
| SAFE_HEAP_STORE($405 | 0, $446 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($412 | 0, $447 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($410 | 0, $432 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($405 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($type$i + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($405 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($type$i + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($405 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($type$i + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i$i300 = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i$i301 = ($__i$0$i$i$i$i$i300 | 0) == 3; | |
| if ($exitcond$i$i$i$i$i301) { | |
| break; | |
| } | |
| $450 = $type$i + ($__i$0$i$i$i$i$i300 << 2) | 0; | |
| SAFE_HEAP_STORE($450 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $451 = $__i$0$i$i$i$i$i300 + 1 | 0; | |
| $__i$0$i$i$i$i$i300 = $451; | |
| } | |
| $452 = $type$i + 12 | 0; | |
| $453 = (tempInt = SAFE_HEAP_LOAD($452 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $454 = $453 & 1; | |
| $455 = $454 << 24 >> 24 == 0; | |
| if ($455) { | |
| $460 = $453 & 255; | |
| $461 = $460 >>> 1; | |
| $462 = $452 + 1 | 0; | |
| $464 = $461; | |
| $466 = $462; | |
| } else { | |
| $456 = $type$i + 16 | 0; | |
| $457 = (tempInt = SAFE_HEAP_LOAD($456 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $458 = $type$i + 20 | 0; | |
| $459 = (tempInt = SAFE_HEAP_LOAD($458 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $464 = $457; | |
| $466 = $459; | |
| } | |
| $463 = $464 >>> 0 < 2; | |
| $465 = $463 ? $464 : 2; | |
| __THREW__ = 0; | |
| invoke_viii(13, $15 | 0, $466 | 0, $465 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $467 = __THREW__; | |
| __THREW__ = 0; | |
| $468 = $467 & 1; | |
| do { | |
| if ($468) { | |
| label = 155; | |
| } else { | |
| $469 = (tempInt = SAFE_HEAP_LOAD($15 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $470 = $469 & 1; | |
| $471 = $470 << 24 >> 24 == 0; | |
| if ($471) { | |
| $476 = $469 & 255; | |
| $477 = $476 >>> 1; | |
| $478 = $15 + 1 | 0; | |
| $480 = $477; | |
| $482 = $478; | |
| } else { | |
| $472 = $15 + 4 | 0; | |
| $473 = (tempInt = SAFE_HEAP_LOAD($472 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $474 = $15 + 8 | 0; | |
| $475 = (tempInt = SAFE_HEAP_LOAD($474 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $480 = $473; | |
| $482 = $475; | |
| } | |
| $479 = $480 >>> 0 > 2; | |
| $481 = $479 ? 2 : $480; | |
| $483 = (tempInt = _memcmp($482, 2744, $481) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $484 = ($483 | 0) != 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($15), asyncState ? abort(-12) | 0 : 0; | |
| $485 = ($480 | 0) != 2; | |
| $486 = $485 | $484; | |
| if (!$486) { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE5eraseEjj($452), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $489 = (tempInt = SAFE_HEAP_LOAD($389 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $490 = $489 + -12 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $19 | 0, $expr$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| $491 = __THREW__; | |
| __THREW__ = 0; | |
| $492 = $491 & 1; | |
| if ($492) { | |
| label = 155; | |
| break; | |
| } | |
| __THREW__ = 0; | |
| $493 = (tempInt = invoke_iiii(4, $19 | 0, 0, 2744 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $494 = __THREW__; | |
| __THREW__ = 0; | |
| $495 = $494 & 1; | |
| if ($495) { | |
| $566 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $567 = tempRet0; | |
| $$4$i305 = $567; | |
| $$46$i = $566; | |
| } else { | |
| SAFE_HEAP_STORE($18 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($493 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($18 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($493 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($18 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($493 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i30$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i31$i = ($__i$0$i$i$i30$i | 0) == 3; | |
| if ($exitcond$i$i$i31$i) { | |
| break; | |
| } | |
| $496 = $493 + ($__i$0$i$i$i30$i << 2) | 0; | |
| SAFE_HEAP_STORE($496 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $497 = $__i$0$i$i$i30$i + 1 | 0; | |
| $__i$0$i$i$i30$i = $497; | |
| } | |
| __THREW__ = 0; | |
| $498 = (tempInt = invoke_iii(5, $18 | 0, 2880 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $499 = __THREW__; | |
| __THREW__ = 0; | |
| $500 = $499 & 1; | |
| do { | |
| if ($500) { | |
| $568 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $569 = tempRet0; | |
| $$3$i = $569; | |
| $$35$i = $568; | |
| } else { | |
| SAFE_HEAP_STORE($17 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($498 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($17 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($498 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($17 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($498 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i34$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i35$i = ($__i$0$i$i$i34$i | 0) == 3; | |
| if ($exitcond$i$i$i35$i) { | |
| break; | |
| } | |
| $501 = $498 + ($__i$0$i$i$i34$i << 2) | 0; | |
| SAFE_HEAP_STORE($501 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $502 = $__i$0$i$i$i34$i + 1 | 0; | |
| $__i$0$i$i$i34$i = $502; | |
| } | |
| $503 = (tempInt = SAFE_HEAP_LOAD($452 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $504 = $503 & 1; | |
| $505 = $504 << 24 >> 24 == 0; | |
| if ($505) { | |
| $510 = $452 + 1 | 0; | |
| $511 = $503 & 255; | |
| $512 = $511 >>> 1; | |
| $513 = $510; | |
| $514 = $512; | |
| } else { | |
| $506 = $type$i + 20 | 0; | |
| $507 = (tempInt = SAFE_HEAP_LOAD($506 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $508 = $type$i + 16 | 0; | |
| $509 = (tempInt = SAFE_HEAP_LOAD($508 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $513 = $507; | |
| $514 = $509; | |
| } | |
| __THREW__ = 0; | |
| $515 = (tempInt = invoke_iiii(3, $17 | 0, $513 | 0, $514 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $516 = __THREW__; | |
| __THREW__ = 0; | |
| $517 = $516 & 1; | |
| if ($517) { | |
| $570 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $571 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($17), asyncState ? abort(-12) | 0 : 0; | |
| $$3$i = $571; | |
| $$35$i = $570; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($16 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($515 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($16 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($515 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($16 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($515 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i38$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i39$i = ($__i$0$i$i$i38$i | 0) == 3; | |
| if ($exitcond$i$i$i39$i) { | |
| break; | |
| } | |
| $518 = $515 + ($__i$0$i$i$i38$i << 2) | 0; | |
| SAFE_HEAP_STORE($518 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $519 = $__i$0$i$i$i38$i + 1 | 0; | |
| $__i$0$i$i$i38$i = $519; | |
| } | |
| $520 = (tempInt = SAFE_HEAP_LOAD($490 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $521 = $520 & 1; | |
| $522 = $521 << 24 >> 24 == 0; | |
| do { | |
| if ($522) { | |
| $523 = $490 + 1 | 0; | |
| SAFE_HEAP_STORE($523 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($490 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $524 = $489 + -4 | 0; | |
| $525 = (tempInt = SAFE_HEAP_LOAD($524 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($525 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $526 = $489 + -8 | 0; | |
| SAFE_HEAP_STORE($526 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i$i42$i = (tempInt = SAFE_HEAP_LOAD($490 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $527 = $$pre$i$i$i42$i & 1; | |
| $528 = $527 << 24 >> 24 == 0; | |
| if ($528) { | |
| $533 = $$pre$i$i$i42$i; | |
| $542 = 10; | |
| } else { | |
| $529 = (tempInt = SAFE_HEAP_LOAD($490 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $530 = $529 & -2; | |
| $phitmp$i$i$i$i$i$i44$i = $530 + -1 | 0; | |
| $531 = $529 & 255; | |
| $533 = $531; | |
| $542 = $phitmp$i$i$i$i$i$i44$i; | |
| } | |
| $532 = $533 & 1; | |
| $534 = $532 << 24 >> 24 == 0; | |
| do { | |
| if ($534) { | |
| $535 = $533 & 255; | |
| $536 = $535 >>> 1; | |
| $537 = ($533 & 255) < 22; | |
| if ($537) { | |
| $2936 = 1; | |
| $541 = 10; | |
| $561 = $536; | |
| break; | |
| } | |
| $538 = $536 + 16 | 0; | |
| $539 = $538 & 240; | |
| $phitmp$i2$i$i$i$i$i47$i = $539 + -1 | 0; | |
| $2936 = 1; | |
| $541 = $phitmp$i2$i$i$i$i$i47$i; | |
| $561 = $536; | |
| } else { | |
| $2936 = 0; | |
| $541 = 10; | |
| $561 = 0; | |
| } | |
| } while (0); | |
| $540 = ($541 | 0) == ($542 | 0); | |
| if ($540) { | |
| break; | |
| } | |
| $543 = ($541 | 0) == 10; | |
| if ($543) { | |
| $548 = $490 + 1 | 0; | |
| $549 = (tempInt = SAFE_HEAP_LOAD($524 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2936) { | |
| $550 = $533 & 255; | |
| $551 = $550 >>> 1; | |
| $552 = $551 + 1 | 0; | |
| (tempInt = _memcpy($548 | 0, $549 | 0, $552 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($549), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $557 = (tempInt = SAFE_HEAP_LOAD($549 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($548 >> 0 | 0, $557 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($549), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $562 = $561 << 1; | |
| $563 = $562 & 255; | |
| SAFE_HEAP_STORE($490 >> 0 | 0, $563 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $544 = $541 >>> 0 <= $542 >>> 0; | |
| $545 = $541 + 1 | 0; | |
| $546 = (tempInt = _malloc($545) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $547 = ($546 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i49$i = $544 & $547; | |
| if ($or$cond$i$i$i$i$i49$i) { | |
| break; | |
| } | |
| if ($2936) { | |
| $553 = $490 + 1 | 0; | |
| $554 = $533 & 255; | |
| $555 = $554 >>> 1; | |
| $556 = $555 + 1 | 0; | |
| (tempInt = _memcpy($546 | 0, $553 | 0, $556 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } else { | |
| $558 = (tempInt = SAFE_HEAP_LOAD($524 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $559 = (tempInt = SAFE_HEAP_LOAD($558 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($546 >> 0 | 0, $559 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($558), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $560 = $545 | 1; | |
| SAFE_HEAP_STORE($490 | 0, $560 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($526 | 0, $561 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($524 | 0, $546 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($490 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($16 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($490 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($16 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($490 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($16 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i57$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i58$i = ($__i$0$i$i$i$i57$i | 0) == 3; | |
| if ($exitcond$i$i$i$i58$i) { | |
| break; | |
| } | |
| $564 = $16 + ($__i$0$i$i$i$i57$i << 2) | 0; | |
| SAFE_HEAP_STORE($564 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $565 = $__i$0$i$i$i$i57$i + 1 | 0; | |
| $__i$0$i$i$i$i57$i = $565; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($16), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($17), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($18), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($19), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($expr$i), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($type$i), asyncState ? abort(-12) | 0 : 0; | |
| $$0$i = $387; | |
| break L90; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($18), asyncState ? abort(-12) | 0 : 0; | |
| $$4$i305 = $$3$i; | |
| $$46$i = $$35$i; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($19), asyncState ? abort(-12) | 0 : 0; | |
| $$5$i306 = $$4$i305; | |
| $$57$i = $$46$i; | |
| } | |
| } while (0); | |
| if ((label | 0) == 155) { | |
| $487 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $488 = tempRet0; | |
| $$5$i306 = $488; | |
| $$57$i = $487; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($expr$i), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($type$i), asyncState ? abort(-12) | 0 : 0; | |
| $$6$i307 = $$5$i306; | |
| $$68$i = $$57$i; | |
| } | |
| ___resumeException($$68$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } else { | |
| $$0$i = $first; | |
| } | |
| } while (0); | |
| $572 = ($$0$i | 0) == ($first | 0); | |
| if ($572) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $573 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $574 = $db + 4 | 0; | |
| $575 = (tempInt = SAFE_HEAP_LOAD($574 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $576 = ($573 | 0) == ($575 | 0); | |
| if ($576) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $577 = $db + 16 | 0; | |
| $578 = $575 + -24 | 0; | |
| $579 = $db + 12 | 0; | |
| $580 = (tempInt = SAFE_HEAP_LOAD($579 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($31 | 0, $580 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEC2EjRKS3_RKS5_($30, $578, $31), asyncState ? abort(-12) | 0 : 0; | |
| $581 = $db + 20 | 0; | |
| $582 = (tempInt = SAFE_HEAP_LOAD($581 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $583 = $db + 24 | 0; | |
| $584 = (tempInt = SAFE_HEAP_LOAD($583 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $585 = $582 >>> 0 < $584 >>> 0; | |
| if ($585) { | |
| $586 = ($582 | 0) == (0 | 0); | |
| if ($586) { | |
| $598 = 0; | |
| } else { | |
| $587 = $582 + 4 | 0; | |
| $588 = $30 + 12 | 0; | |
| $589 = (tempInt = SAFE_HEAP_LOAD($588 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $590 = $582 + 8 | 0; | |
| $591 = $582 + 12 | 0; | |
| SAFE_HEAP_STORE($591 | 0, $589 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $592 = (tempInt = SAFE_HEAP_LOAD($30 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($582 | 0, $592 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $593 = $30 + 4 | 0; | |
| $594 = (tempInt = SAFE_HEAP_LOAD($593 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($587 | 0, $594 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $595 = $30 + 8 | 0; | |
| $596 = (tempInt = SAFE_HEAP_LOAD($595 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($590 | 0, $596 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($595 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($593 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($30 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i77 = (tempInt = SAFE_HEAP_LOAD($581 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $598 = $$pre$i77; | |
| } | |
| $597 = $598 + 16 | 0; | |
| SAFE_HEAP_STORE($581 | 0, $597 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $599 = $db + 28 | 0; | |
| $600 = (tempInt = SAFE_HEAP_LOAD($577 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $601 = $582; | |
| $602 = $600; | |
| $603 = $601 - $602 | 0; | |
| $604 = $603 >> 4; | |
| $605 = $604 + 1 | 0; | |
| $606 = ($603 | 0) < -16; | |
| if ($606) { | |
| __THREW__ = 0; | |
| invoke_vi(14, $577 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $607 = __THREW__; | |
| __THREW__ = 0; | |
| $608 = $607 & 1; | |
| if ($608) { | |
| $630 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $631 = tempRet0; | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($30), asyncState ? abort(-12) | 0 : 0; | |
| $$10 = $630; | |
| $$1013 = $631; | |
| break L88; | |
| } else {} | |
| } | |
| $609 = $584; | |
| $610 = $609 - $602 | 0; | |
| $611 = $610 >> 4; | |
| $612 = $611 >>> 0 < 1073741823; | |
| if ($612) { | |
| $613 = $610 >> 3; | |
| $614 = $613 >>> 0 < $605 >>> 0; | |
| $615 = $614 ? $605 : $613; | |
| $$0$i$i$i79 = $615; | |
| } else { | |
| $$0$i$i$i79 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEEC2EjjS9_($__v$i$i76, $$0$i$i$i79, $604, $599), asyncState ? abort(-12) | 0 : 0; | |
| $616 = $__v$i$i76 + 8 | 0; | |
| $617 = (tempInt = SAFE_HEAP_LOAD($616 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $618 = ($617 | 0) == (0 | 0); | |
| if (!$618) { | |
| $619 = $617 + 4 | 0; | |
| $620 = $30 + 12 | 0; | |
| $621 = (tempInt = SAFE_HEAP_LOAD($620 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $622 = $617 + 8 | 0; | |
| $623 = $617 + 12 | 0; | |
| SAFE_HEAP_STORE($623 | 0, $621 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $624 = (tempInt = SAFE_HEAP_LOAD($30 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($617 | 0, $624 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $625 = $30 + 4 | 0; | |
| $626 = (tempInt = SAFE_HEAP_LOAD($625 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($619 | 0, $626 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $627 = $30 + 8 | 0; | |
| $628 = (tempInt = SAFE_HEAP_LOAD($627 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($622 | 0, $628 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($627 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($625 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($30 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $629 = $617 + 16 | 0; | |
| SAFE_HEAP_STORE($616 | 0, $629 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorINS0_IN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEENS4_IS6_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS6_RS7_EE($577, $__v$i$i76), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEED2Ev($__v$i$i76), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($30), asyncState ? abort(-12) | 0 : 0; | |
| $$0 = $$0$i; | |
| break L1; | |
| break; | |
| } | |
| case 67: | |
| { | |
| $632 = $first + 1 | 0; | |
| $633 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($632, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $634 = ($633 | 0) == ($632 | 0); | |
| if ($634) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $635 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $636 = $db + 4 | 0; | |
| $637 = (tempInt = SAFE_HEAP_LOAD($636 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $638 = ($635 | 0) == ($637 | 0); | |
| if ($638) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $639 = $637 + -24 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($639, 2712) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $640 = $db + 16 | 0; | |
| $641 = (tempInt = SAFE_HEAP_LOAD($636 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $642 = $641 + -24 | 0; | |
| $643 = $db + 12 | 0; | |
| $644 = (tempInt = SAFE_HEAP_LOAD($643 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($33 | 0, $644 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEC2EjRKS3_RKS5_($32, $642, $33), asyncState ? abort(-12) | 0 : 0; | |
| $645 = $db + 20 | 0; | |
| $646 = (tempInt = SAFE_HEAP_LOAD($645 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $647 = $db + 24 | 0; | |
| $648 = (tempInt = SAFE_HEAP_LOAD($647 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $649 = $646 >>> 0 < $648 >>> 0; | |
| if ($649) { | |
| $650 = ($646 | 0) == (0 | 0); | |
| if ($650) { | |
| $662 = 0; | |
| } else { | |
| $651 = $646 + 4 | 0; | |
| $652 = $32 + 12 | 0; | |
| $653 = (tempInt = SAFE_HEAP_LOAD($652 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $654 = $646 + 8 | 0; | |
| $655 = $646 + 12 | 0; | |
| SAFE_HEAP_STORE($655 | 0, $653 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $656 = (tempInt = SAFE_HEAP_LOAD($32 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($646 | 0, $656 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $657 = $32 + 4 | 0; | |
| $658 = (tempInt = SAFE_HEAP_LOAD($657 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($651 | 0, $658 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $659 = $32 + 8 | 0; | |
| $660 = (tempInt = SAFE_HEAP_LOAD($659 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($654 | 0, $660 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($659 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($657 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($32 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i85 = (tempInt = SAFE_HEAP_LOAD($645 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $662 = $$pre$i85; | |
| } | |
| $661 = $662 + 16 | 0; | |
| SAFE_HEAP_STORE($645 | 0, $661 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $663 = $db + 28 | 0; | |
| $664 = (tempInt = SAFE_HEAP_LOAD($640 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $665 = $646; | |
| $666 = $664; | |
| $667 = $665 - $666 | 0; | |
| $668 = $667 >> 4; | |
| $669 = $668 + 1 | 0; | |
| $670 = ($667 | 0) < -16; | |
| if ($670) { | |
| __THREW__ = 0; | |
| invoke_vi(14, $640 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $671 = __THREW__; | |
| __THREW__ = 0; | |
| $672 = $671 & 1; | |
| if ($672) { | |
| $694 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $695 = tempRet0; | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($32), asyncState ? abort(-12) | 0 : 0; | |
| $$10 = $694; | |
| $$1013 = $695; | |
| break L88; | |
| } else {} | |
| } | |
| $673 = $648; | |
| $674 = $673 - $666 | 0; | |
| $675 = $674 >> 4; | |
| $676 = $675 >>> 0 < 1073741823; | |
| if ($676) { | |
| $677 = $674 >> 3; | |
| $678 = $677 >>> 0 < $669 >>> 0; | |
| $679 = $678 ? $669 : $677; | |
| $$0$i$i$i87 = $679; | |
| } else { | |
| $$0$i$i$i87 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEEC2EjjS9_($__v$i$i84, $$0$i$i$i87, $668, $663), asyncState ? abort(-12) | 0 : 0; | |
| $680 = $__v$i$i84 + 8 | 0; | |
| $681 = (tempInt = SAFE_HEAP_LOAD($680 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $682 = ($681 | 0) == (0 | 0); | |
| if (!$682) { | |
| $683 = $681 + 4 | 0; | |
| $684 = $32 + 12 | 0; | |
| $685 = (tempInt = SAFE_HEAP_LOAD($684 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $686 = $681 + 8 | 0; | |
| $687 = $681 + 12 | 0; | |
| SAFE_HEAP_STORE($687 | 0, $685 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $688 = (tempInt = SAFE_HEAP_LOAD($32 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($681 | 0, $688 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $689 = $32 + 4 | 0; | |
| $690 = (tempInt = SAFE_HEAP_LOAD($689 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($683 | 0, $690 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $691 = $32 + 8 | 0; | |
| $692 = (tempInt = SAFE_HEAP_LOAD($691 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($686 | 0, $692 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($691 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($689 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($32 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $693 = $681 + 16 | 0; | |
| SAFE_HEAP_STORE($680 | 0, $693 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorINS0_IN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEENS4_IS6_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS6_RS7_EE($640, $__v$i$i84), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEED2Ev($__v$i$i84), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($32), asyncState ? abort(-12) | 0 : 0; | |
| $$0 = $633; | |
| break L1; | |
| break; | |
| } | |
| case 70: | |
| { | |
| $696 = $232 << 24 >> 24 == 70; | |
| do { | |
| if ($696) { | |
| $697 = $first + 1 | 0; | |
| $698 = ($697 | 0) == ($last | 0); | |
| if (!$698) { | |
| $699 = (tempInt = SAFE_HEAP_LOAD($697 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $700 = $699 << 24 >> 24 == 89; | |
| if ($700) { | |
| $701 = $first + 2 | 0; | |
| $702 = ($701 | 0) == ($last | 0); | |
| if ($702) { | |
| break; | |
| } else { | |
| $t$0$i = $701; | |
| } | |
| } else { | |
| $t$0$i = $697; | |
| } | |
| $703 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($t$0$i, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $704 = ($703 | 0) == ($t$0$i | 0); | |
| if (!$704) { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($sig$i, 2768, 1), asyncState ? abort(-12) | 0 : 0; | |
| $705 = $db + 4 | 0; | |
| $706 = $20 + 1 | 0; | |
| $707 = $20 + 8 | 0; | |
| $708 = $20 + 4 | 0; | |
| $709 = $sig$i + 4 | 0; | |
| $ref_qual$0$i$ph = 0; | |
| $t$1$i$ph = $703; | |
| L322 : while (1) { | |
| $t$1$i = $t$1$i$ph; | |
| while (1) { | |
| $710 = ($t$1$i | 0) == ($last | 0); | |
| if ($710) { | |
| label = 243; | |
| break L322; | |
| } | |
| $722 = (tempInt = SAFE_HEAP_LOAD($t$1$i >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($722 << 24 >> 24 == 69) { | |
| $ref_qual$0$i$ph$lcssa569 = $ref_qual$0$i$ph; | |
| $t$1$i$lcssa563 = $t$1$i; | |
| label = 251; | |
| break L322; | |
| } else if ($722 << 24 >> 24 == 118) { | |
| $726 = $t$1$i + 1 | 0; | |
| $t$1$i$be = $726; | |
| } else if ($722 << 24 >> 24 == 82) { | |
| $727 = $t$1$i + 1 | 0; | |
| $728 = ($727 | 0) == ($last | 0); | |
| if ($728) { | |
| label = 259; | |
| } else { | |
| $729 = (tempInt = SAFE_HEAP_LOAD($727 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $730 = $729 << 24 >> 24 == 69; | |
| if ($730) { | |
| $ref_qual$0$i$ph$ph = 1; | |
| $t$1$i$ph$ph = $727; | |
| break; | |
| } else { | |
| label = 259; | |
| } | |
| } | |
| } else if ($722 << 24 >> 24 == 79) { | |
| $731 = $t$1$i + 1 | 0; | |
| $732 = ($731 | 0) == ($last | 0); | |
| if ($732) { | |
| label = 259; | |
| } else { | |
| $733 = (tempInt = SAFE_HEAP_LOAD($731 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $734 = $733 << 24 >> 24 == 69; | |
| if ($734) { | |
| $ref_qual$0$i$ph$ph = 2; | |
| $t$1$i$ph$ph = $731; | |
| break; | |
| } else { | |
| label = 259; | |
| } | |
| } | |
| } else { | |
| label = 259; | |
| } | |
| if ((label | 0) == 259) { | |
| label = 0; | |
| $735 = (tempInt = SAFE_HEAP_LOAD($705 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $736 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $737 = $735; | |
| $738 = $736; | |
| $739 = $737 - $738 | 0; | |
| $740 = ($739 | 0) / 24 & -1; | |
| __THREW__ = 0; | |
| $741 = (tempInt = invoke_iiii(6, $t$1$i | 0, $last | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $742 = __THREW__; | |
| __THREW__ = 0; | |
| $743 = $742 & 1; | |
| if ($743) { | |
| label = 247; | |
| break L322; | |
| } | |
| $744 = (tempInt = SAFE_HEAP_LOAD($705 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $745 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $746 = $744; | |
| $747 = $745; | |
| $748 = $746 - $747 | 0; | |
| $749 = ($748 | 0) / 24 & -1; | |
| $750 = ($741 | 0) == ($t$1$i | 0); | |
| $751 = ($741 | 0) == ($last | 0); | |
| $or$cond$i = $750 | $751; | |
| if ($or$cond$i) { | |
| label = 290; | |
| break L322; | |
| } | |
| $k$0$i = $740; | |
| while (1) { | |
| $752 = $k$0$i >>> 0 < $749 >>> 0; | |
| if (!$752) { | |
| break; | |
| } | |
| $753 = (tempInt = SAFE_HEAP_LOAD($sig$i >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $754 = $753 & 1; | |
| $755 = $754 << 24 >> 24 == 0; | |
| if ($755) { | |
| $757 = $753 & 255; | |
| $758 = $757 >>> 1; | |
| $760 = $758; | |
| } else { | |
| $756 = (tempInt = SAFE_HEAP_LOAD($709 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $760 = $756; | |
| } | |
| $759 = $760 >>> 0 > 1; | |
| if ($759) { | |
| __THREW__ = 0; | |
| (tempInt = invoke_iii(5, $sig$i | 0, 3256 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $761 = __THREW__; | |
| __THREW__ = 0; | |
| $762 = $761 & 1; | |
| if ($762) { | |
| label = 246; | |
| break L322; | |
| } | |
| } | |
| $763 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $764 = $763 + ($k$0$i * 24 | 0) | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $20 | 0, $764 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $765 = __THREW__; | |
| __THREW__ = 0; | |
| $766 = $765 & 1; | |
| if ($766) { | |
| label = 246; | |
| break L322; | |
| } | |
| $767 = (tempInt = SAFE_HEAP_LOAD($20 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $768 = $767 & 1; | |
| $769 = $768 << 24 >> 24 == 0; | |
| if ($769) { | |
| $772 = $767 & 255; | |
| $773 = $772 >>> 1; | |
| $774 = $706; | |
| $775 = $773; | |
| } else { | |
| $770 = (tempInt = SAFE_HEAP_LOAD($707 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $771 = (tempInt = SAFE_HEAP_LOAD($708 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $774 = $770; | |
| $775 = $771; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiii(3, $sig$i | 0, $774 | 0, $775 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $776 = __THREW__; | |
| __THREW__ = 0; | |
| $777 = $776 & 1; | |
| if ($777) { | |
| label = 275; | |
| break L322; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($20), asyncState ? abort(-12) | 0 : 0; | |
| $778 = $k$0$i + 1 | 0; | |
| $k$0$i = $778; | |
| } | |
| $k2$0$i = $740; | |
| while (1) { | |
| $781 = $k2$0$i >>> 0 < $749 >>> 0; | |
| if (!$781) { | |
| break; | |
| } | |
| $782 = (tempInt = SAFE_HEAP_LOAD($705 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $783 = $782 + -24 | 0; | |
| $785 = $782; | |
| while (1) { | |
| $784 = ($785 | 0) == ($783 | 0); | |
| if ($784) { | |
| break; | |
| } | |
| $786 = $785 + -24 | 0; | |
| SAFE_HEAP_STORE($705 | 0, $786 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($786), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i7$i = (tempInt = SAFE_HEAP_LOAD($705 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $785 = $$pre$i7$i; | |
| } | |
| $787 = $k2$0$i + 1 | 0; | |
| $k2$0$i = $787; | |
| } | |
| $t$1$i$be = $741; | |
| } | |
| $t$1$i = $t$1$i$be; | |
| } | |
| $ref_qual$0$i$ph = $ref_qual$0$i$ph$ph; | |
| $t$1$i$ph = $t$1$i$ph$ph; | |
| } | |
| L364 : do { | |
| if ((label | 0) == 243) { | |
| $711 = (tempInt = SAFE_HEAP_LOAD($705 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $712 = $711 + -24 | 0; | |
| $714 = $711; | |
| while (1) { | |
| $713 = ($714 | 0) == ($712 | 0); | |
| if ($713) { | |
| break; | |
| } | |
| $715 = $714 + -24 | 0; | |
| SAFE_HEAP_STORE($705 | 0, $715 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($715), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i261 = (tempInt = SAFE_HEAP_LOAD($705 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $714 = $$pre$i$i261; | |
| } | |
| label = 291; | |
| } else if ((label | 0) == 246) { | |
| $716 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $717 = tempRet0; | |
| $lpad$phi$index = $716; | |
| $lpad$phi$index8 = $717; | |
| label = 249; | |
| } else if ((label | 0) == 247) { | |
| $718 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $719 = tempRet0; | |
| $lpad$phi$index = $718; | |
| $lpad$phi$index8 = $719; | |
| label = 249; | |
| } else if ((label | 0) == 251) { | |
| $723 = $t$1$i$lcssa563 + 1 | 0; | |
| __THREW__ = 0; | |
| (tempInt = invoke_iii(5, $sig$i | 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $724 = __THREW__; | |
| __THREW__ = 0; | |
| $725 = $724 & 1; | |
| do { | |
| if (!$725) { | |
| if (($ref_qual$0$i$ph$lcssa569 | 0) == 1) { | |
| __THREW__ = 0; | |
| (tempInt = invoke_iii(5, $sig$i | 0, 5080 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $788 = __THREW__; | |
| __THREW__ = 0; | |
| $789 = $788 & 1; | |
| if ($789) { | |
| break; | |
| } | |
| } else if (($ref_qual$0$i$ph$lcssa569 | 0) == 2) { | |
| __THREW__ = 0; | |
| (tempInt = invoke_iii(5, $sig$i | 0, 5088 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $790 = __THREW__; | |
| __THREW__ = 0; | |
| $791 = $790 & 1; | |
| if ($791) { | |
| break; | |
| } | |
| } | |
| $792 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $793 = (tempInt = SAFE_HEAP_LOAD($705 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $794 = ($792 | 0) == ($793 | 0); | |
| if ($794) { | |
| label = 291; | |
| break L364; | |
| } | |
| $795 = $793 + -24 | 0; | |
| __THREW__ = 0; | |
| (tempInt = invoke_iii(5, $795 | 0, 2840 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $796 = __THREW__; | |
| __THREW__ = 0; | |
| $797 = $796 & 1; | |
| if (!$797) { | |
| $798 = (tempInt = SAFE_HEAP_LOAD($705 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $799 = $798 + -12 | 0; | |
| $800 = (tempInt = SAFE_HEAP_LOAD($sig$i >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $801 = $800 & 1; | |
| $802 = $801 << 24 >> 24 == 0; | |
| if ($802) { | |
| $806 = $sig$i + 1 | 0; | |
| $807 = $800 & 255; | |
| $808 = $807 >>> 1; | |
| $809 = $806; | |
| $810 = $808; | |
| } else { | |
| $803 = $sig$i + 8 | 0; | |
| $804 = (tempInt = SAFE_HEAP_LOAD($803 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $805 = (tempInt = SAFE_HEAP_LOAD($709 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $809 = $804; | |
| $810 = $805; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiiii(11, $799 | 0, 0, $809 | 0, $810 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $811 = __THREW__; | |
| __THREW__ = 0; | |
| $812 = $811 & 1; | |
| if (!$812) { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($sig$i), asyncState ? abort(-12) | 0 : 0; | |
| $813 = ($723 | 0) == ($first | 0); | |
| if ($813) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $814 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $815 = (tempInt = SAFE_HEAP_LOAD($705 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $816 = ($814 | 0) == ($815 | 0); | |
| if ($816) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $817 = $db + 16 | 0; | |
| $818 = $815 + -24 | 0; | |
| $819 = $db + 12 | 0; | |
| $820 = (tempInt = SAFE_HEAP_LOAD($819 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($35 | 0, $820 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEC2EjRKS3_RKS5_($34, $818, $35), asyncState ? abort(-12) | 0 : 0; | |
| $821 = $db + 20 | 0; | |
| $822 = (tempInt = SAFE_HEAP_LOAD($821 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $823 = $db + 24 | 0; | |
| $824 = (tempInt = SAFE_HEAP_LOAD($823 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $825 = $822 >>> 0 < $824 >>> 0; | |
| if ($825) { | |
| $826 = ($822 | 0) == (0 | 0); | |
| if ($826) { | |
| $838 = 0; | |
| } else { | |
| $827 = $822 + 4 | 0; | |
| $828 = $34 + 12 | 0; | |
| $829 = (tempInt = SAFE_HEAP_LOAD($828 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $830 = $822 + 8 | 0; | |
| $831 = $822 + 12 | 0; | |
| SAFE_HEAP_STORE($831 | 0, $829 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $832 = (tempInt = SAFE_HEAP_LOAD($34 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($822 | 0, $832 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $833 = $34 + 4 | 0; | |
| $834 = (tempInt = SAFE_HEAP_LOAD($833 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($827 | 0, $834 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $835 = $34 + 8 | 0; | |
| $836 = (tempInt = SAFE_HEAP_LOAD($835 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($830 | 0, $836 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($835 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($833 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($34 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i93 = (tempInt = SAFE_HEAP_LOAD($821 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $838 = $$pre$i93; | |
| } | |
| $837 = $838 + 16 | 0; | |
| SAFE_HEAP_STORE($821 | 0, $837 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $839 = $db + 28 | 0; | |
| $840 = (tempInt = SAFE_HEAP_LOAD($817 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $841 = $822; | |
| $842 = $840; | |
| $843 = $841 - $842 | 0; | |
| $844 = $843 >> 4; | |
| $845 = $844 + 1 | 0; | |
| $846 = ($843 | 0) < -16; | |
| if ($846) { | |
| __THREW__ = 0; | |
| invoke_vi(14, $817 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $847 = __THREW__; | |
| __THREW__ = 0; | |
| $848 = $847 & 1; | |
| if ($848) { | |
| $870 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $871 = tempRet0; | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($34), asyncState ? abort(-12) | 0 : 0; | |
| $$10 = $870; | |
| $$1013 = $871; | |
| break L88; | |
| } else {} | |
| } | |
| $849 = $824; | |
| $850 = $849 - $842 | 0; | |
| $851 = $850 >> 4; | |
| $852 = $851 >>> 0 < 1073741823; | |
| if ($852) { | |
| $853 = $850 >> 3; | |
| $854 = $853 >>> 0 < $845 >>> 0; | |
| $855 = $854 ? $845 : $853; | |
| $$0$i$i$i95 = $855; | |
| } else { | |
| $$0$i$i$i95 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEEC2EjjS9_($__v$i$i92, $$0$i$i$i95, $844, $839), asyncState ? abort(-12) | 0 : 0; | |
| $856 = $__v$i$i92 + 8 | 0; | |
| $857 = (tempInt = SAFE_HEAP_LOAD($856 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $858 = ($857 | 0) == (0 | 0); | |
| if (!$858) { | |
| $859 = $857 + 4 | 0; | |
| $860 = $34 + 12 | 0; | |
| $861 = (tempInt = SAFE_HEAP_LOAD($860 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $862 = $857 + 8 | 0; | |
| $863 = $857 + 12 | 0; | |
| SAFE_HEAP_STORE($863 | 0, $861 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $864 = (tempInt = SAFE_HEAP_LOAD($34 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($857 | 0, $864 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $865 = $34 + 4 | 0; | |
| $866 = (tempInt = SAFE_HEAP_LOAD($865 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($859 | 0, $866 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $867 = $34 + 8 | 0; | |
| $868 = (tempInt = SAFE_HEAP_LOAD($867 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($862 | 0, $868 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($867 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($865 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($34 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $869 = $857 + 16 | 0; | |
| SAFE_HEAP_STORE($856 | 0, $869 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorINS0_IN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEENS4_IS6_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS6_RS7_EE($817, $__v$i$i92), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEED2Ev($__v$i$i92), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($34), asyncState ? abort(-12) | 0 : 0; | |
| $$0 = $723; | |
| break L1; | |
| } | |
| } | |
| } | |
| } while (0); | |
| $720 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $721 = tempRet0; | |
| $lpad$phi$index = $720; | |
| $lpad$phi$index8 = $721; | |
| label = 249; | |
| } else if ((label | 0) == 275) { | |
| $779 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $780 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($20), asyncState ? abort(-12) | 0 : 0; | |
| $$04$i = $780; | |
| $$05$i = $779; | |
| } else if ((label | 0) == 290) { | |
| label = 291; | |
| } | |
| } while (0); | |
| if ((label | 0) == 249) { | |
| $$04$i = $lpad$phi$index8; | |
| $$05$i = $lpad$phi$index; | |
| } else if ((label | 0) == 291) { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($sig$i), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($sig$i), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$05$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } | |
| } while (0); | |
| $$0 = $first; | |
| break L1; | |
| break; | |
| } | |
| case 71: | |
| { | |
| $872 = $first + 1 | 0; | |
| $873 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($872, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $874 = ($873 | 0) == ($872 | 0); | |
| if ($874) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $875 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $876 = $db + 4 | 0; | |
| $877 = (tempInt = SAFE_HEAP_LOAD($876 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $878 = ($875 | 0) == ($877 | 0); | |
| if ($878) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $879 = $877 + -24 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($879, 2728) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $880 = $db + 16 | 0; | |
| $881 = (tempInt = SAFE_HEAP_LOAD($876 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $882 = $881 + -24 | 0; | |
| $883 = $db + 12 | 0; | |
| $884 = (tempInt = SAFE_HEAP_LOAD($883 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($37 | 0, $884 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEC2EjRKS3_RKS5_($36, $882, $37), asyncState ? abort(-12) | 0 : 0; | |
| $885 = $db + 20 | 0; | |
| $886 = (tempInt = SAFE_HEAP_LOAD($885 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $887 = $db + 24 | 0; | |
| $888 = (tempInt = SAFE_HEAP_LOAD($887 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $889 = $886 >>> 0 < $888 >>> 0; | |
| if ($889) { | |
| $890 = ($886 | 0) == (0 | 0); | |
| if ($890) { | |
| $902 = 0; | |
| } else { | |
| $891 = $886 + 4 | 0; | |
| $892 = $36 + 12 | 0; | |
| $893 = (tempInt = SAFE_HEAP_LOAD($892 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $894 = $886 + 8 | 0; | |
| $895 = $886 + 12 | 0; | |
| SAFE_HEAP_STORE($895 | 0, $893 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $896 = (tempInt = SAFE_HEAP_LOAD($36 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($886 | 0, $896 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $897 = $36 + 4 | 0; | |
| $898 = (tempInt = SAFE_HEAP_LOAD($897 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($891 | 0, $898 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $899 = $36 + 8 | 0; | |
| $900 = (tempInt = SAFE_HEAP_LOAD($899 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($894 | 0, $900 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($899 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($897 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($36 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i101 = (tempInt = SAFE_HEAP_LOAD($885 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $902 = $$pre$i101; | |
| } | |
| $901 = $902 + 16 | 0; | |
| SAFE_HEAP_STORE($885 | 0, $901 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $903 = $db + 28 | 0; | |
| $904 = (tempInt = SAFE_HEAP_LOAD($880 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $905 = $886; | |
| $906 = $904; | |
| $907 = $905 - $906 | 0; | |
| $908 = $907 >> 4; | |
| $909 = $908 + 1 | 0; | |
| $910 = ($907 | 0) < -16; | |
| if ($910) { | |
| __THREW__ = 0; | |
| invoke_vi(14, $880 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $911 = __THREW__; | |
| __THREW__ = 0; | |
| $912 = $911 & 1; | |
| if ($912) { | |
| $934 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $935 = tempRet0; | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($36), asyncState ? abort(-12) | 0 : 0; | |
| $$10 = $934; | |
| $$1013 = $935; | |
| break L88; | |
| } else {} | |
| } | |
| $913 = $888; | |
| $914 = $913 - $906 | 0; | |
| $915 = $914 >> 4; | |
| $916 = $915 >>> 0 < 1073741823; | |
| if ($916) { | |
| $917 = $914 >> 3; | |
| $918 = $917 >>> 0 < $909 >>> 0; | |
| $919 = $918 ? $909 : $917; | |
| $$0$i$i$i103 = $919; | |
| } else { | |
| $$0$i$i$i103 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEEC2EjjS9_($__v$i$i100, $$0$i$i$i103, $908, $903), asyncState ? abort(-12) | 0 : 0; | |
| $920 = $__v$i$i100 + 8 | 0; | |
| $921 = (tempInt = SAFE_HEAP_LOAD($920 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $922 = ($921 | 0) == (0 | 0); | |
| if (!$922) { | |
| $923 = $921 + 4 | 0; | |
| $924 = $36 + 12 | 0; | |
| $925 = (tempInt = SAFE_HEAP_LOAD($924 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $926 = $921 + 8 | 0; | |
| $927 = $921 + 12 | 0; | |
| SAFE_HEAP_STORE($927 | 0, $925 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $928 = (tempInt = SAFE_HEAP_LOAD($36 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($921 | 0, $928 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $929 = $36 + 4 | 0; | |
| $930 = (tempInt = SAFE_HEAP_LOAD($929 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($923 | 0, $930 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $931 = $36 + 8 | 0; | |
| $932 = (tempInt = SAFE_HEAP_LOAD($931 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($926 | 0, $932 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($931 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($929 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($36 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $933 = $921 + 16 | 0; | |
| SAFE_HEAP_STORE($920 | 0, $933 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorINS0_IN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEENS4_IS6_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS6_RS7_EE($880, $__v$i$i100), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEED2Ev($__v$i$i100), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($36), asyncState ? abort(-12) | 0 : 0; | |
| $$0 = $873; | |
| break L1; | |
| break; | |
| } | |
| case 77: | |
| { | |
| $936 = $232 << 24 >> 24 == 77; | |
| do { | |
| if ($936) { | |
| $937 = $first + 1 | 0; | |
| $938 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($937, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $939 = ($938 | 0) == ($937 | 0); | |
| if ($939) { | |
| $$08$i = $first; | |
| } else { | |
| $940 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($938, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $941 = ($940 | 0) == ($938 | 0); | |
| if ($941) { | |
| $$08$i = $first; | |
| } else { | |
| $942 = $db + 4 | 0; | |
| $943 = (tempInt = SAFE_HEAP_LOAD($942 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $944 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $945 = $943; | |
| $946 = $944; | |
| $947 = $945 - $946 | 0; | |
| $948 = ($947 | 0) / 24 & -1; | |
| $949 = $948 >>> 0 < 2; | |
| if ($949) { | |
| $$08$i = $first; | |
| } else { | |
| $950 = $943 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2EOS1_($func$i, $950), asyncState ? abort(-12) | 0 : 0; | |
| $951 = (tempInt = SAFE_HEAP_LOAD($942 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $952 = $951 + -24 | 0; | |
| $954 = $951; | |
| while (1) { | |
| $953 = ($954 | 0) == ($952 | 0); | |
| if ($953) { | |
| break; | |
| } | |
| $955 = $954 + -24 | 0; | |
| SAFE_HEAP_STORE($942 | 0, $955 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($955), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i = (tempInt = SAFE_HEAP_LOAD($942 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $954 = $$pre$i$i; | |
| } | |
| $956 = $951 + -48 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2EOS1_($class_type$i, $956), asyncState ? abort(-12) | 0 : 0; | |
| $957 = $func$i + 12 | 0; | |
| $958 = (tempInt = SAFE_HEAP_LOAD($957 | 0, 2, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $959 = $958 & 1; | |
| $960 = $959 << 16 >> 16 == 0; | |
| if ($960) { | |
| $963 = ($958 & 65535) >>> 8; | |
| $964 = $963 & 255; | |
| $966 = $964; | |
| } else { | |
| $961 = $func$i + 20 | 0; | |
| $962 = (tempInt = SAFE_HEAP_LOAD($961 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $$pre = (tempInt = SAFE_HEAP_LOAD($962 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $966 = $$pre; | |
| } | |
| $965 = $966 << 24 >> 24 == 40; | |
| $967 = (tempInt = SAFE_HEAP_LOAD($942 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $968 = $967 + -24 | 0; | |
| L451 : do { | |
| if ($965) { | |
| __THREW__ = 0; | |
| $969 = (tempInt = invoke_iii(5, $func$i | 0, 2768 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $970 = __THREW__; | |
| __THREW__ = 0; | |
| $971 = $970 & 1; | |
| if ($971) { | |
| label = 400; | |
| } else { | |
| SAFE_HEAP_STORE($23 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($969 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($23 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($969 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($23 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($969 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i = ($__i$0$i$i$i$i | 0) == 3; | |
| if ($exitcond$i$i$i$i) { | |
| break; | |
| } | |
| $972 = $969 + ($__i$0$i$i$i$i << 2) | 0; | |
| SAFE_HEAP_STORE($972 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $973 = $__i$0$i$i$i$i + 1 | 0; | |
| $__i$0$i$i$i$i = $973; | |
| } | |
| __THREW__ = 0; | |
| invoke_vii(8, $24 | 0, $class_type$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| $974 = __THREW__; | |
| __THREW__ = 0; | |
| $975 = $974 & 1; | |
| if ($975) { | |
| $1099 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1100 = tempRet0; | |
| $$2$i = $1100; | |
| $$23$i = $1099; | |
| } else { | |
| $976 = (tempInt = SAFE_HEAP_LOAD($24 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $977 = $976 & 1; | |
| $978 = $977 << 24 >> 24 == 0; | |
| if ($978) { | |
| $983 = $24 + 1 | 0; | |
| $984 = $976 & 255; | |
| $985 = $984 >>> 1; | |
| $986 = $983; | |
| $987 = $985; | |
| } else { | |
| $979 = $24 + 8 | 0; | |
| $980 = (tempInt = SAFE_HEAP_LOAD($979 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $981 = $24 + 4 | 0; | |
| $982 = (tempInt = SAFE_HEAP_LOAD($981 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $986 = $980; | |
| $987 = $982; | |
| } | |
| __THREW__ = 0; | |
| $988 = (tempInt = invoke_iiii(3, $23 | 0, $986 | 0, $987 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $989 = __THREW__; | |
| __THREW__ = 0; | |
| $990 = $989 & 1; | |
| do { | |
| if ($990) { | |
| $1101 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1102 = tempRet0; | |
| $$1$i = $1102; | |
| $$12$i = $1101; | |
| } else { | |
| SAFE_HEAP_STORE($22 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($988 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($22 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($988 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($22 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($988 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i10$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i11$i = ($__i$0$i$i$i10$i | 0) == 3; | |
| if ($exitcond$i$i$i11$i) { | |
| break; | |
| } | |
| $991 = $988 + ($__i$0$i$i$i10$i << 2) | 0; | |
| SAFE_HEAP_STORE($991 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $992 = $__i$0$i$i$i10$i + 1 | 0; | |
| $__i$0$i$i$i10$i = $992; | |
| } | |
| __THREW__ = 0; | |
| $993 = (tempInt = invoke_iii(5, $22 | 0, 5072 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $994 = __THREW__; | |
| __THREW__ = 0; | |
| $995 = $994 & 1; | |
| if ($995) { | |
| $1103 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1104 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($22), asyncState ? abort(-12) | 0 : 0; | |
| $$1$i = $1104; | |
| $$12$i = $1103; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($21 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($993 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($21 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($993 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($21 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($993 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i13$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i14$i = ($__i$0$i$i$i13$i | 0) == 3; | |
| if ($exitcond$i$i$i14$i) { | |
| break; | |
| } | |
| $996 = $993 + ($__i$0$i$i$i13$i << 2) | 0; | |
| SAFE_HEAP_STORE($996 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $997 = $__i$0$i$i$i13$i + 1 | 0; | |
| $__i$0$i$i$i13$i = $997; | |
| } | |
| $998 = (tempInt = SAFE_HEAP_LOAD($968 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $999 = $998 & 1; | |
| $1000 = $999 << 24 >> 24 == 0; | |
| do { | |
| if ($1000) { | |
| $1001 = $968 + 1 | 0; | |
| SAFE_HEAP_STORE($1001 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($968 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1002 = $967 + -16 | 0; | |
| $1003 = (tempInt = SAFE_HEAP_LOAD($1002 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1003 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1004 = $967 + -20 | 0; | |
| SAFE_HEAP_STORE($1004 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i$i$i = (tempInt = SAFE_HEAP_LOAD($968 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1005 = $$pre$i$i$i$i & 1; | |
| $1006 = $1005 << 24 >> 24 == 0; | |
| if ($1006) { | |
| $1011 = $$pre$i$i$i$i; | |
| $1020 = 10; | |
| } else { | |
| $1007 = (tempInt = SAFE_HEAP_LOAD($968 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1008 = $1007 & -2; | |
| $phitmp$i$i$i$i$i$i$i = $1008 + -1 | 0; | |
| $1009 = $1007 & 255; | |
| $1011 = $1009; | |
| $1020 = $phitmp$i$i$i$i$i$i$i; | |
| } | |
| $1010 = $1011 & 1; | |
| $1012 = $1010 << 24 >> 24 == 0; | |
| do { | |
| if ($1012) { | |
| $1013 = $1011 & 255; | |
| $1014 = $1013 >>> 1; | |
| $1015 = ($1011 & 255) < 22; | |
| if ($1015) { | |
| $1019 = 10; | |
| $1039 = $1014; | |
| $2937 = 1; | |
| break; | |
| } | |
| $1016 = $1014 + 16 | 0; | |
| $1017 = $1016 & 240; | |
| $phitmp$i2$i$i$i$i$i$i = $1017 + -1 | 0; | |
| $1019 = $phitmp$i2$i$i$i$i$i$i; | |
| $1039 = $1014; | |
| $2937 = 1; | |
| } else { | |
| $1019 = 10; | |
| $1039 = 0; | |
| $2937 = 0; | |
| } | |
| } while (0); | |
| $1018 = ($1019 | 0) == ($1020 | 0); | |
| if ($1018) { | |
| break; | |
| } | |
| $1021 = ($1019 | 0) == 10; | |
| if ($1021) { | |
| $1026 = $968 + 1 | 0; | |
| $1027 = (tempInt = SAFE_HEAP_LOAD($1002 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2937) { | |
| $1028 = $1011 & 255; | |
| $1029 = $1028 >>> 1; | |
| $1030 = $1029 + 1 | 0; | |
| (tempInt = _memcpy($1026 | 0, $1027 | 0, $1030 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($1027), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1035 = (tempInt = SAFE_HEAP_LOAD($1027 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1026 >> 0 | 0, $1035 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($1027), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1040 = $1039 << 1; | |
| $1041 = $1040 & 255; | |
| SAFE_HEAP_STORE($968 >> 0 | 0, $1041 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $1022 = $1019 >>> 0 <= $1020 >>> 0; | |
| $1023 = $1019 + 1 | 0; | |
| $1024 = (tempInt = _malloc($1023) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1025 = ($1024 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i$i = $1022 & $1025; | |
| if ($or$cond$i$i$i$i$i$i) { | |
| break; | |
| } | |
| if ($2937) { | |
| $1031 = $968 + 1 | 0; | |
| $1032 = $1011 & 255; | |
| $1033 = $1032 >>> 1; | |
| $1034 = $1033 + 1 | 0; | |
| (tempInt = _memcpy($1024 | 0, $1031 | 0, $1034 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } else { | |
| $1036 = (tempInt = SAFE_HEAP_LOAD($1002 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1037 = (tempInt = SAFE_HEAP_LOAD($1036 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1024 >> 0 | 0, $1037 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($1036), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1038 = $1023 | 1; | |
| SAFE_HEAP_STORE($968 | 0, $1038 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1004 | 0, $1039 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1002 | 0, $1024 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($968 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($21 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($968 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($21 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($968 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($21 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i$i = ($__i$0$i$i$i$i$i | 0) == 3; | |
| if ($exitcond$i$i$i$i$i) { | |
| break; | |
| } | |
| $1042 = $21 + ($__i$0$i$i$i$i$i << 2) | 0; | |
| SAFE_HEAP_STORE($1042 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1043 = $__i$0$i$i$i$i$i + 1 | 0; | |
| $__i$0$i$i$i$i$i = $1043; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($21), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($22), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($24), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($23), asyncState ? abort(-12) | 0 : 0; | |
| $1044 = (tempInt = SAFE_HEAP_LOAD($942 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| __THREW__ = 0; | |
| $1045 = (tempInt = invoke_iiii(4, $957 | 0, 0, 2760 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1046 = __THREW__; | |
| __THREW__ = 0; | |
| $1047 = $1046 & 1; | |
| if ($1047) { | |
| label = 400; | |
| break L451; | |
| } | |
| SAFE_HEAP_STORE($25 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1045 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($25 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1045 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($25 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1045 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i17$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i18$i = ($__i$0$i$i$i17$i | 0) == 3; | |
| if ($exitcond$i$i$i18$i) { | |
| break; | |
| } | |
| $1048 = $1045 + ($__i$0$i$i$i17$i << 2) | 0; | |
| SAFE_HEAP_STORE($1048 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1049 = $__i$0$i$i$i17$i + 1 | 0; | |
| $__i$0$i$i$i17$i = $1049; | |
| } | |
| $1050 = $1044 + -12 | 0; | |
| $1051 = (tempInt = SAFE_HEAP_LOAD($1050 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1052 = $1051 & 1; | |
| $1053 = $1052 << 24 >> 24 == 0; | |
| do { | |
| if ($1053) { | |
| $1054 = $1050 + 1 | 0; | |
| SAFE_HEAP_STORE($1054 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1050 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1055 = $1044 + -4 | 0; | |
| $1056 = (tempInt = SAFE_HEAP_LOAD($1055 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1056 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1057 = $1044 + -8 | 0; | |
| SAFE_HEAP_STORE($1057 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i$i21$i = (tempInt = SAFE_HEAP_LOAD($1050 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1058 = $$pre$i$i$i21$i & 1; | |
| $1059 = $1058 << 24 >> 24 == 0; | |
| if ($1059) { | |
| $1064 = $$pre$i$i$i21$i; | |
| $1073 = 10; | |
| } else { | |
| $1060 = (tempInt = SAFE_HEAP_LOAD($1050 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1061 = $1060 & -2; | |
| $phitmp$i$i$i$i$i$i23$i = $1061 + -1 | 0; | |
| $1062 = $1060 & 255; | |
| $1064 = $1062; | |
| $1073 = $phitmp$i$i$i$i$i$i23$i; | |
| } | |
| $1063 = $1064 & 1; | |
| $1065 = $1063 << 24 >> 24 == 0; | |
| do { | |
| if ($1065) { | |
| $1066 = $1064 & 255; | |
| $1067 = $1066 >>> 1; | |
| $1068 = ($1064 & 255) < 22; | |
| if ($1068) { | |
| $1072 = 10; | |
| $1092 = $1067; | |
| $2938 = 1; | |
| break; | |
| } | |
| $1069 = $1067 + 16 | 0; | |
| $1070 = $1069 & 240; | |
| $phitmp$i2$i$i$i$i$i26$i = $1070 + -1 | 0; | |
| $1072 = $phitmp$i2$i$i$i$i$i26$i; | |
| $1092 = $1067; | |
| $2938 = 1; | |
| } else { | |
| $1072 = 10; | |
| $1092 = 0; | |
| $2938 = 0; | |
| } | |
| } while (0); | |
| $1071 = ($1072 | 0) == ($1073 | 0); | |
| if ($1071) { | |
| break; | |
| } | |
| $1074 = ($1072 | 0) == 10; | |
| if ($1074) { | |
| $1079 = $1050 + 1 | 0; | |
| $1080 = (tempInt = SAFE_HEAP_LOAD($1055 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2938) { | |
| $1081 = $1064 & 255; | |
| $1082 = $1081 >>> 1; | |
| $1083 = $1082 + 1 | 0; | |
| (tempInt = _memcpy($1079 | 0, $1080 | 0, $1083 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($1080), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1088 = (tempInt = SAFE_HEAP_LOAD($1080 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1079 >> 0 | 0, $1088 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($1080), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1093 = $1092 << 1; | |
| $1094 = $1093 & 255; | |
| SAFE_HEAP_STORE($1050 >> 0 | 0, $1094 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $1075 = $1072 >>> 0 <= $1073 >>> 0; | |
| $1076 = $1072 + 1 | 0; | |
| $1077 = (tempInt = _malloc($1076) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1078 = ($1077 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i28$i = $1075 & $1078; | |
| if ($or$cond$i$i$i$i$i28$i) { | |
| break; | |
| } | |
| if ($2938) { | |
| $1084 = $1050 + 1 | 0; | |
| $1085 = $1064 & 255; | |
| $1086 = $1085 >>> 1; | |
| $1087 = $1086 + 1 | 0; | |
| (tempInt = _memcpy($1077 | 0, $1084 | 0, $1087 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } else { | |
| $1089 = (tempInt = SAFE_HEAP_LOAD($1055 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1090 = (tempInt = SAFE_HEAP_LOAD($1089 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1077 >> 0 | 0, $1090 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($1089), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1091 = $1076 | 1; | |
| SAFE_HEAP_STORE($1050 | 0, $1091 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1057 | 0, $1092 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1055 | 0, $1077 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($1050 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($25 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1050 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($25 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1050 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($25 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i36$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i37$i = ($__i$0$i$i$i$i36$i | 0) == 3; | |
| if ($exitcond$i$i$i$i37$i) { | |
| break; | |
| } | |
| $1095 = $25 + ($__i$0$i$i$i$i36$i << 2) | 0; | |
| SAFE_HEAP_STORE($1095 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1096 = $__i$0$i$i$i$i36$i + 1 | 0; | |
| $__i$0$i$i$i$i36$i = $1096; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($25), asyncState ? abort(-12) | 0 : 0; | |
| label = 470; | |
| break L451; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($24), asyncState ? abort(-12) | 0 : 0; | |
| $$2$i = $$1$i; | |
| $$23$i = $$12$i; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($23), asyncState ? abort(-12) | 0 : 0; | |
| $$6$i = $$2$i; | |
| $$67$i = $$23$i; | |
| } | |
| } else { | |
| __THREW__ = 0; | |
| $1105 = (tempInt = invoke_iii(5, $func$i | 0, 2840 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1106 = __THREW__; | |
| __THREW__ = 0; | |
| $1107 = $1106 & 1; | |
| if ($1107) { | |
| label = 400; | |
| } else { | |
| SAFE_HEAP_STORE($28 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1105 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($28 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1105 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($28 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1105 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i39$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i40$i = ($__i$0$i$i$i39$i | 0) == 3; | |
| if ($exitcond$i$i$i40$i) { | |
| break; | |
| } | |
| $1108 = $1105 + ($__i$0$i$i$i39$i << 2) | 0; | |
| SAFE_HEAP_STORE($1108 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1109 = $__i$0$i$i$i39$i + 1 | 0; | |
| $__i$0$i$i$i39$i = $1109; | |
| } | |
| __THREW__ = 0; | |
| invoke_vii(8, $29 | 0, $class_type$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1110 = __THREW__; | |
| __THREW__ = 0; | |
| $1111 = $1110 & 1; | |
| if ($1111) { | |
| $1228 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1229 = tempRet0; | |
| $$5$i = $1229; | |
| $$56$i = $1228; | |
| } else { | |
| $1112 = (tempInt = SAFE_HEAP_LOAD($29 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1113 = $1112 & 1; | |
| $1114 = $1113 << 24 >> 24 == 0; | |
| if ($1114) { | |
| $1119 = $29 + 1 | 0; | |
| $1120 = $1112 & 255; | |
| $1121 = $1120 >>> 1; | |
| $1122 = $1119; | |
| $1123 = $1121; | |
| } else { | |
| $1115 = $29 + 8 | 0; | |
| $1116 = (tempInt = SAFE_HEAP_LOAD($1115 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1117 = $29 + 4 | 0; | |
| $1118 = (tempInt = SAFE_HEAP_LOAD($1117 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1122 = $1116; | |
| $1123 = $1118; | |
| } | |
| __THREW__ = 0; | |
| $1124 = (tempInt = invoke_iiii(3, $28 | 0, $1122 | 0, $1123 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1125 = __THREW__; | |
| __THREW__ = 0; | |
| $1126 = $1125 & 1; | |
| do { | |
| if ($1126) { | |
| $1230 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1231 = tempRet0; | |
| $$4$i = $1231; | |
| $$45$i = $1230; | |
| } else { | |
| SAFE_HEAP_STORE($27 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1124 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($27 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1124 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($27 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1124 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i44$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i45$i = ($__i$0$i$i$i44$i | 0) == 3; | |
| if ($exitcond$i$i$i45$i) { | |
| break; | |
| } | |
| $1127 = $1124 + ($__i$0$i$i$i44$i << 2) | 0; | |
| SAFE_HEAP_STORE($1127 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1128 = $__i$0$i$i$i44$i + 1 | 0; | |
| $__i$0$i$i$i44$i = $1128; | |
| } | |
| __THREW__ = 0; | |
| $1129 = (tempInt = invoke_iii(5, $27 | 0, 5072 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1130 = __THREW__; | |
| __THREW__ = 0; | |
| $1131 = $1130 & 1; | |
| if ($1131) { | |
| $1232 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1233 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($27), asyncState ? abort(-12) | 0 : 0; | |
| $$4$i = $1233; | |
| $$45$i = $1232; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($26 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($1129 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($26 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($1129 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($26 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($1129 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i48$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i49$i = ($__i$0$i$i$i48$i | 0) == 3; | |
| if ($exitcond$i$i$i49$i) { | |
| break; | |
| } | |
| $1132 = $1129 + ($__i$0$i$i$i48$i << 2) | 0; | |
| SAFE_HEAP_STORE($1132 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1133 = $__i$0$i$i$i48$i + 1 | 0; | |
| $__i$0$i$i$i48$i = $1133; | |
| } | |
| $1134 = (tempInt = SAFE_HEAP_LOAD($968 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1135 = $1134 & 1; | |
| $1136 = $1135 << 24 >> 24 == 0; | |
| do { | |
| if ($1136) { | |
| $1137 = $968 + 1 | 0; | |
| SAFE_HEAP_STORE($1137 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($968 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1138 = $967 + -16 | 0; | |
| $1139 = (tempInt = SAFE_HEAP_LOAD($1138 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1139 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1140 = $967 + -20 | 0; | |
| SAFE_HEAP_STORE($1140 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i$i53$i = (tempInt = SAFE_HEAP_LOAD($968 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1141 = $$pre$i$i$i53$i & 1; | |
| $1142 = $1141 << 24 >> 24 == 0; | |
| if ($1142) { | |
| $1147 = $$pre$i$i$i53$i; | |
| $1156 = 10; | |
| } else { | |
| $1143 = (tempInt = SAFE_HEAP_LOAD($968 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1144 = $1143 & -2; | |
| $phitmp$i$i$i$i$i$i55$i = $1144 + -1 | 0; | |
| $1145 = $1143 & 255; | |
| $1147 = $1145; | |
| $1156 = $phitmp$i$i$i$i$i$i55$i; | |
| } | |
| $1146 = $1147 & 1; | |
| $1148 = $1146 << 24 >> 24 == 0; | |
| do { | |
| if ($1148) { | |
| $1149 = $1147 & 255; | |
| $1150 = $1149 >>> 1; | |
| $1151 = ($1147 & 255) < 22; | |
| if ($1151) { | |
| $1155 = 10; | |
| $1175 = $1150; | |
| $2939 = 1; | |
| break; | |
| } | |
| $1152 = $1150 + 16 | 0; | |
| $1153 = $1152 & 240; | |
| $phitmp$i2$i$i$i$i$i58$i = $1153 + -1 | 0; | |
| $1155 = $phitmp$i2$i$i$i$i$i58$i; | |
| $1175 = $1150; | |
| $2939 = 1; | |
| } else { | |
| $1155 = 10; | |
| $1175 = 0; | |
| $2939 = 0; | |
| } | |
| } while (0); | |
| $1154 = ($1155 | 0) == ($1156 | 0); | |
| if ($1154) { | |
| break; | |
| } | |
| $1157 = ($1155 | 0) == 10; | |
| if ($1157) { | |
| $1162 = $968 + 1 | 0; | |
| $1163 = (tempInt = SAFE_HEAP_LOAD($1138 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2939) { | |
| $1164 = $1147 & 255; | |
| $1165 = $1164 >>> 1; | |
| $1166 = $1165 + 1 | 0; | |
| (tempInt = _memcpy($1162 | 0, $1163 | 0, $1166 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($1163), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1171 = (tempInt = SAFE_HEAP_LOAD($1163 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1162 >> 0 | 0, $1171 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($1163), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1176 = $1175 << 1; | |
| $1177 = $1176 & 255; | |
| SAFE_HEAP_STORE($968 >> 0 | 0, $1177 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $1158 = $1155 >>> 0 <= $1156 >>> 0; | |
| $1159 = $1155 + 1 | 0; | |
| $1160 = (tempInt = _malloc($1159) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1161 = ($1160 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i60$i = $1158 & $1161; | |
| if ($or$cond$i$i$i$i$i60$i) { | |
| break; | |
| } | |
| if ($2939) { | |
| $1167 = $968 + 1 | 0; | |
| $1168 = $1147 & 255; | |
| $1169 = $1168 >>> 1; | |
| $1170 = $1169 + 1 | 0; | |
| (tempInt = _memcpy($1160 | 0, $1167 | 0, $1170 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } else { | |
| $1172 = (tempInt = SAFE_HEAP_LOAD($1138 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1173 = (tempInt = SAFE_HEAP_LOAD($1172 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1160 >> 0 | 0, $1173 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($1172), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1174 = $1159 | 1; | |
| SAFE_HEAP_STORE($968 | 0, $1174 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1140 | 0, $1175 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1138 | 0, $1160 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($968 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($26 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($968 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($26 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($968 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($26 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i68$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i69$i = ($__i$0$i$i$i$i68$i | 0) == 3; | |
| if ($exitcond$i$i$i$i69$i) { | |
| break; | |
| } | |
| $1178 = $26 + ($__i$0$i$i$i$i68$i << 2) | 0; | |
| SAFE_HEAP_STORE($1178 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1179 = $__i$0$i$i$i$i68$i + 1 | 0; | |
| $__i$0$i$i$i$i68$i = $1179; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($26), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($27), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($29), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($28), asyncState ? abort(-12) | 0 : 0; | |
| $1180 = (tempInt = SAFE_HEAP_LOAD($942 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1181 = $1180 + -12 | 0; | |
| $1182 = (tempInt = SAFE_HEAP_LOAD($1181 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1183 = $1182 & 1; | |
| $1184 = $1183 << 24 >> 24 == 0; | |
| do { | |
| if ($1184) { | |
| $1185 = $1181 + 1 | 0; | |
| SAFE_HEAP_STORE($1185 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1181 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1186 = $1180 + -4 | 0; | |
| $1187 = (tempInt = SAFE_HEAP_LOAD($1186 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1187 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1188 = $1180 + -8 | 0; | |
| SAFE_HEAP_STORE($1188 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i$i$i72$i = (tempInt = SAFE_HEAP_LOAD($1181 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1189 = $$pre$i$i$i72$i & 1; | |
| $1190 = $1189 << 24 >> 24 == 0; | |
| if ($1190) { | |
| $1195 = $$pre$i$i$i72$i; | |
| $1204 = 10; | |
| } else { | |
| $1191 = (tempInt = SAFE_HEAP_LOAD($1181 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1192 = $1191 & -2; | |
| $phitmp$i$i$i$i$i$i74$i = $1192 + -1 | 0; | |
| $1193 = $1191 & 255; | |
| $1195 = $1193; | |
| $1204 = $phitmp$i$i$i$i$i$i74$i; | |
| } | |
| $1194 = $1195 & 1; | |
| $1196 = $1194 << 24 >> 24 == 0; | |
| do { | |
| if ($1196) { | |
| $1197 = $1195 & 255; | |
| $1198 = $1197 >>> 1; | |
| $1199 = ($1195 & 255) < 22; | |
| if ($1199) { | |
| $1203 = 10; | |
| $1223 = $1198; | |
| $2940 = 1; | |
| break; | |
| } | |
| $1200 = $1198 + 16 | 0; | |
| $1201 = $1200 & 240; | |
| $phitmp$i2$i$i$i$i$i77$i = $1201 + -1 | 0; | |
| $1203 = $phitmp$i2$i$i$i$i$i77$i; | |
| $1223 = $1198; | |
| $2940 = 1; | |
| } else { | |
| $1203 = 10; | |
| $1223 = 0; | |
| $2940 = 0; | |
| } | |
| } while (0); | |
| $1202 = ($1203 | 0) == ($1204 | 0); | |
| if ($1202) { | |
| break; | |
| } | |
| $1205 = ($1203 | 0) == 10; | |
| if ($1205) { | |
| $1210 = $1181 + 1 | 0; | |
| $1211 = (tempInt = SAFE_HEAP_LOAD($1186 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| if ($2940) { | |
| $1212 = $1195 & 255; | |
| $1213 = $1212 >>> 1; | |
| $1214 = $1213 + 1 | 0; | |
| (tempInt = _memcpy($1210 | 0, $1211 | 0, $1214 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| _free($1211), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1219 = (tempInt = SAFE_HEAP_LOAD($1211 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1210 >> 0 | 0, $1219 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($1211), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1224 = $1223 << 1; | |
| $1225 = $1224 & 255; | |
| SAFE_HEAP_STORE($1181 >> 0 | 0, $1225 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $1206 = $1203 >>> 0 <= $1204 >>> 0; | |
| $1207 = $1203 + 1 | 0; | |
| $1208 = (tempInt = _malloc($1207) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1209 = ($1208 | 0) == (0 | 0); | |
| $or$cond$i$i$i$i$i79$i = $1206 & $1209; | |
| if ($or$cond$i$i$i$i$i79$i) { | |
| break; | |
| } | |
| if ($2940) { | |
| $1215 = $1181 + 1 | 0; | |
| $1216 = $1195 & 255; | |
| $1217 = $1216 >>> 1; | |
| $1218 = $1217 + 1 | 0; | |
| (tempInt = _memcpy($1208 | 0, $1215 | 0, $1218 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } else { | |
| $1220 = (tempInt = SAFE_HEAP_LOAD($1186 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1221 = (tempInt = SAFE_HEAP_LOAD($1220 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1208 >> 0 | 0, $1221 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| _free($1220), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1222 = $1207 | 1; | |
| SAFE_HEAP_STORE($1181 | 0, $1222 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1188 | 0, $1223 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1186 | 0, $1208 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } while (0); | |
| SAFE_HEAP_STORE($1181 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($957 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1181 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($957 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1181 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($957 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i$i87$i = 0; | |
| while (1) { | |
| $exitcond$i$i$i$i88$i = ($__i$0$i$i$i$i87$i | 0) == 3; | |
| if ($exitcond$i$i$i$i88$i) { | |
| break; | |
| } | |
| $1226 = $957 + ($__i$0$i$i$i$i87$i << 2) | 0; | |
| SAFE_HEAP_STORE($1226 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1227 = $__i$0$i$i$i$i87$i + 1 | 0; | |
| $__i$0$i$i$i$i87$i = $1227; | |
| } | |
| label = 470; | |
| break L451; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($29), asyncState ? abort(-12) | 0 : 0; | |
| $$5$i = $$4$i; | |
| $$56$i = $$45$i; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($28), asyncState ? abort(-12) | 0 : 0; | |
| $$6$i = $$5$i; | |
| $$67$i = $$56$i; | |
| } | |
| } | |
| } while (0); | |
| if ((label | 0) == 400) { | |
| $1097 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1098 = tempRet0; | |
| $$6$i = $1098; | |
| $$67$i = $1097; | |
| } else if ((label | 0) == 470) { | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($class_type$i), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($func$i), asyncState ? abort(-12) | 0 : 0; | |
| $$08$i = $940; | |
| break; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($class_type$i), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($func$i), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($$67$i | 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| } | |
| } | |
| } else { | |
| $$08$i = $first; | |
| } | |
| } while (0); | |
| $1234 = ($$08$i | 0) == ($first | 0); | |
| if ($1234) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1235 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1236 = $db + 4 | 0; | |
| $1237 = (tempInt = SAFE_HEAP_LOAD($1236 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1238 = ($1235 | 0) == ($1237 | 0); | |
| if ($1238) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1239 = $db + 16 | 0; | |
| $1240 = $1237 + -24 | 0; | |
| $1241 = $db + 12 | 0; | |
| $1242 = (tempInt = SAFE_HEAP_LOAD($1241 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($39 | 0, $1242 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEC2EjRKS3_RKS5_($38, $1240, $39), asyncState ? abort(-12) | 0 : 0; | |
| $1243 = $db + 20 | 0; | |
| $1244 = (tempInt = SAFE_HEAP_LOAD($1243 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1245 = $db + 24 | 0; | |
| $1246 = (tempInt = SAFE_HEAP_LOAD($1245 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1247 = $1244 >>> 0 < $1246 >>> 0; | |
| if ($1247) { | |
| $1248 = ($1244 | 0) == (0 | 0); | |
| if ($1248) { | |
| $1260 = 0; | |
| } else { | |
| $1249 = $1244 + 4 | 0; | |
| $1250 = $38 + 12 | 0; | |
| $1251 = (tempInt = SAFE_HEAP_LOAD($1250 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1252 = $1244 + 8 | 0; | |
| $1253 = $1244 + 12 | 0; | |
| SAFE_HEAP_STORE($1253 | 0, $1251 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1254 = (tempInt = SAFE_HEAP_LOAD($38 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1244 | 0, $1254 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1255 = $38 + 4 | 0; | |
| $1256 = (tempInt = SAFE_HEAP_LOAD($1255 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1249 | 0, $1256 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1257 = $38 + 8 | 0; | |
| $1258 = (tempInt = SAFE_HEAP_LOAD($1257 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1252 | 0, $1258 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1257 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1255 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($38 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i109 = (tempInt = SAFE_HEAP_LOAD($1243 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1260 = $$pre$i109; | |
| } | |
| $1259 = $1260 + 16 | 0; | |
| SAFE_HEAP_STORE($1243 | 0, $1259 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1261 = $db + 28 | 0; | |
| $1262 = (tempInt = SAFE_HEAP_LOAD($1239 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1263 = $1244; | |
| $1264 = $1262; | |
| $1265 = $1263 - $1264 | 0; | |
| $1266 = $1265 >> 4; | |
| $1267 = $1266 + 1 | 0; | |
| $1268 = ($1265 | 0) < -16; | |
| if ($1268) { | |
| __THREW__ = 0; | |
| invoke_vi(14, $1239 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1269 = __THREW__; | |
| __THREW__ = 0; | |
| $1270 = $1269 & 1; | |
| if ($1270) { | |
| $1292 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1293 = tempRet0; | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($38), asyncState ? abort(-12) | 0 : 0; | |
| $$10 = $1292; | |
| $$1013 = $1293; | |
| break L88; | |
| } else {} | |
| } | |
| $1271 = $1246; | |
| $1272 = $1271 - $1264 | 0; | |
| $1273 = $1272 >> 4; | |
| $1274 = $1273 >>> 0 < 1073741823; | |
| if ($1274) { | |
| $1275 = $1272 >> 3; | |
| $1276 = $1275 >>> 0 < $1267 >>> 0; | |
| $1277 = $1276 ? $1267 : $1275; | |
| $$0$i$i$i111 = $1277; | |
| } else { | |
| $$0$i$i$i111 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEEC2EjjS9_($__v$i$i108, $$0$i$i$i111, $1266, $1261), asyncState ? abort(-12) | 0 : 0; | |
| $1278 = $__v$i$i108 + 8 | 0; | |
| $1279 = (tempInt = SAFE_HEAP_LOAD($1278 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1280 = ($1279 | 0) == (0 | 0); | |
| if (!$1280) { | |
| $1281 = $1279 + 4 | 0; | |
| $1282 = $38 + 12 | 0; | |
| $1283 = (tempInt = SAFE_HEAP_LOAD($1282 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1284 = $1279 + 8 | 0; | |
| $1285 = $1279 + 12 | 0; | |
| SAFE_HEAP_STORE($1285 | 0, $1283 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1286 = (tempInt = SAFE_HEAP_LOAD($38 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1279 | 0, $1286 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1287 = $38 + 4 | 0; | |
| $1288 = (tempInt = SAFE_HEAP_LOAD($1287 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1281 | 0, $1288 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1289 = $38 + 8 | 0; | |
| $1290 = (tempInt = SAFE_HEAP_LOAD($1289 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1284 | 0, $1290 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1289 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1287 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($38 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1291 = $1279 + 16 | 0; | |
| SAFE_HEAP_STORE($1278 | 0, $1291 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorINS0_IN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEENS4_IS6_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS6_RS7_EE($1239, $__v$i$i108), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEED2Ev($__v$i$i108), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($38), asyncState ? abort(-12) | 0 : 0; | |
| $$0 = $$08$i; | |
| break L1; | |
| break; | |
| } | |
| case 79: | |
| { | |
| $1294 = $db + 4 | 0; | |
| $1295 = (tempInt = SAFE_HEAP_LOAD($1294 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1296 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1297 = $1295; | |
| $1298 = $1296; | |
| $1299 = $1297 - $1298 | 0; | |
| $1300 = ($1299 | 0) / 24 & -1; | |
| $1301 = $first + 1 | 0; | |
| $1302 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($1301, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1303 = (tempInt = SAFE_HEAP_LOAD($1294 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1304 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1305 = $1303; | |
| $1306 = $1304; | |
| $1307 = $1305 - $1306 | 0; | |
| $1308 = ($1307 | 0) / 24 & -1; | |
| $1309 = ($1302 | 0) == ($1301 | 0); | |
| if ($1309) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1310 = $db + 16 | 0; | |
| $1311 = $db + 12 | 0; | |
| $1312 = (tempInt = SAFE_HEAP_LOAD($1311 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1313 = $db + 20 | 0; | |
| $1314 = (tempInt = SAFE_HEAP_LOAD($1313 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1315 = $db + 24 | 0; | |
| $1316 = (tempInt = SAFE_HEAP_LOAD($1315 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1317 = $1314 >>> 0 < $1316 >>> 0; | |
| if ($1317) { | |
| $1318 = ($1314 | 0) == (0 | 0); | |
| if ($1318) { | |
| $1323 = 0; | |
| } else { | |
| SAFE_HEAP_STORE($1314 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1319 = $1314 + 4 | 0; | |
| SAFE_HEAP_STORE($1319 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1320 = $1314 + 8 | 0; | |
| SAFE_HEAP_STORE($1320 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1321 = $1314 + 12 | 0; | |
| SAFE_HEAP_STORE($1321 | 0, $1312 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i117 = (tempInt = SAFE_HEAP_LOAD($1313 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1323 = $$pre$i117; | |
| } | |
| $1322 = $1323 + 16 | 0; | |
| SAFE_HEAP_STORE($1313 | 0, $1322 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1324 = $db + 28 | 0; | |
| $1325 = (tempInt = SAFE_HEAP_LOAD($1310 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1326 = $1314; | |
| $1327 = $1325; | |
| $1328 = $1326 - $1327 | 0; | |
| $1329 = $1328 >> 4; | |
| $1330 = $1329 + 1 | 0; | |
| $1331 = ($1328 | 0) < -16; | |
| if ($1331) { | |
| __ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv($1310), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1332 = $1316; | |
| $1333 = $1332 - $1327 | 0; | |
| $1334 = $1333 >> 4; | |
| $1335 = $1334 >>> 0 < 1073741823; | |
| if ($1335) { | |
| $1336 = $1333 >> 3; | |
| $1337 = $1336 >>> 0 < $1330 >>> 0; | |
| $1338 = $1337 ? $1330 : $1336; | |
| $$0$i$i$i119 = $1338; | |
| } else { | |
| $$0$i$i$i119 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEEC2EjjS9_($__v$i$i116, $$0$i$i$i119, $1329, $1324), asyncState ? abort(-12) | 0 : 0; | |
| $1339 = $__v$i$i116 + 8 | 0; | |
| $1340 = (tempInt = SAFE_HEAP_LOAD($1339 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1341 = ($1340 | 0) == (0 | 0); | |
| if (!$1341) { | |
| SAFE_HEAP_STORE($1340 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1342 = $1340 + 4 | 0; | |
| SAFE_HEAP_STORE($1342 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1343 = $1340 + 8 | 0; | |
| SAFE_HEAP_STORE($1343 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1344 = $1340 + 12 | 0; | |
| SAFE_HEAP_STORE($1344 | 0, $1312 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1345 = $1340 + 16 | 0; | |
| SAFE_HEAP_STORE($1339 | 0, $1345 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorINS0_IN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEENS4_IS6_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS6_RS7_EE($1310, $__v$i$i116), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEED2Ev($__v$i$i116), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1346 = $40 + 1 | 0; | |
| $1347 = $__v$i$i124 + 8 | 0; | |
| $1348 = $40 + 8 | 0; | |
| $1349 = $40 + 4 | 0; | |
| $k5$0 = $1300; | |
| while (1) { | |
| $1350 = $k5$0 >>> 0 < $1308 >>> 0; | |
| if (!$1350) { | |
| label = 1048; | |
| break; | |
| } | |
| $1351 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1352 = ($1351 + ($k5$0 * 24 | 0) | 0) + 12 | 0; | |
| $1353 = (tempInt = SAFE_HEAP_LOAD($1352 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1354 = $1353 & 1; | |
| $1355 = $1354 << 24 >> 24 == 0; | |
| if ($1355) { | |
| $1360 = $1353 & 255; | |
| $1361 = $1360 >>> 1; | |
| $1362 = $1352 + 1 | 0; | |
| $1364 = $1361; | |
| $1366 = $1362; | |
| } else { | |
| $1356 = ($1351 + ($k5$0 * 24 | 0) | 0) + 16 | 0; | |
| $1357 = (tempInt = SAFE_HEAP_LOAD($1356 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1358 = ($1351 + ($k5$0 * 24 | 0) | 0) + 20 | 0; | |
| $1359 = (tempInt = SAFE_HEAP_LOAD($1358 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1364 = $1357; | |
| $1366 = $1359; | |
| } | |
| $1363 = $1364 >>> 0 < 2; | |
| $1365 = $1363 ? $1364 : 2; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($40, $1366, $1365), asyncState ? abort(-12) | 0 : 0; | |
| $1367 = (tempInt = SAFE_HEAP_LOAD($40 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1368 = $1367 & 1; | |
| $1369 = $1368 << 24 >> 24 == 0; | |
| if ($1369) { | |
| $1372 = $1367 & 255; | |
| $1373 = $1372 >>> 1; | |
| $1375 = $1373; | |
| $1377 = $1346; | |
| } else { | |
| $1370 = (tempInt = SAFE_HEAP_LOAD($1349 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1371 = (tempInt = SAFE_HEAP_LOAD($1348 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1375 = $1370; | |
| $1377 = $1371; | |
| } | |
| $1374 = $1375 >>> 0 > 2; | |
| $1376 = $1374 ? 2 : $1375; | |
| $1378 = (tempInt = _memcmp($1377, 2744, $1376) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1379 = ($1378 | 0) != 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($40), asyncState ? abort(-12) | 0 : 0; | |
| $1380 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1381 = ($1375 | 0) != 2; | |
| $1382 = $1381 | $1379; | |
| if ($1382) { | |
| $1386 = ($1380 + ($k5$0 * 24 | 0) | 0) + 12 | 0; | |
| $1387 = (tempInt = SAFE_HEAP_LOAD($1386 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1388 = $1387 & 1; | |
| $1389 = $1388 << 24 >> 24 == 0; | |
| if ($1389) { | |
| $1392 = $1386 + 1 | 0; | |
| $1394 = $1392; | |
| } else { | |
| $1390 = ($1380 + ($k5$0 * 24 | 0) | 0) + 20 | 0; | |
| $1391 = (tempInt = SAFE_HEAP_LOAD($1390 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1394 = $1391; | |
| } | |
| $1393 = (tempInt = SAFE_HEAP_LOAD($1394 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1395 = $1393 << 24 >> 24 == 40; | |
| if ($1395) { | |
| $1396 = $1380 + ($k5$0 * 24 | 0) | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($1396, 2768) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1397 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1398 = ($1397 + ($k5$0 * 24 | 0) | 0) + 12 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6insertEjPKc($1398, 0, 2760) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } | |
| } else { | |
| $1383 = $1380 + ($k5$0 * 24 | 0) | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($1383, 2752) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1384 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1385 = ($1384 + ($k5$0 * 24 | 0) | 0) + 12 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6insertEjPKc($1385, 0, 2760) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } | |
| $1399 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1400 = $1399 + ($k5$0 * 24 | 0) | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($1400, 2776) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1401 = (tempInt = SAFE_HEAP_LOAD($1313 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1402 = $1401 + -16 | 0; | |
| $1403 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1404 = $1403 + ($k5$0 * 24 | 0) | 0; | |
| $1405 = $1401 + -12 | 0; | |
| $1406 = (tempInt = SAFE_HEAP_LOAD($1405 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1407 = $1401 + -8 | 0; | |
| $1408 = (tempInt = SAFE_HEAP_LOAD($1407 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1409 = ($1406 | 0) == ($1408 | 0); | |
| if ($1409) { | |
| $1419 = $1401 + -4 | 0; | |
| $1420 = (tempInt = SAFE_HEAP_LOAD($1402 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1421 = $1406; | |
| $1422 = $1420; | |
| $1423 = $1421 - $1422 | 0; | |
| $1424 = ($1423 | 0) / 24 & -1; | |
| $1425 = $1424 + 1 | 0; | |
| $1426 = ($1425 | 0) < 0; | |
| if ($1426) { | |
| $$lcssa574 = $1402; | |
| label = 522; | |
| break; | |
| } | |
| $1427 = $1424 >>> 0 < 1073741823; | |
| if ($1427) { | |
| $1428 = $1424 << 1; | |
| $1429 = $1428 >>> 0 < $1425 >>> 0; | |
| $1430 = $1429 ? $1425 : $1428; | |
| $$0$i$i$i128 = $1430; | |
| } else { | |
| $$0$i$i$i128 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEEC2EjjS6_($__v$i$i124, $$0$i$i$i128, $1424, $1419), asyncState ? abort(-12) | 0 : 0; | |
| $1431 = (tempInt = SAFE_HEAP_LOAD($1347 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1432 = ($1431 | 0) == (0 | 0); | |
| if (!$1432) { | |
| __THREW__ = 0; | |
| invoke_vii(12, $1431 | 0, $1404 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1433 = __THREW__; | |
| __THREW__ = 0; | |
| $1434 = $1433 & 1; | |
| if ($1434) { | |
| label = 529; | |
| break; | |
| } | |
| $1435 = $1431 + 12 | 0; | |
| $1436 = ($1403 + ($k5$0 * 24 | 0) | 0) + 12 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(12, $1435 | 0, $1436 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1437 = __THREW__; | |
| __THREW__ = 0; | |
| $1438 = $1437 & 1; | |
| if ($1438) { | |
| $$lcssa578 = $1431; | |
| label = 528; | |
| break; | |
| } | |
| } | |
| $1443 = $1431 + 24 | 0; | |
| SAFE_HEAP_STORE($1347 | 0, $1443 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS3_RS5_EE($1402, $__v$i$i124), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i124), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1410 = ($1406 | 0) == (0 | 0); | |
| if ($1410) { | |
| $1418 = 0; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEEC2ERKS7_($1406, $1404), asyncState ? abort(-12) | 0 : 0; | |
| $1411 = $1406 + 12 | 0; | |
| $1412 = ($1403 + ($k5$0 * 24 | 0) | 0) + 12 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(12, $1411 | 0, $1412 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1413 = __THREW__; | |
| __THREW__ = 0; | |
| $1414 = $1413 & 1; | |
| if ($1414) { | |
| $$lcssa = $1406; | |
| label = 519; | |
| break; | |
| } | |
| $$pre$i125 = (tempInt = SAFE_HEAP_LOAD($1405 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1418 = $$pre$i125; | |
| } | |
| $1417 = $1418 + 24 | 0; | |
| SAFE_HEAP_STORE($1405 | 0, $1417 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1444 = $k5$0 + 1 | 0; | |
| $k5$0 = $1444; | |
| } | |
| if ((label | 0) == 519) { | |
| $1415 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1416 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($$lcssa), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($1415 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } else if ((label | 0) == 522) { | |
| __ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv($$lcssa574), asyncState ? abort(-12) | 0 : 0; | |
| } else if ((label | 0) == 528) { | |
| $1439 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1440 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($$lcssa578), asyncState ? abort(-12) | 0 : 0; | |
| $eh$lpad$body$i$i131$index14Z2D = $1440; | |
| $eh$lpad$body$i$i131$indexZ2D = $1439; | |
| } else if ((label | 0) == 529) { | |
| $1441 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1442 = tempRet0; | |
| $eh$lpad$body$i$i131$index14Z2D = $1442; | |
| $eh$lpad$body$i$i131$indexZ2D = $1441; | |
| } else if ((label | 0) == 1048) { | |
| $$0 = $1302; | |
| break L1; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i124), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($eh$lpad$body$i$i131$indexZ2D | 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| case 80: | |
| { | |
| $1445 = $db + 4 | 0; | |
| $1446 = (tempInt = SAFE_HEAP_LOAD($1445 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1447 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1448 = $1446; | |
| $1449 = $1447; | |
| $1450 = $1448 - $1449 | 0; | |
| $1451 = ($1450 | 0) / 24 & -1; | |
| $1452 = $first + 1 | 0; | |
| $1453 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($1452, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1454 = (tempInt = SAFE_HEAP_LOAD($1445 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1455 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1456 = $1454; | |
| $1457 = $1455; | |
| $1458 = $1456 - $1457 | 0; | |
| $1459 = ($1458 | 0) / 24 & -1; | |
| $1460 = ($1453 | 0) == ($1452 | 0); | |
| if ($1460) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1461 = $db + 16 | 0; | |
| $1462 = $db + 12 | 0; | |
| $1463 = (tempInt = SAFE_HEAP_LOAD($1462 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1464 = $db + 20 | 0; | |
| $1465 = (tempInt = SAFE_HEAP_LOAD($1464 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1466 = $db + 24 | 0; | |
| $1467 = (tempInt = SAFE_HEAP_LOAD($1466 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1468 = $1465 >>> 0 < $1467 >>> 0; | |
| if ($1468) { | |
| $1469 = ($1465 | 0) == (0 | 0); | |
| if ($1469) { | |
| $1474 = 0; | |
| } else { | |
| SAFE_HEAP_STORE($1465 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1470 = $1465 + 4 | 0; | |
| SAFE_HEAP_STORE($1470 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1471 = $1465 + 8 | 0; | |
| SAFE_HEAP_STORE($1471 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1472 = $1465 + 12 | 0; | |
| SAFE_HEAP_STORE($1472 | 0, $1463 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i136 = (tempInt = SAFE_HEAP_LOAD($1464 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1474 = $$pre$i136; | |
| } | |
| $1473 = $1474 + 16 | 0; | |
| SAFE_HEAP_STORE($1464 | 0, $1473 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1475 = $db + 28 | 0; | |
| $1476 = (tempInt = SAFE_HEAP_LOAD($1461 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1477 = $1465; | |
| $1478 = $1476; | |
| $1479 = $1477 - $1478 | 0; | |
| $1480 = $1479 >> 4; | |
| $1481 = $1480 + 1 | 0; | |
| $1482 = ($1479 | 0) < -16; | |
| if ($1482) { | |
| __ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv($1461), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1483 = $1467; | |
| $1484 = $1483 - $1478 | 0; | |
| $1485 = $1484 >> 4; | |
| $1486 = $1485 >>> 0 < 1073741823; | |
| if ($1486) { | |
| $1487 = $1484 >> 3; | |
| $1488 = $1487 >>> 0 < $1481 >>> 0; | |
| $1489 = $1488 ? $1481 : $1487; | |
| $$0$i$i$i138 = $1489; | |
| } else { | |
| $$0$i$i$i138 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEEC2EjjS9_($__v$i$i135, $$0$i$i$i138, $1480, $1475), asyncState ? abort(-12) | 0 : 0; | |
| $1490 = $__v$i$i135 + 8 | 0; | |
| $1491 = (tempInt = SAFE_HEAP_LOAD($1490 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1492 = ($1491 | 0) == (0 | 0); | |
| if (!$1492) { | |
| SAFE_HEAP_STORE($1491 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1493 = $1491 + 4 | 0; | |
| SAFE_HEAP_STORE($1493 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1494 = $1491 + 8 | 0; | |
| SAFE_HEAP_STORE($1494 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1495 = $1491 + 12 | 0; | |
| SAFE_HEAP_STORE($1495 | 0, $1463 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1496 = $1491 + 16 | 0; | |
| SAFE_HEAP_STORE($1490 | 0, $1496 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorINS0_IN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEENS4_IS6_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS6_RS7_EE($1461, $__v$i$i135), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEED2Ev($__v$i$i135), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1497 = $41 + 1 | 0; | |
| $1498 = $42 + 1 | 0; | |
| $1499 = $42 + 8 | 0; | |
| $1500 = $42 + 4 | 0; | |
| $1501 = $__v$i$i151 + 8 | 0; | |
| $1502 = $41 + 8 | 0; | |
| $1503 = $41 + 4 | 0; | |
| $k8$0 = $1451; | |
| while (1) { | |
| $1504 = $k8$0 >>> 0 < $1459 >>> 0; | |
| if (!$1504) { | |
| label = 1049; | |
| break; | |
| } | |
| $1505 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1506 = ($1505 + ($k8$0 * 24 | 0) | 0) + 12 | 0; | |
| $1507 = (tempInt = SAFE_HEAP_LOAD($1506 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1508 = $1507 & 1; | |
| $1509 = $1508 << 24 >> 24 == 0; | |
| if ($1509) { | |
| $1514 = $1507 & 255; | |
| $1515 = $1514 >>> 1; | |
| $1516 = $1506 + 1 | 0; | |
| $1518 = $1515; | |
| $1520 = $1516; | |
| } else { | |
| $1510 = ($1505 + ($k8$0 * 24 | 0) | 0) + 16 | 0; | |
| $1511 = (tempInt = SAFE_HEAP_LOAD($1510 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1512 = ($1505 + ($k8$0 * 24 | 0) | 0) + 20 | 0; | |
| $1513 = (tempInt = SAFE_HEAP_LOAD($1512 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1518 = $1511; | |
| $1520 = $1513; | |
| } | |
| $1517 = $1518 >>> 0 < 2; | |
| $1519 = $1517 ? $1518 : 2; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($41, $1520, $1519), asyncState ? abort(-12) | 0 : 0; | |
| $1521 = (tempInt = SAFE_HEAP_LOAD($41 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1522 = $1521 & 1; | |
| $1523 = $1522 << 24 >> 24 == 0; | |
| if ($1523) { | |
| $1526 = $1521 & 255; | |
| $1527 = $1526 >>> 1; | |
| $1529 = $1527; | |
| $1531 = $1497; | |
| } else { | |
| $1524 = (tempInt = SAFE_HEAP_LOAD($1503 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1525 = (tempInt = SAFE_HEAP_LOAD($1502 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1529 = $1524; | |
| $1531 = $1525; | |
| } | |
| $1528 = $1529 >>> 0 > 2; | |
| $1530 = $1528 ? 2 : $1529; | |
| $1532 = (tempInt = _memcmp($1531, 2744, $1530) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1533 = ($1532 | 0) != 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($41), asyncState ? abort(-12) | 0 : 0; | |
| $1534 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1535 = ($1529 | 0) != 2; | |
| $1536 = $1535 | $1533; | |
| if ($1536) { | |
| $1540 = ($1534 + ($k8$0 * 24 | 0) | 0) + 12 | 0; | |
| $1541 = (tempInt = SAFE_HEAP_LOAD($1540 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1542 = $1541 & 1; | |
| $1543 = $1542 << 24 >> 24 == 0; | |
| if ($1543) { | |
| $1546 = $1540 + 1 | 0; | |
| $1548 = $1546; | |
| } else { | |
| $1544 = ($1534 + ($k8$0 * 24 | 0) | 0) + 20 | 0; | |
| $1545 = (tempInt = SAFE_HEAP_LOAD($1544 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1548 = $1545; | |
| } | |
| $1547 = (tempInt = SAFE_HEAP_LOAD($1548 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1549 = $1547 << 24 >> 24 == 40; | |
| if ($1549) { | |
| $1550 = $1534 + ($k8$0 * 24 | 0) | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($1550, 2768) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1551 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1552 = ($1551 + ($k8$0 * 24 | 0) | 0) + 12 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6insertEjPKc($1552, 0, 2760) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } | |
| } else { | |
| $1537 = $1534 + ($k8$0 * 24 | 0) | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($1537, 2752) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1538 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1539 = ($1538 + ($k8$0 * 24 | 0) | 0) + 12 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6insertEjPKc($1539, 0, 2760) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } | |
| $1553 = (tempInt = SAFE_HEAP_LOAD($1452 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1554 = $1553 << 24 >> 24 == 85; | |
| $1555 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1556 = $1555 + ($k8$0 * 24 | 0) | 0; | |
| do { | |
| if ($1554) { | |
| $1557 = (tempInt = SAFE_HEAP_LOAD($1556 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1558 = $1557 & 1; | |
| $1559 = $1558 << 24 >> 24 == 0; | |
| if ($1559) { | |
| $1564 = $1557 & 255; | |
| $1565 = $1564 >>> 1; | |
| $1566 = $1556 + 1 | 0; | |
| $1568 = $1565; | |
| $1570 = $1566; | |
| } else { | |
| $1560 = ($1555 + ($k8$0 * 24 | 0) | 0) + 4 | 0; | |
| $1561 = (tempInt = SAFE_HEAP_LOAD($1560 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1562 = ($1555 + ($k8$0 * 24 | 0) | 0) + 8 | 0; | |
| $1563 = (tempInt = SAFE_HEAP_LOAD($1562 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1568 = $1561; | |
| $1570 = $1563; | |
| } | |
| $1567 = $1568 >>> 0 < 12; | |
| $1569 = $1567 ? $1568 : 12; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($42, $1570, $1569), asyncState ? abort(-12) | 0 : 0; | |
| $1571 = (tempInt = SAFE_HEAP_LOAD($42 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1572 = $1571 & 1; | |
| $1573 = $1572 << 24 >> 24 == 0; | |
| if ($1573) { | |
| $1576 = $1571 & 255; | |
| $1577 = $1576 >>> 1; | |
| $1579 = $1577; | |
| $1581 = $1498; | |
| } else { | |
| $1574 = (tempInt = SAFE_HEAP_LOAD($1500 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1575 = (tempInt = SAFE_HEAP_LOAD($1499 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1579 = $1574; | |
| $1581 = $1575; | |
| } | |
| $1578 = $1579 >>> 0 > 12; | |
| $1580 = $1578 ? 12 : $1579; | |
| $1582 = (tempInt = _memcmp($1581, 2784, $1580) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1583 = ($1582 | 0) == 0; | |
| if ($1583) { | |
| $1584 = $1579 >>> 0 < 12; | |
| $$$i$i$i$i = $1578 & 1; | |
| $$$$i$i$i$i = $1584 ? -1 : $$$i$i$i$i; | |
| $1586 = $$$$i$i$i$i; | |
| } else { | |
| $1586 = $1582; | |
| } | |
| $1585 = ($1586 | 0) == 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($42), asyncState ? abort(-12) | 0 : 0; | |
| $1587 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1588 = $1587 + ($k8$0 * 24 | 0) | 0; | |
| if ($1585) { | |
| $1590 = (tempInt = SAFE_HEAP_LOAD($1588 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1591 = $1590 & 1; | |
| $1592 = $1591 << 24 >> 24 == 0; | |
| if ($1592) { | |
| $1593 = $1590 & 255; | |
| $1594 = $1593 >>> 1; | |
| $1595 = $1594 >>> 0 < 11; | |
| $1596 = $1595 ? $1594 : 11; | |
| $1605 = $1596; | |
| $1606 = $1594; | |
| $1608 = 10; | |
| $1611 = $1590; | |
| } else { | |
| $1597 = ($1587 + ($k8$0 * 24 | 0) | 0) + 4 | 0; | |
| $1598 = (tempInt = SAFE_HEAP_LOAD($1597 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1599 = $1598 >>> 0 < 11; | |
| $1600 = $1599 ? $1598 : 11; | |
| $1601 = (tempInt = SAFE_HEAP_LOAD($1588 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1602 = $1601 & -2; | |
| $phitmp$i$i$i = $1602 + -1 | 0; | |
| $1603 = $1601 & 255; | |
| $1605 = $1600; | |
| $1606 = $1598; | |
| $1608 = $phitmp$i$i$i; | |
| $1611 = $1603; | |
| } | |
| $1604 = $1605 - $1606 | 0; | |
| $1607 = $1604 + $1608 | 0; | |
| $1609 = $1607 >>> 0 < 2; | |
| if ($1609) { | |
| $1645 = 2 - $1605 | 0; | |
| $1646 = $1645 + $1606 | 0; | |
| $1647 = $1646 - $1608 | 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE21__grow_by_and_replaceEjjjjjjPKc($1588, $1608, $1647, $1606, 0, $1605, 2, 2808), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| $1610 = $1611 & 1; | |
| $1612 = $1610 << 24 >> 24 == 0; | |
| if ($1612) { | |
| $1615 = $1588 + 1 | 0; | |
| $1620 = $1615; | |
| } else { | |
| $1613 = ($1587 + ($k8$0 * 24 | 0) | 0) + 8 | 0; | |
| $1614 = (tempInt = SAFE_HEAP_LOAD($1613 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1620 = $1614; | |
| } | |
| $1616 = ($1605 | 0) == 2; | |
| do { | |
| if ($1616) { | |
| $$1$i$i = 0; | |
| $$12$i$i = 2808; | |
| $$14$i$i = 2; | |
| $2941 = 2; | |
| label = 587; | |
| } else { | |
| $1617 = $1606 - $1605 | 0; | |
| $1618 = ($1606 | 0) == ($1605 | 0); | |
| if ($1618) { | |
| $$1$i$i = 0; | |
| $$12$i$i = 2808; | |
| $$14$i$i = 2; | |
| $2941 = $1605; | |
| label = 587; | |
| break; | |
| } | |
| $1619 = $1605 >>> 0 > 2; | |
| if ($1619) { | |
| SAFE_HEAP_STORE($1620 >> 0 | 0, 25705 & 255 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1620 + 1 >> 0 | 0, 25705 >> 8 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1621 = $1620 + 2 | 0; | |
| $1622 = $1620 + $1605 | 0; | |
| (tempInt = _memmove($1621 | 0, $1622 | 0, $1617 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $$2$i$i = 2; | |
| $1636 = $1605; | |
| break; | |
| } | |
| $1623 = $1620 >>> 0 < 2808 >>> 0; | |
| $1624 = $1620 + $1606 | 0; | |
| $1625 = $1624 >>> 0 > 2808 >>> 0; | |
| $or$cond$i$i = $1623 & $1625; | |
| do { | |
| if ($or$cond$i$i) { | |
| $1626 = $1620 + $1605 | 0; | |
| $1627 = $1626 >>> 0 > 2808 >>> 0; | |
| if ($1627) { | |
| (tempInt = _memcpy($1620 | 0, 2808 | 0, $1605 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1630 = 2 - $1605 | 0; | |
| $$0$i$i = $1605; | |
| $$01$i$i = 2808 + 2 | 0; | |
| $$03$i$i = $1630; | |
| $1632 = 0; | |
| break; | |
| } else { | |
| $1628 = 2 - $1605 | 0; | |
| $1629 = 2808 + $1628 | 0; | |
| $$0$i$i = 0; | |
| $$01$i$i = $1629; | |
| $$03$i$i = 2; | |
| $1632 = $1605; | |
| break; | |
| } | |
| } else { | |
| $$0$i$i = 0; | |
| $$01$i$i = 2808; | |
| $$03$i$i = 2; | |
| $1632 = $1605; | |
| } | |
| } while (0); | |
| $$sum$i$i = $$0$i$i + $$03$i$i | 0; | |
| $1631 = $1620 + $$sum$i$i | 0; | |
| $$sum1$i$i = $$0$i$i + $1632 | 0; | |
| $1633 = $1620 + $$sum1$i$i | 0; | |
| (tempInt = _memmove($1631 | 0, $1633 | 0, $1617 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $$1$i$i = $$0$i$i; | |
| $$12$i$i = $$01$i$i; | |
| $$14$i$i = $$03$i$i; | |
| $2941 = $1632; | |
| label = 587; | |
| } | |
| } while (0); | |
| if ((label | 0) == 587) { | |
| label = 0; | |
| $1634 = $1620 + $$1$i$i | 0; | |
| (tempInt = _memmove($1634 | 0, $$12$i$i | 0, $$14$i$i | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $$2$i$i = $$14$i$i; | |
| $1636 = $2941; | |
| } | |
| $1635 = $$2$i$i - $1636 | 0; | |
| $1637 = $1635 + $1606 | 0; | |
| $1638 = (tempInt = SAFE_HEAP_LOAD($1588 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1639 = $1638 & 1; | |
| $1640 = $1639 << 24 >> 24 == 0; | |
| if ($1640) { | |
| $1642 = $1637 << 1; | |
| $1643 = $1642 & 255; | |
| SAFE_HEAP_STORE($1588 >> 0 | 0, $1643 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1641 = ($1587 + ($k8$0 * 24 | 0) | 0) + 4 | 0; | |
| SAFE_HEAP_STORE($1641 | 0, $1637 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1644 = $1620 + $1637 | 0; | |
| SAFE_HEAP_STORE($1644 >> 0 | 0, 0 | 0, 1, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1589 = $1588; | |
| label = 570; | |
| } | |
| } else { | |
| $1589 = $1556; | |
| label = 570; | |
| } | |
| } while (0); | |
| if ((label | 0) == 570) { | |
| label = 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($1589, 2800) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } | |
| $1648 = (tempInt = SAFE_HEAP_LOAD($1464 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1649 = $1648 + -16 | 0; | |
| $1650 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1651 = $1650 + ($k8$0 * 24 | 0) | 0; | |
| $1652 = $1648 + -12 | 0; | |
| $1653 = (tempInt = SAFE_HEAP_LOAD($1652 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1654 = $1648 + -8 | 0; | |
| $1655 = (tempInt = SAFE_HEAP_LOAD($1654 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1656 = ($1653 | 0) == ($1655 | 0); | |
| if ($1656) { | |
| $1666 = $1648 + -4 | 0; | |
| $1667 = (tempInt = SAFE_HEAP_LOAD($1649 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1668 = $1653; | |
| $1669 = $1667; | |
| $1670 = $1668 - $1669 | 0; | |
| $1671 = ($1670 | 0) / 24 & -1; | |
| $1672 = $1671 + 1 | 0; | |
| $1673 = ($1672 | 0) < 0; | |
| if ($1673) { | |
| $$lcssa580 = $1649; | |
| label = 600; | |
| break; | |
| } | |
| $1674 = $1671 >>> 0 < 1073741823; | |
| if ($1674) { | |
| $1675 = $1671 << 1; | |
| $1676 = $1675 >>> 0 < $1672 >>> 0; | |
| $1677 = $1676 ? $1672 : $1675; | |
| $$0$i$i$i155 = $1677; | |
| } else { | |
| $$0$i$i$i155 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEEC2EjjS6_($__v$i$i151, $$0$i$i$i155, $1671, $1666), asyncState ? abort(-12) | 0 : 0; | |
| $1678 = (tempInt = SAFE_HEAP_LOAD($1501 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1679 = ($1678 | 0) == (0 | 0); | |
| if (!$1679) { | |
| __THREW__ = 0; | |
| invoke_vii(12, $1678 | 0, $1651 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1680 = __THREW__; | |
| __THREW__ = 0; | |
| $1681 = $1680 & 1; | |
| if ($1681) { | |
| label = 607; | |
| break; | |
| } | |
| $1682 = $1678 + 12 | 0; | |
| $1683 = ($1650 + ($k8$0 * 24 | 0) | 0) + 12 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(12, $1682 | 0, $1683 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1684 = __THREW__; | |
| __THREW__ = 0; | |
| $1685 = $1684 & 1; | |
| if ($1685) { | |
| $$lcssa585 = $1678; | |
| label = 606; | |
| break; | |
| } | |
| } | |
| $1690 = $1678 + 24 | 0; | |
| SAFE_HEAP_STORE($1501 | 0, $1690 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS3_RS5_EE($1649, $__v$i$i151), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i151), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1657 = ($1653 | 0) == (0 | 0); | |
| if ($1657) { | |
| $1665 = 0; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEEC2ERKS7_($1653, $1651), asyncState ? abort(-12) | 0 : 0; | |
| $1658 = $1653 + 12 | 0; | |
| $1659 = ($1650 + ($k8$0 * 24 | 0) | 0) + 12 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(12, $1658 | 0, $1659 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1660 = __THREW__; | |
| __THREW__ = 0; | |
| $1661 = $1660 & 1; | |
| if ($1661) { | |
| $$lcssa583 = $1653; | |
| label = 597; | |
| break; | |
| } | |
| $$pre$i152 = (tempInt = SAFE_HEAP_LOAD($1652 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1665 = $$pre$i152; | |
| } | |
| $1664 = $1665 + 24 | 0; | |
| SAFE_HEAP_STORE($1652 | 0, $1664 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1691 = $k8$0 + 1 | 0; | |
| $k8$0 = $1691; | |
| } | |
| if ((label | 0) == 597) { | |
| $1662 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1663 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($$lcssa583), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($1662 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } else if ((label | 0) == 600) { | |
| __ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv($$lcssa580), asyncState ? abort(-12) | 0 : 0; | |
| } else if ((label | 0) == 606) { | |
| $1686 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1687 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($$lcssa585), asyncState ? abort(-12) | 0 : 0; | |
| $eh$lpad$body$i$i158$index19Z2D = $1687; | |
| $eh$lpad$body$i$i158$indexZ2D = $1686; | |
| } else if ((label | 0) == 607) { | |
| $1688 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1689 = tempRet0; | |
| $eh$lpad$body$i$i158$index19Z2D = $1689; | |
| $eh$lpad$body$i$i158$indexZ2D = $1688; | |
| } else if ((label | 0) == 1049) { | |
| $$0 = $1453; | |
| break L1; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i151), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($eh$lpad$body$i$i158$indexZ2D | 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| case 82: | |
| { | |
| $1692 = $db + 4 | 0; | |
| $1693 = (tempInt = SAFE_HEAP_LOAD($1692 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1694 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1695 = $1693; | |
| $1696 = $1694; | |
| $1697 = $1695 - $1696 | 0; | |
| $1698 = ($1697 | 0) / 24 & -1; | |
| $1699 = $first + 1 | 0; | |
| $1700 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($1699, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1701 = (tempInt = SAFE_HEAP_LOAD($1692 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1702 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1703 = $1701; | |
| $1704 = $1702; | |
| $1705 = $1703 - $1704 | 0; | |
| $1706 = ($1705 | 0) / 24 & -1; | |
| $1707 = ($1700 | 0) == ($1699 | 0); | |
| if ($1707) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1708 = $db + 16 | 0; | |
| $1709 = $db + 12 | 0; | |
| $1710 = (tempInt = SAFE_HEAP_LOAD($1709 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1711 = $db + 20 | 0; | |
| $1712 = (tempInt = SAFE_HEAP_LOAD($1711 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1713 = $db + 24 | 0; | |
| $1714 = (tempInt = SAFE_HEAP_LOAD($1713 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1715 = $1712 >>> 0 < $1714 >>> 0; | |
| if ($1715) { | |
| $1716 = ($1712 | 0) == (0 | 0); | |
| if ($1716) { | |
| $1721 = 0; | |
| } else { | |
| SAFE_HEAP_STORE($1712 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1717 = $1712 + 4 | 0; | |
| SAFE_HEAP_STORE($1717 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1718 = $1712 + 8 | 0; | |
| SAFE_HEAP_STORE($1718 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1719 = $1712 + 12 | 0; | |
| SAFE_HEAP_STORE($1719 | 0, $1710 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i163 = (tempInt = SAFE_HEAP_LOAD($1711 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1721 = $$pre$i163; | |
| } | |
| $1720 = $1721 + 16 | 0; | |
| SAFE_HEAP_STORE($1711 | 0, $1720 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1722 = $db + 28 | 0; | |
| $1723 = (tempInt = SAFE_HEAP_LOAD($1708 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1724 = $1712; | |
| $1725 = $1723; | |
| $1726 = $1724 - $1725 | 0; | |
| $1727 = $1726 >> 4; | |
| $1728 = $1727 + 1 | 0; | |
| $1729 = ($1726 | 0) < -16; | |
| if ($1729) { | |
| __ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv($1708), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1730 = $1714; | |
| $1731 = $1730 - $1725 | 0; | |
| $1732 = $1731 >> 4; | |
| $1733 = $1732 >>> 0 < 1073741823; | |
| if ($1733) { | |
| $1734 = $1731 >> 3; | |
| $1735 = $1734 >>> 0 < $1728 >>> 0; | |
| $1736 = $1735 ? $1728 : $1734; | |
| $$0$i$i$i165 = $1736; | |
| } else { | |
| $$0$i$i$i165 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEEC2EjjS9_($__v$i$i162, $$0$i$i$i165, $1727, $1722), asyncState ? abort(-12) | 0 : 0; | |
| $1737 = $__v$i$i162 + 8 | 0; | |
| $1738 = (tempInt = SAFE_HEAP_LOAD($1737 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1739 = ($1738 | 0) == (0 | 0); | |
| if (!$1739) { | |
| SAFE_HEAP_STORE($1738 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1740 = $1738 + 4 | 0; | |
| SAFE_HEAP_STORE($1740 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1741 = $1738 + 8 | 0; | |
| SAFE_HEAP_STORE($1741 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1742 = $1738 + 12 | 0; | |
| SAFE_HEAP_STORE($1742 | 0, $1710 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1743 = $1738 + 16 | 0; | |
| SAFE_HEAP_STORE($1737 | 0, $1743 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorINS0_IN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEENS4_IS6_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS6_RS7_EE($1708, $__v$i$i162), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEED2Ev($__v$i$i162), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1744 = $43 + 1 | 0; | |
| $1745 = $__v$i$i177 + 8 | 0; | |
| $1746 = $43 + 8 | 0; | |
| $1747 = $43 + 4 | 0; | |
| $k11$0 = $1698; | |
| while (1) { | |
| $1748 = $k11$0 >>> 0 < $1706 >>> 0; | |
| if (!$1748) { | |
| label = 1050; | |
| break; | |
| } | |
| $1749 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1750 = ($1749 + ($k11$0 * 24 | 0) | 0) + 12 | 0; | |
| $1751 = (tempInt = SAFE_HEAP_LOAD($1750 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1752 = $1751 & 1; | |
| $1753 = $1752 << 24 >> 24 == 0; | |
| if ($1753) { | |
| $1758 = $1751 & 255; | |
| $1759 = $1758 >>> 1; | |
| $1760 = $1750 + 1 | 0; | |
| $1762 = $1759; | |
| $1764 = $1760; | |
| } else { | |
| $1754 = ($1749 + ($k11$0 * 24 | 0) | 0) + 16 | 0; | |
| $1755 = (tempInt = SAFE_HEAP_LOAD($1754 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1756 = ($1749 + ($k11$0 * 24 | 0) | 0) + 20 | 0; | |
| $1757 = (tempInt = SAFE_HEAP_LOAD($1756 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1762 = $1755; | |
| $1764 = $1757; | |
| } | |
| $1761 = $1762 >>> 0 < 2; | |
| $1763 = $1761 ? $1762 : 2; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6__initEPKcj($43, $1764, $1763), asyncState ? abort(-12) | 0 : 0; | |
| $1765 = (tempInt = SAFE_HEAP_LOAD($43 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1766 = $1765 & 1; | |
| $1767 = $1766 << 24 >> 24 == 0; | |
| if ($1767) { | |
| $1770 = $1765 & 255; | |
| $1771 = $1770 >>> 1; | |
| $1773 = $1771; | |
| $1775 = $1744; | |
| } else { | |
| $1768 = (tempInt = SAFE_HEAP_LOAD($1747 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1769 = (tempInt = SAFE_HEAP_LOAD($1746 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1773 = $1768; | |
| $1775 = $1769; | |
| } | |
| $1772 = $1773 >>> 0 > 2; | |
| $1774 = $1772 ? 2 : $1773; | |
| $1776 = (tempInt = _memcmp($1775, 2744, $1774) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1777 = ($1776 | 0) != 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($43), asyncState ? abort(-12) | 0 : 0; | |
| $1778 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1779 = ($1773 | 0) != 2; | |
| $1780 = $1779 | $1777; | |
| if ($1780) { | |
| $1784 = ($1778 + ($k11$0 * 24 | 0) | 0) + 12 | 0; | |
| $1785 = (tempInt = SAFE_HEAP_LOAD($1784 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1786 = $1785 & 1; | |
| $1787 = $1786 << 24 >> 24 == 0; | |
| if ($1787) { | |
| $1790 = $1784 + 1 | 0; | |
| $1792 = $1790; | |
| } else { | |
| $1788 = ($1778 + ($k11$0 * 24 | 0) | 0) + 20 | 0; | |
| $1789 = (tempInt = SAFE_HEAP_LOAD($1788 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1792 = $1789; | |
| } | |
| $1791 = (tempInt = SAFE_HEAP_LOAD($1792 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1793 = $1791 << 24 >> 24 == 40; | |
| if ($1793) { | |
| $1794 = $1778 + ($k11$0 * 24 | 0) | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($1794, 2768) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1795 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1796 = ($1795 + ($k11$0 * 24 | 0) | 0) + 12 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6insertEjPKc($1796, 0, 2760) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } | |
| } else { | |
| $1781 = $1778 + ($k11$0 * 24 | 0) | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($1781, 2752) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1782 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1783 = ($1782 + ($k11$0 * 24 | 0) | 0) + 12 | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6insertEjPKc($1783, 0, 2760) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| } | |
| $1797 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1798 = $1797 + ($k11$0 * 24 | 0) | 0; | |
| (tempInt = __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEE6appendEPKc($1798, 2816) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1799 = (tempInt = SAFE_HEAP_LOAD($1711 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1800 = $1799 + -16 | 0; | |
| $1801 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1802 = $1801 + ($k11$0 * 24 | 0) | 0; | |
| $1803 = $1799 + -12 | 0; | |
| $1804 = (tempInt = SAFE_HEAP_LOAD($1803 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1805 = $1799 + -8 | 0; | |
| $1806 = (tempInt = SAFE_HEAP_LOAD($1805 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1807 = ($1804 | 0) == ($1806 | 0); | |
| if ($1807) { | |
| $1817 = $1799 + -4 | 0; | |
| $1818 = (tempInt = SAFE_HEAP_LOAD($1800 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1819 = $1804; | |
| $1820 = $1818; | |
| $1821 = $1819 - $1820 | 0; | |
| $1822 = ($1821 | 0) / 24 & -1; | |
| $1823 = $1822 + 1 | 0; | |
| $1824 = ($1823 | 0) < 0; | |
| if ($1824) { | |
| $$lcssa587 = $1800; | |
| label = 645; | |
| break; | |
| } | |
| $1825 = $1822 >>> 0 < 1073741823; | |
| if ($1825) { | |
| $1826 = $1822 << 1; | |
| $1827 = $1826 >>> 0 < $1823 >>> 0; | |
| $1828 = $1827 ? $1823 : $1826; | |
| $$0$i$i$i181 = $1828; | |
| } else { | |
| $$0$i$i$i181 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEEC2EjjS6_($__v$i$i177, $$0$i$i$i181, $1822, $1817), asyncState ? abort(-12) | 0 : 0; | |
| $1829 = (tempInt = SAFE_HEAP_LOAD($1745 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1830 = ($1829 | 0) == (0 | 0); | |
| if (!$1830) { | |
| __THREW__ = 0; | |
| invoke_vii(12, $1829 | 0, $1802 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1831 = __THREW__; | |
| __THREW__ = 0; | |
| $1832 = $1831 & 1; | |
| if ($1832) { | |
| label = 652; | |
| break; | |
| } | |
| $1833 = $1829 + 12 | 0; | |
| $1834 = ($1801 + ($k11$0 * 24 | 0) | 0) + 12 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(12, $1833 | 0, $1834 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1835 = __THREW__; | |
| __THREW__ = 0; | |
| $1836 = $1835 & 1; | |
| if ($1836) { | |
| $$lcssa592 = $1829; | |
| label = 651; | |
| break; | |
| } | |
| } | |
| $1841 = $1829 + 24 | 0; | |
| SAFE_HEAP_STORE($1745 | 0, $1841 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS3_RS5_EE($1800, $__v$i$i177), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i177), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1808 = ($1804 | 0) == (0 | 0); | |
| if ($1808) { | |
| $1816 = 0; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEEC2ERKS7_($1804, $1802), asyncState ? abort(-12) | 0 : 0; | |
| $1809 = $1804 + 12 | 0; | |
| $1810 = ($1801 + ($k11$0 * 24 | 0) | 0) + 12 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(12, $1809 | 0, $1810 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1811 = __THREW__; | |
| __THREW__ = 0; | |
| $1812 = $1811 & 1; | |
| if ($1812) { | |
| $$lcssa590 = $1804; | |
| label = 642; | |
| break; | |
| } | |
| $$pre$i178 = (tempInt = SAFE_HEAP_LOAD($1803 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1816 = $$pre$i178; | |
| } | |
| $1815 = $1816 + 24 | 0; | |
| SAFE_HEAP_STORE($1803 | 0, $1815 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1842 = $k11$0 + 1 | 0; | |
| $k11$0 = $1842; | |
| } | |
| if ((label | 0) == 642) { | |
| $1813 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1814 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($$lcssa590), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($1813 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } else if ((label | 0) == 645) { | |
| __ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv($$lcssa587), asyncState ? abort(-12) | 0 : 0; | |
| } else if ((label | 0) == 651) { | |
| $1837 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1838 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($$lcssa592), asyncState ? abort(-12) | 0 : 0; | |
| $eh$lpad$body$i$i184$index24Z2D = $1838; | |
| $eh$lpad$body$i$i184$indexZ2D = $1837; | |
| } else if ((label | 0) == 652) { | |
| $1839 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1840 = tempRet0; | |
| $eh$lpad$body$i$i184$index24Z2D = $1840; | |
| $eh$lpad$body$i$i184$indexZ2D = $1839; | |
| } else if ((label | 0) == 1050) { | |
| $$0 = $1700; | |
| break L1; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i177), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($eh$lpad$body$i$i184$indexZ2D | 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| case 84: | |
| { | |
| $1843 = $db + 4 | 0; | |
| $1844 = (tempInt = SAFE_HEAP_LOAD($1843 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1845 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1846 = $1844; | |
| $1847 = $1845; | |
| $1848 = $1846 - $1847 | 0; | |
| $1849 = ($1848 | 0) / 24 & -1; | |
| $1850 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_120parse_template_paramINS0_2DbEEEPKcS4_S4_RT_($first, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1851 = (tempInt = SAFE_HEAP_LOAD($1843 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1852 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1853 = $1851; | |
| $1854 = $1852; | |
| $1855 = $1853 - $1854 | 0; | |
| $1856 = ($1855 | 0) / 24 & -1; | |
| $1857 = ($1850 | 0) == ($first | 0); | |
| if ($1857) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $1858 = $db + 16 | 0; | |
| $1859 = $db + 12 | 0; | |
| $1860 = (tempInt = SAFE_HEAP_LOAD($1859 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1861 = $db + 20 | 0; | |
| $1862 = (tempInt = SAFE_HEAP_LOAD($1861 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1863 = $db + 24 | 0; | |
| $1864 = (tempInt = SAFE_HEAP_LOAD($1863 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1865 = $1862 >>> 0 < $1864 >>> 0; | |
| if ($1865) { | |
| $1866 = ($1862 | 0) == (0 | 0); | |
| if ($1866) { | |
| $1871 = 0; | |
| } else { | |
| SAFE_HEAP_STORE($1862 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1867 = $1862 + 4 | 0; | |
| SAFE_HEAP_STORE($1867 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1868 = $1862 + 8 | 0; | |
| SAFE_HEAP_STORE($1868 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1869 = $1862 + 12 | 0; | |
| SAFE_HEAP_STORE($1869 | 0, $1860 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i189 = (tempInt = SAFE_HEAP_LOAD($1861 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1871 = $$pre$i189; | |
| } | |
| $1870 = $1871 + 16 | 0; | |
| SAFE_HEAP_STORE($1861 | 0, $1870 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1872 = $db + 28 | 0; | |
| $1873 = (tempInt = SAFE_HEAP_LOAD($1858 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1874 = $1862; | |
| $1875 = $1873; | |
| $1876 = $1874 - $1875 | 0; | |
| $1877 = $1876 >> 4; | |
| $1878 = $1877 + 1 | 0; | |
| $1879 = ($1876 | 0) < -16; | |
| if ($1879) { | |
| __ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv($1858), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1880 = $1864; | |
| $1881 = $1880 - $1875 | 0; | |
| $1882 = $1881 >> 4; | |
| $1883 = $1882 >>> 0 < 1073741823; | |
| if ($1883) { | |
| $1884 = $1881 >> 3; | |
| $1885 = $1884 >>> 0 < $1878 >>> 0; | |
| $1886 = $1885 ? $1878 : $1884; | |
| $$0$i$i$i191 = $1886; | |
| } else { | |
| $$0$i$i$i191 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEEC2EjjS9_($__v$i$i188, $$0$i$i$i191, $1877, $1872), asyncState ? abort(-12) | 0 : 0; | |
| $1887 = $__v$i$i188 + 8 | 0; | |
| $1888 = (tempInt = SAFE_HEAP_LOAD($1887 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1889 = ($1888 | 0) == (0 | 0); | |
| if (!$1889) { | |
| SAFE_HEAP_STORE($1888 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1890 = $1888 + 4 | 0; | |
| SAFE_HEAP_STORE($1890 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1891 = $1888 + 8 | 0; | |
| SAFE_HEAP_STORE($1891 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1892 = $1888 + 12 | 0; | |
| SAFE_HEAP_STORE($1892 | 0, $1860 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1893 = $1888 + 16 | 0; | |
| SAFE_HEAP_STORE($1887 | 0, $1893 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorINS0_IN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEENS4_IS6_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS6_RS7_EE($1858, $__v$i$i188), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEED2Ev($__v$i$i188), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1894 = $__v$i$i195 + 8 | 0; | |
| $k15$0 = $1849; | |
| while (1) { | |
| $1895 = $k15$0 >>> 0 < $1856 >>> 0; | |
| if (!$1895) { | |
| label = 688; | |
| break; | |
| } | |
| $1896 = (tempInt = SAFE_HEAP_LOAD($1861 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1897 = $1896 + -16 | 0; | |
| $1898 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1899 = $1898 + ($k15$0 * 24 | 0) | 0; | |
| $1900 = $1896 + -12 | 0; | |
| $1901 = (tempInt = SAFE_HEAP_LOAD($1900 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1902 = $1896 + -8 | 0; | |
| $1903 = (tempInt = SAFE_HEAP_LOAD($1902 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1904 = ($1901 | 0) == ($1903 | 0); | |
| if ($1904) { | |
| $1914 = $1896 + -4 | 0; | |
| $1915 = (tempInt = SAFE_HEAP_LOAD($1897 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1916 = $1901; | |
| $1917 = $1915; | |
| $1918 = $1916 - $1917 | 0; | |
| $1919 = ($1918 | 0) / 24 & -1; | |
| $1920 = $1919 + 1 | 0; | |
| $1921 = ($1920 | 0) < 0; | |
| if ($1921) { | |
| $$lcssa594 = $1897; | |
| label = 677; | |
| break; | |
| } | |
| $1922 = $1919 >>> 0 < 1073741823; | |
| if ($1922) { | |
| $1923 = $1919 << 1; | |
| $1924 = $1923 >>> 0 < $1920 >>> 0; | |
| $1925 = $1924 ? $1920 : $1923; | |
| $$0$i$i$i199 = $1925; | |
| } else { | |
| $$0$i$i$i199 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEEC2EjjS6_($__v$i$i195, $$0$i$i$i199, $1919, $1914), asyncState ? abort(-12) | 0 : 0; | |
| $1926 = (tempInt = SAFE_HEAP_LOAD($1894 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1927 = ($1926 | 0) == (0 | 0); | |
| if (!$1927) { | |
| __THREW__ = 0; | |
| invoke_vii(12, $1926 | 0, $1899 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1928 = __THREW__; | |
| __THREW__ = 0; | |
| $1929 = $1928 & 1; | |
| if ($1929) { | |
| label = 684; | |
| break; | |
| } | |
| $1930 = $1926 + 12 | 0; | |
| $1931 = ($1898 + ($k15$0 * 24 | 0) | 0) + 12 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(12, $1930 | 0, $1931 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1932 = __THREW__; | |
| __THREW__ = 0; | |
| $1933 = $1932 & 1; | |
| if ($1933) { | |
| $$lcssa599 = $1926; | |
| label = 683; | |
| break; | |
| } | |
| } | |
| $1938 = $1926 + 24 | 0; | |
| SAFE_HEAP_STORE($1894 | 0, $1938 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS3_RS5_EE($1897, $__v$i$i195), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i195), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1905 = ($1901 | 0) == (0 | 0); | |
| if ($1905) { | |
| $1913 = 0; | |
| } else { | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEEC2ERKS7_($1901, $1899), asyncState ? abort(-12) | 0 : 0; | |
| $1906 = $1901 + 12 | 0; | |
| $1907 = ($1898 + ($k15$0 * 24 | 0) | 0) + 12 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(12, $1906 | 0, $1907 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1908 = __THREW__; | |
| __THREW__ = 0; | |
| $1909 = $1908 & 1; | |
| if ($1909) { | |
| $$lcssa597 = $1901; | |
| label = 674; | |
| break; | |
| } | |
| $$pre$i196 = (tempInt = SAFE_HEAP_LOAD($1900 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1913 = $$pre$i196; | |
| } | |
| $1912 = $1913 + 24 | 0; | |
| SAFE_HEAP_STORE($1900 | 0, $1912 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $1939 = $k15$0 + 1 | 0; | |
| $k15$0 = $1939; | |
| } | |
| if ((label | 0) == 674) { | |
| $1910 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1911 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($$lcssa597), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($1910 | 0), asyncState ? abort(-12) | 0 : 0; | |
| } else if ((label | 0) == 677) { | |
| __ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv($$lcssa594), asyncState ? abort(-12) | 0 : 0; | |
| } else if ((label | 0) == 683) { | |
| $1934 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1935 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($$lcssa599), asyncState ? abort(-12) | 0 : 0; | |
| $eh$lpad$body$i$i202$index29Z2D = $1935; | |
| $eh$lpad$body$i$i202$indexZ2D = $1934; | |
| } else if ((label | 0) == 684) { | |
| $1936 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1937 = tempRet0; | |
| $eh$lpad$body$i$i202$index29Z2D = $1937; | |
| $eh$lpad$body$i$i202$indexZ2D = $1936; | |
| } else if ((label | 0) == 688) { | |
| $1940 = $db + 63 | 0; | |
| $1941 = (tempInt = SAFE_HEAP_LOAD($1940 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1942 = $1941 << 24 >> 24 != 0; | |
| $1943 = $1849 + 1 | 0; | |
| $1944 = ($1856 | 0) == ($1943 | 0); | |
| $or$cond = $1944 & $1942; | |
| if (!$or$cond) { | |
| $$0 = $1850; | |
| break L1; | |
| } | |
| $1945 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_119parse_template_argsINS0_2DbEEEPKcS4_S4_RT_($1850, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1946 = ($1945 | 0) == ($1850 | 0); | |
| if ($1946) { | |
| $$0 = $1850; | |
| break L1; | |
| } | |
| $1947 = (tempInt = SAFE_HEAP_LOAD($1843 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1948 = $1947 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($args, $1948), asyncState ? abort(-12) | 0 : 0; | |
| $1949 = (tempInt = SAFE_HEAP_LOAD($1843 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1950 = $1949 + -24 | 0; | |
| $1952 = $1949; | |
| while (1) { | |
| $1951 = ($1952 | 0) == ($1950 | 0); | |
| if ($1951) { | |
| break; | |
| } | |
| $1953 = $1952 + -24 | 0; | |
| SAFE_HEAP_STORE($1843 | 0, $1953 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($1953), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i206 = (tempInt = SAFE_HEAP_LOAD($1843 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1952 = $$pre$i206; | |
| } | |
| $1954 = $1949 + -48 | 0; | |
| $1955 = (tempInt = SAFE_HEAP_LOAD($args >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1956 = $1955 & 1; | |
| $1957 = $1956 << 24 >> 24 == 0; | |
| if ($1957) { | |
| $1962 = $args + 1 | 0; | |
| $1963 = $1955 & 255; | |
| $1964 = $1963 >>> 1; | |
| $1965 = $1962; | |
| $1966 = $1964; | |
| } else { | |
| $1958 = $args + 8 | 0; | |
| $1959 = (tempInt = SAFE_HEAP_LOAD($1958 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1960 = $args + 4 | 0; | |
| $1961 = (tempInt = SAFE_HEAP_LOAD($1960 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1965 = $1959; | |
| $1966 = $1961; | |
| } | |
| __THREW__ = 0; | |
| (tempInt = invoke_iiii(3, $1954 | 0, $1965 | 0, $1966 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $1967 = __THREW__; | |
| __THREW__ = 0; | |
| $1968 = $1967 & 1; | |
| do { | |
| if ($1968) { | |
| label = 711; | |
| } else { | |
| $1969 = (tempInt = SAFE_HEAP_LOAD($1843 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1970 = $1969 + -24 | 0; | |
| $1971 = (tempInt = SAFE_HEAP_LOAD($1859 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($45 | 0, $1971 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __THREW__ = 0; | |
| invoke_viii(15, $44 | 0, $1970 | 0, $45 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1972 = __THREW__; | |
| __THREW__ = 0; | |
| $1973 = $1972 & 1; | |
| if ($1973) { | |
| label = 711; | |
| } else { | |
| $1974 = (tempInt = SAFE_HEAP_LOAD($1861 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1975 = (tempInt = SAFE_HEAP_LOAD($1863 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1976 = $1974 >>> 0 < $1975 >>> 0; | |
| if ($1976) { | |
| $1977 = ($1974 | 0) == (0 | 0); | |
| if ($1977) { | |
| $1989 = 0; | |
| } else { | |
| $1978 = $1974 + 4 | 0; | |
| $1979 = $44 + 12 | 0; | |
| $1980 = (tempInt = SAFE_HEAP_LOAD($1979 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1981 = $1974 + 8 | 0; | |
| $1982 = $1974 + 12 | 0; | |
| SAFE_HEAP_STORE($1982 | 0, $1980 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1983 = (tempInt = SAFE_HEAP_LOAD($44 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1974 | 0, $1983 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1984 = $44 + 4 | 0; | |
| $1985 = (tempInt = SAFE_HEAP_LOAD($1984 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1978 | 0, $1985 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $1986 = $44 + 8 | 0; | |
| $1987 = (tempInt = SAFE_HEAP_LOAD($1986 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($1981 | 0, $1987 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1986 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($1984 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($44 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i212 = (tempInt = SAFE_HEAP_LOAD($1861 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1989 = $$pre$i212; | |
| } | |
| $1988 = $1989 + 16 | 0; | |
| SAFE_HEAP_STORE($1861 | 0, $1988 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $1990 = $db + 28 | 0; | |
| $1991 = (tempInt = SAFE_HEAP_LOAD($1858 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $1992 = $1974; | |
| $1993 = $1991; | |
| $1994 = $1992 - $1993 | 0; | |
| $1995 = $1994 >> 4; | |
| $1996 = $1995 + 1 | 0; | |
| $1997 = ($1994 | 0) < -16; | |
| if ($1997) { | |
| __THREW__ = 0; | |
| invoke_vi(14, $1858 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $1998 = __THREW__; | |
| __THREW__ = 0; | |
| $1999 = $1998 & 1; | |
| if ($1999) { | |
| $2023 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2024 = tempRet0; | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($44), asyncState ? abort(-12) | 0 : 0; | |
| $$02 = $2023; | |
| $$03 = $2024; | |
| break; | |
| } else {} | |
| } | |
| $2000 = $1975; | |
| $2001 = $2000 - $1993 | 0; | |
| $2002 = $2001 >> 4; | |
| $2003 = $2002 >>> 0 < 1073741823; | |
| if ($2003) { | |
| $2004 = $2001 >> 3; | |
| $2005 = $2004 >>> 0 < $1996 >>> 0; | |
| $2006 = $2005 ? $1996 : $2004; | |
| $$0$i$i$i214 = $2006; | |
| } else { | |
| $$0$i$i$i214 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEEC2EjjS9_($__v$i$i211, $$0$i$i$i214, $1995, $1990), asyncState ? abort(-12) | 0 : 0; | |
| $2007 = $__v$i$i211 + 8 | 0; | |
| $2008 = (tempInt = SAFE_HEAP_LOAD($2007 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2009 = ($2008 | 0) == (0 | 0); | |
| if (!$2009) { | |
| $2010 = $2008 + 4 | 0; | |
| $2011 = $44 + 12 | 0; | |
| $2012 = (tempInt = SAFE_HEAP_LOAD($2011 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2013 = $2008 + 8 | 0; | |
| $2014 = $2008 + 12 | 0; | |
| SAFE_HEAP_STORE($2014 | 0, $2012 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2015 = (tempInt = SAFE_HEAP_LOAD($44 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($2008 | 0, $2015 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2016 = $44 + 4 | 0; | |
| $2017 = (tempInt = SAFE_HEAP_LOAD($2016 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($2010 | 0, $2017 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2018 = $44 + 8 | 0; | |
| $2019 = (tempInt = SAFE_HEAP_LOAD($2018 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| SAFE_HEAP_STORE($2013 | 0, $2019 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($2018 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($2016 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($44 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $2020 = $2008 + 16 | 0; | |
| SAFE_HEAP_STORE($2007 | 0, $2020 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorINS0_IN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEEENS4_IS6_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS6_RS7_EE($1858, $__v$i$i211), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferINS_6vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS3_11short_allocIS4_Lj4096EEEEERNS5_IS7_Lj4096EEEED2Ev($__v$i$i211), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| __ZNSt3__113__vector_baseIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEED2Ev($44), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($args), asyncState ? abort(-12) | 0 : 0; | |
| $$0 = $1945; | |
| break L1; | |
| } | |
| } | |
| } while (0); | |
| if ((label | 0) == 711) { | |
| $2021 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2022 = tempRet0; | |
| $$02 = $2021; | |
| $$03 = $2022; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($args), asyncState ? abort(-12) | 0 : 0; | |
| $$10 = $$02; | |
| $$1013 = $$03; | |
| break L88; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i195), asyncState ? abort(-12) | 0 : 0; | |
| ___resumeException($eh$lpad$body$i$i202$indexZ2D | 0), asyncState ? abort(-12) | 0 : 0; | |
| break; | |
| } | |
| case 85: | |
| { | |
| $2025 = $first + 1 | 0; | |
| $2026 = ($2025 | 0) == ($last | 0); | |
| if ($2026) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $2027 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_117parse_source_nameINS0_2DbEEEPKcS4_S4_RT_($2025, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2028 = ($2027 | 0) == ($2025 | 0); | |
| if ($2028) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $2029 = (tempInt = __ZN10__cxxabiv112_GLOBAL__N_110parse_typeINS0_2DbEEEPKcS4_S4_RT_($2027, $last, $db) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2030 = ($2029 | 0) == ($2027 | 0); | |
| if ($2030) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $2031 = $db + 4 | 0; | |
| $2032 = (tempInt = SAFE_HEAP_LOAD($2031 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2033 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2034 = $2032; | |
| $2035 = $2033; | |
| $2036 = $2034 - $2035 | 0; | |
| $2037 = ($2036 | 0) / 24 & -1; | |
| $2038 = $2037 >>> 0 < 2; | |
| if ($2038) { | |
| $$0 = $first; | |
| break L1; | |
| } | |
| $2039 = $2032 + -24 | 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pair9move_fullEv($type, $2039), asyncState ? abort(-12) | 0 : 0; | |
| $2040 = (tempInt = SAFE_HEAP_LOAD($2031 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2041 = $2040 + -24 | 0; | |
| $2043 = $2040; | |
| while (1) { | |
| $2042 = ($2043 | 0) == ($2041 | 0); | |
| if ($2042) { | |
| break; | |
| } | |
| $2044 = $2043 + -24 | 0; | |
| SAFE_HEAP_STORE($2031 | 0, $2044 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($2044), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i227 = (tempInt = SAFE_HEAP_LOAD($2031 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2043 = $$pre$i227; | |
| } | |
| $2045 = $2040 + -48 | 0; | |
| $2046 = (tempInt = SAFE_HEAP_LOAD($2045 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2047 = $2046 & 1; | |
| $2048 = $2047 << 24 >> 24 == 0; | |
| if ($2048) { | |
| $2053 = $2046 & 255; | |
| $2054 = $2053 >>> 1; | |
| $2055 = $2045 + 1 | 0; | |
| $2057 = $2054; | |
| $2059 = $2055; | |
| } else { | |
| $2049 = $2040 + -44 | 0; | |
| $2050 = (tempInt = SAFE_HEAP_LOAD($2049 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2051 = $2040 + -40 | 0; | |
| $2052 = (tempInt = SAFE_HEAP_LOAD($2051 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2057 = $2050; | |
| $2059 = $2052; | |
| } | |
| $2056 = $2057 >>> 0 < 9; | |
| $2058 = $2056 ? $2057 : 9; | |
| __THREW__ = 0; | |
| invoke_viii(13, $46 | 0, $2059 | 0, $2058 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $2060 = __THREW__; | |
| __THREW__ = 0; | |
| $2061 = $2060 & 1; | |
| L975 : do { | |
| if ($2061) { | |
| label = 741; | |
| } else { | |
| $2062 = (tempInt = SAFE_HEAP_LOAD($46 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2063 = $2062 & 1; | |
| $2064 = $2063 << 24 >> 24 == 0; | |
| if ($2064) { | |
| $2069 = $2062 & 255; | |
| $2070 = $2069 >>> 1; | |
| $2071 = $46 + 1 | 0; | |
| $2073 = $2070; | |
| $2075 = $2071; | |
| } else { | |
| $2065 = $46 + 4 | 0; | |
| $2066 = (tempInt = SAFE_HEAP_LOAD($2065 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2067 = $46 + 8 | 0; | |
| $2068 = (tempInt = SAFE_HEAP_LOAD($2067 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2073 = $2066; | |
| $2075 = $2068; | |
| } | |
| $2072 = $2073 >>> 0 > 9; | |
| $2074 = $2072 ? 9 : $2073; | |
| $2076 = (tempInt = _memcmp($2075, 2824, $2074) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2077 = ($2076 | 0) == 0; | |
| if ($2077) { | |
| $2078 = $2073 >>> 0 < 9; | |
| $$$i$i$i$i234 = $2072 & 1; | |
| $$$$i$i$i$i234 = $2078 ? -1 : $$$i$i$i$i234; | |
| $2080 = $$$$i$i$i$i234; | |
| } else { | |
| $2080 = $2076; | |
| } | |
| $2079 = ($2080 | 0) == 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($46), asyncState ? abort(-12) | 0 : 0; | |
| $2081 = (tempInt = SAFE_HEAP_LOAD($2031 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2082 = $2081 + -24 | 0; | |
| L984 : do { | |
| if ($2079) { | |
| __THREW__ = 0; | |
| invoke_vii(8, $proto | 0, $2082 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $2112 = __THREW__; | |
| __THREW__ = 0; | |
| $2113 = $2112 & 1; | |
| if ($2113) { | |
| label = 741; | |
| break L975; | |
| } | |
| $2114 = (tempInt = SAFE_HEAP_LOAD($2031 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2115 = $2114 + -24 | 0; | |
| $2117 = $2114; | |
| while (1) { | |
| $2116 = ($2117 | 0) == ($2115 | 0); | |
| if ($2116) { | |
| break; | |
| } | |
| $2118 = $2117 + -24 | 0; | |
| SAFE_HEAP_STORE($2031 | 0, $2118 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($2118), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i239 = (tempInt = SAFE_HEAP_LOAD($2031 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2117 = $$pre$i239; | |
| } | |
| $2119 = (tempInt = SAFE_HEAP_LOAD($proto >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2120 = $2119 & 1; | |
| $2121 = $2120 << 24 >> 24 == 0; | |
| if ($2121) { | |
| $2126 = $proto + 1 | 0; | |
| $2127 = $proto + 1 | 0; | |
| $2128 = $2119 & 255; | |
| $2129 = $2128 >>> 1; | |
| $$pn = $2126; | |
| $2132 = $2127; | |
| $2133 = $2129; | |
| } else { | |
| $2122 = $proto + 8 | 0; | |
| $2123 = (tempInt = SAFE_HEAP_LOAD($2122 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2124 = $proto + 4 | 0; | |
| $2125 = (tempInt = SAFE_HEAP_LOAD($2124 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $$pn = $2123; | |
| $2132 = $2123; | |
| $2133 = $2125; | |
| } | |
| $2130 = $$pn + 9 | 0; | |
| $2131 = $2132 + $2133 | 0; | |
| __THREW__ = 0; | |
| $2134 = (tempInt = invoke_iiii(17, $2130 | 0, $2131 | 0, $db | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2135 = __THREW__; | |
| __THREW__ = 0; | |
| $2136 = $2135 & 1; | |
| L1012 : do { | |
| if ($2136) { | |
| label = 771; | |
| } else { | |
| $2137 = (tempInt = SAFE_HEAP_LOAD($proto >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2138 = $2137 & 1; | |
| $2139 = $2138 << 24 >> 24 == 0; | |
| if ($2139) { | |
| $2142 = $proto + 1 | 0; | |
| $2144 = $2142; | |
| } else { | |
| $2140 = $proto + 8 | 0; | |
| $2141 = (tempInt = SAFE_HEAP_LOAD($2140 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2144 = $2141; | |
| } | |
| $2143 = $2144 + 9 | 0; | |
| $2145 = ($2134 | 0) == ($2143 | 0); | |
| L1018 : do { | |
| if ($2145) { | |
| __THREW__ = 0; | |
| invoke_viii(16, $58 | 0, $type | 0, 2840 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $2184 = __THREW__; | |
| __THREW__ = 0; | |
| $2185 = $2184 & 1; | |
| if ($2185) { | |
| label = 771; | |
| break L1012; | |
| } | |
| $2186 = (tempInt = SAFE_HEAP_LOAD($proto >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2187 = $2186 & 1; | |
| $2188 = $2187 << 24 >> 24 == 0; | |
| if ($2188) { | |
| $2193 = $proto + 1 | 0; | |
| $2194 = $2186 & 255; | |
| $2195 = $2194 >>> 1; | |
| $2196 = $2193; | |
| $2197 = $2195; | |
| } else { | |
| $2189 = $proto + 8 | 0; | |
| $2190 = (tempInt = SAFE_HEAP_LOAD($2189 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2191 = $proto + 4 | 0; | |
| $2192 = (tempInt = SAFE_HEAP_LOAD($2191 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2196 = $2190; | |
| $2197 = $2192; | |
| } | |
| __THREW__ = 0; | |
| $2198 = (tempInt = invoke_iiii(3, $58 | 0, $2196 | 0, $2197 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2199 = __THREW__; | |
| __THREW__ = 0; | |
| $2200 = $2199 & 1; | |
| do { | |
| if ($2200) { | |
| $2231 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2232 = tempRet0; | |
| $$6 = $2231; | |
| $$69 = $2232; | |
| } else { | |
| SAFE_HEAP_STORE($57 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2198 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($57 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2198 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($57 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2198 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i253 = 0; | |
| while (1) { | |
| $exitcond$i$i$i254 = ($__i$0$i$i$i253 | 0) == 3; | |
| if ($exitcond$i$i$i254) { | |
| break; | |
| } | |
| $2201 = $2198 + ($__i$0$i$i$i253 << 2) | 0; | |
| SAFE_HEAP_STORE($2201 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2202 = $__i$0$i$i$i253 + 1 | 0; | |
| $__i$0$i$i$i253 = $2202; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($56, $57), asyncState ? abort(-12) | 0 : 0; | |
| $2203 = (tempInt = SAFE_HEAP_LOAD($2031 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2204 = $db + 8 | 0; | |
| $2205 = (tempInt = SAFE_HEAP_LOAD($2204 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2206 = $2203 >>> 0 < $2205 >>> 0; | |
| if ($2206) { | |
| $2207 = ($2203 | 0) == (0 | 0); | |
| if ($2207) { | |
| $2209 = 0; | |
| } else { | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2EOS1_($2203, $56), asyncState ? abort(-12) | 0 : 0; | |
| $$pre$i257 = (tempInt = SAFE_HEAP_LOAD($2031 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2209 = $$pre$i257; | |
| } | |
| $2208 = $2209 + 24 | 0; | |
| SAFE_HEAP_STORE($2031 | 0, $2208 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| } else { | |
| $2210 = $db + 12 | 0; | |
| $2211 = (tempInt = SAFE_HEAP_LOAD($db | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2212 = $2203; | |
| $2213 = $2211; | |
| $2214 = $2212 - $2213 | 0; | |
| $2215 = ($2214 | 0) / 24 & -1; | |
| $2216 = $2215 + 1 | 0; | |
| $2217 = ($2216 | 0) < 0; | |
| if ($2217) { | |
| __THREW__ = 0; | |
| invoke_vi(14, $db | 0), asyncState ? abort(-12) | 0 : 0; | |
| $2218 = __THREW__; | |
| __THREW__ = 0; | |
| $2219 = $2218 & 1; | |
| if ($2219) { | |
| $2233 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2234 = tempRet0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($56), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($57), asyncState ? abort(-12) | 0 : 0; | |
| $$6 = $2233; | |
| $$69 = $2234; | |
| break; | |
| } else {} | |
| } | |
| $2220 = $2205; | |
| $2221 = $2220 - $2213 | 0; | |
| $2222 = ($2221 | 0) / 24 & -1; | |
| $2223 = $2222 >>> 0 < 1073741823; | |
| if ($2223) { | |
| $2224 = $2222 << 1; | |
| $2225 = $2224 >>> 0 < $2216 >>> 0; | |
| $2226 = $2225 ? $2216 : $2224; | |
| $$0$i$i$i258 = $2226; | |
| } else { | |
| $$0$i$i$i258 = 2147483647; | |
| } | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEEC2EjjS6_($__v$i$i256, $$0$i$i$i258, $2215, $2210), asyncState ? abort(-12) | 0 : 0; | |
| $2227 = $__v$i$i256 + 8 | 0; | |
| $2228 = (tempInt = SAFE_HEAP_LOAD($2227 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2229 = ($2228 | 0) == (0 | 0); | |
| if (!$2229) { | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2EOS1_($2228, $56), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| $2230 = $2228 + 24 | 0; | |
| SAFE_HEAP_STORE($2227 | 0, $2230 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__16vectorIN10__cxxabiv112_GLOBAL__N_111string_pairENS2_11short_allocIS3_Lj4096EEEE26__swap_out_circular_bufferERNS_14__split_bufferIS3_RS5_EE($db, $__v$i$i256), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__114__split_bufferIN10__cxxabiv112_GLOBAL__N_111string_pairERNS2_11short_allocIS3_Lj4096EEEED2Ev($__v$i$i256), asyncState ? abort(-12) | 0 : 0; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($56), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($57), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($58), asyncState ? abort(-12) | 0 : 0; | |
| break L1018; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($58), asyncState ? abort(-12) | 0 : 0; | |
| $$7 = $$6; | |
| $$710 = $$69; | |
| break L1012; | |
| } else { | |
| $2146 = (tempInt = SAFE_HEAP_LOAD($2031 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2147 = $2146 + -24 | 0; | |
| __THREW__ = 0; | |
| invoke_viii(16, $54 | 0, $type | 0, 2848 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $2148 = __THREW__; | |
| __THREW__ = 0; | |
| $2149 = $2148 & 1; | |
| if ($2149) { | |
| label = 771; | |
| break L1012; | |
| } | |
| $2150 = (tempInt = SAFE_HEAP_LOAD($2031 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2151 = $2150 + -24 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $55 | 0, $2151 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $2152 = __THREW__; | |
| __THREW__ = 0; | |
| $2153 = $2152 & 1; | |
| if ($2153) { | |
| $2178 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2179 = tempRet0; | |
| $$5 = $2178; | |
| $$58 = $2179; | |
| } else { | |
| $2154 = (tempInt = SAFE_HEAP_LOAD($55 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2155 = $2154 & 1; | |
| $2156 = $2155 << 24 >> 24 == 0; | |
| if ($2156) { | |
| $2161 = $55 + 1 | 0; | |
| $2162 = $2154 & 255; | |
| $2163 = $2162 >>> 1; | |
| $2164 = $2161; | |
| $2165 = $2163; | |
| } else { | |
| $2157 = $55 + 8 | 0; | |
| $2158 = (tempInt = SAFE_HEAP_LOAD($2157 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2159 = $55 + 4 | 0; | |
| $2160 = (tempInt = SAFE_HEAP_LOAD($2159 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2164 = $2158; | |
| $2165 = $2160; | |
| } | |
| __THREW__ = 0; | |
| $2166 = (tempInt = invoke_iiii(3, $54 | 0, $2164 | 0, $2165 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2167 = __THREW__; | |
| __THREW__ = 0; | |
| $2168 = $2167 & 1; | |
| do { | |
| if ($2168) { | |
| $2180 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2181 = tempRet0; | |
| $$4 = $2180; | |
| $$47 = $2181; | |
| } else { | |
| SAFE_HEAP_STORE($53 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2166 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($53 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2166 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($53 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2166 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i245 = 0; | |
| while (1) { | |
| $exitcond$i$i$i246 = ($__i$0$i$i$i245 | 0) == 3; | |
| if ($exitcond$i$i$i246) { | |
| break; | |
| } | |
| $2169 = $2166 + ($__i$0$i$i$i245 << 2) | 0; | |
| SAFE_HEAP_STORE($2169 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2170 = $__i$0$i$i$i245 + 1 | 0; | |
| $__i$0$i$i$i245 = $2170; | |
| } | |
| __THREW__ = 0; | |
| $2171 = (tempInt = invoke_iii(5, $53 | 0, 2856 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2172 = __THREW__; | |
| __THREW__ = 0; | |
| $2173 = $2172 & 1; | |
| if ($2173) { | |
| $2182 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2183 = tempRet0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($53), asyncState ? abort(-12) | 0 : 0; | |
| $$4 = $2182; | |
| $$47 = $2183; | |
| break; | |
| } | |
| SAFE_HEAP_STORE($52 + 0 | 0, (tempInt = SAFE_HEAP_LOAD($2171 + 0 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($52 + 4 | 0, (tempInt = SAFE_HEAP_LOAD($2171 + 4 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| SAFE_HEAP_STORE($52 + 8 | 0, (tempInt = SAFE_HEAP_LOAD($2171 + 8 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $__i$0$i$i$i249 = 0; | |
| while (1) { | |
| $exitcond$i$i$i250 = ($__i$0$i$i$i249 | 0) == 3; | |
| if ($exitcond$i$i$i250) { | |
| break; | |
| } | |
| $2174 = $2171 + ($__i$0$i$i$i249 << 2) | 0; | |
| SAFE_HEAP_STORE($2174 | 0, 0 | 0, 4, 0), asyncState ? abort(-12) | 0 : 0; | |
| $2175 = $__i$0$i$i$i249 + 1 | 0; | |
| $__i$0$i$i$i249 = $2175; | |
| } | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairC2ENSt3__112basic_stringIcNS2_11char_traitsIcEENS0_12malloc_allocIcEEEE($51, $52), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairaSEOS1_($2147, $51), asyncState ? abort(-12) | 0 : 0; | |
| __ZN10__cxxabiv112_GLOBAL__N_111string_pairD2Ev($51), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($52), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($53), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($55), asyncState ? abort(-12) | 0 : 0; | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($54), asyncState ? abort(-12) | 0 : 0; | |
| break L1018; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($55), asyncState ? abort(-12) | 0 : 0; | |
| $$5 = $$4; | |
| $$58 = $$47; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($54), asyncState ? abort(-12) | 0 : 0; | |
| $$7 = $$5; | |
| $$710 = $$58; | |
| break L1012; | |
| } | |
| } while (0); | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($proto), asyncState ? abort(-12) | 0 : 0; | |
| break L984; | |
| } | |
| } while (0); | |
| if ((label | 0) == 771) { | |
| $2176 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2177 = tempRet0; | |
| $$7 = $2176; | |
| $$710 = $2177; | |
| } | |
| __ZNSt3__112basic_stringIcNS_11char_traitsIcEEN10__cxxabiv112_GLOBAL__N_112malloc_allocIcEEED2Ev($proto), asyncState ? abort(-12) | 0 : 0; | |
| $$8 = $$7; | |
| $$811 = $$710; | |
| break L975; | |
| } else { | |
| __THREW__ = 0; | |
| invoke_viii(16, $49 | 0, $type | 0, 2840 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $2083 = __THREW__; | |
| __THREW__ = 0; | |
| $2084 = $2083 & 1; | |
| if ($2084) { | |
| label = 741; | |
| break L975; | |
| } | |
| $2085 = (tempInt = SAFE_HEAP_LOAD($2031 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2086 = $2085 + -24 | 0; | |
| __THREW__ = 0; | |
| invoke_vii(8, $50 | 0, $2086 | 0), asyncState ? abort(-12) | 0 : 0; | |
| $2087 = __THREW__; | |
| __THREW__ = 0; | |
| $2088 = $2087 & 1; | |
| do { | |
| if ($2088) { | |
| $2108 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2109 = tempRet0; | |
| $$2 = $2108; | |
| $$25 = $2109; | |
| } else { | |
| $2089 = (tempInt = SAFE_HEAP_LOAD($50 >> 0 | 0, 1, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2090 = $2089 & 1; | |
| $2091 = $2090 << 24 >> 24 == 0; | |
| if ($2091) { | |
| $2096 = $50 + 1 | 0; | |
| $2097 = $2089 & 255; | |
| $2098 = $2097 >>> 1; | |
| $2099 = $2096; | |
| $2100 = $2098; | |
| } else { | |
| $2092 = $50 + 8 | 0; | |
| $2093 = (tempInt = SAFE_HEAP_LOAD($2092 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2094 = $50 + 4 | 0; | |
| $2095 = (tempInt = SAFE_HEAP_LOAD($2094 | 0, 4, 0, 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0 | 0; | |
| $2099 = $2093; | |
| $2100 = $2095; | |
| } | |
| __THREW__ = 0; | |
| $2101 = (tempInt = invoke_iiii(3, $49 | 0, $2099 | 0, $2100 | 0) | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2102 = __THREW__; | |
| __THREW__ = 0; | |
| $2103 = $2102 & 1; | |
| if ($2103) { | |
| $2110 = (tempInt = ___cxa_find_matching_catch() | 0, asyncState ? abort(-12) | 0 : tempInt) | 0; | |
| $2111 = tempRet0; | |
| __ZNSt3_ |
View raw
(Sorry about that, but we can’t show files that are this big right now.)
View raw
(Sorry about that, but we can’t show files that are this big right now.)
View raw
(Sorry about that, but we can’t show files that are this big right now.)
View raw
(Sorry about that, but we can’t show files that are this big right now.)
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment