js/riscvemu.js

// 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));
  };

  Module['thisProgram'] = process['argv'][1].replace(/\\/g, '/');
  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;
  }

  this['Module'] = Module;

}
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_WEB) {
    window['Module'] = Module;
  } else {
    Module['load'] = importScripts;
  }
}
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,
  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) {
      if (!args.splice) args = Array.prototype.slice.call(args);
      args.splice(0, 0, ptr);
      return Module['dynCall_' + sig].apply(null, args);
    } else {
      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;
  },
  getAsmConst: function (code, numArgs) {
    // code is a constant string on the heap, so we can cache these
    if (!Runtime.asmConstCache) Runtime.asmConstCache = {};
    var func = Runtime.asmConstCache[code];
    if (func) return func;
    var args = [];
    for (var i = 0; i < numArgs; i++) {
      args.push(String.fromCharCode(36) + i); // $0, $1 etc
    }
    var source = Pointer_stringify(code);
    if (source[0] === '"') {
      // tolerate EM_ASM("..code..") even though EM_ASM(..code..) is correct
      if (source.indexOf('"', 1) === source.length-1) {
        source = source.substr(1, source.length-2);
      } else {
        // something invalid happened, e.g. EM_ASM("..code($0)..", input)
        abort('invalid EM_ASM input |' + source + '|. Please use EM_ASM(..code..) (no quotes) or EM_ASM({ ..code($0).. }, input) (to input values)');
      }
    }
    try {
      // Module is the only 'upvar', which we provide directly. We also provide FS for legacy support.
      var evalled = eval('(function(Module, FS) { return function(' + args.join(',') + '){ ' + source + ' } })')(Module, typeof FS !== 'undefined' ? FS : null);
    } catch(e) {
      Module.printErr('error in executing inline EM_ASM code: ' + e + ' on: \n\n' + source + '\n\nwith args |' + args + '| (make sure to use the right one out of EM_ASM, EM_ASM_ARGS, etc.)');
      throw e;
    }
    return Runtime.asmConstCache[code] = evalled;
  },
  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];
  },
  UTF8Processor: function () {
    var buffer = [];
    var needed = 0;
    this.processCChar = function (code) {
      code = code & 0xFF;

      if (buffer.length == 0) {
        if ((code & 0x80) == 0x00) {        // 0xxxxxxx
          return String.fromCharCode(code);
        }
        buffer.push(code);
        if ((code & 0xE0) == 0xC0) {        // 110xxxxx
          needed = 1;
        } else if ((code & 0xF0) == 0xE0) { // 1110xxxx
          needed = 2;
        } else {                            // 11110xxx
          needed = 3;
        }
        return '';
      }

      if (needed) {
        buffer.push(code);
        needed--;
        if (needed > 0) return '';
      }

      var c1 = buffer[0];
      var c2 = buffer[1];
      var c3 = buffer[2];
      var c4 = buffer[3];
      var ret;
      if (buffer.length == 2) {
        ret = String.fromCharCode(((c1 & 0x1F) << 6)  | (c2 & 0x3F));
      } else if (buffer.length == 3) {
        ret = String.fromCharCode(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6)  | (c3 & 0x3F));
      } else {
        // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
        var codePoint = ((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) |
                        ((c3 & 0x3F) << 6)  | (c4 & 0x3F);
        ret = String.fromCharCode(
          (((codePoint - 0x10000) / 0x400)|0) + 0xD800,
          (codePoint - 0x10000) % 0x400 + 0xDC00);
      }
      buffer.length = 0;
      return ret;
    }
    this.processJSString = function processJSString(string) {
      /* TODO: use TextEncoder when present,
        var encoder = new TextEncoder();
        encoder['encoding'] = "utf-8";
        var utf8Array = encoder['encode'](aMsg.data);
      */
      string = unescape(encodeURIComponent(string));
      var ret = [];
      for (var i = 0; i < string.length; i++) {
        ret.push(string.charCodeAt(i));
      }
      return ret;
    }
  },
  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); return ret; },
  staticAlloc: function (size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = (((STATICTOP)+15)&-16); return ret; },
  dynamicAlloc: function (size) { var ret = DYNAMICTOP;DYNAMICTOP = (DYNAMICTOP + size)|0;DYNAMICTOP = (((DYNAMICTOP)+15)&-16); if (DYNAMICTOP >= TOTAL_MEMORY) enlargeMemory();; 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: 8,
  QUANTUM_SIZE: 4,
  __dummy__: 0
}


Module['Runtime'] = Runtime;









//========================================
// 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 stack = 0;
  var JSfuncs = {
    'stackSave' : function() {
      stack = Runtime.stackSave();
    },
    'stackRestore' : function() {
      Runtime.stackRestore(stack);
    },
    // 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 = [];
    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 (returnType === 'string') ret = Pointer_stringify(ret);
    if (stack !== 0) JSfuncs['stackRestore']();
    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 += 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);';
    }
    if (!numericArgs) {
      // If we had a stack, restore it
      funcstr += JSsource['stackRestore'].body + ';';
    }
    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
    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);
    }
}
Module['setValue'] = setValue;


function getValue(ptr, type, noSafe) {
  type = type || 'i8';
  if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
    switch(type) {
      case 'i1': return HEAP8[((ptr)>>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);
    }
  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;
    }

    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) return '';
  // TODO: use TextDecoder
  // Find the length, and check for UTF while doing so
  var hasUtf = false;
  var t;
  var i = 0;
  while (1) {
    t = HEAPU8[(((ptr)+(i))>>0)];
    if (t >= 128) hasUtf = true;
    else if (t == 0 && !length) break;
    i++;
    if (length && i == length) break;
  }
  if (!length) length = i;

  var ret = '';

  if (!hasUtf) {
    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;
  }

  var utf8 = new Runtime.UTF8Processor();
  for (i = 0; i < length; i++) {
    t = HEAPU8[(((ptr)+(i))>>0)];
    ret += utf8.processCChar(t);
  }
  return ret;
}
Module['Pointer_stringify'] = Pointer_stringify;

function UTF16ToString(ptr) {
  var i = 0;

  var str = '';
  while (1) {
    var codeUnit = HEAP16[(((ptr)+(i*2))>>1)];
    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;


function stringToUTF16(str, outPtr) {
  for(var i = 0; i < str.length; ++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
    HEAP16[(((outPtr)+(i*2))>>1)]=codeUnit;
  }
  // Null-terminate the pointer to the HEAP.
  HEAP16[(((outPtr)+(str.length*2))>>1)]=0;
}
Module['stringToUTF16'] = stringToUTF16;


function UTF32ToString(ptr) {
  var i = 0;

  var str = '';
  while (1) {
    var utf32 = HEAP32[(((ptr)+(i*4))>>2)];
    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.
    if (utf32 >= 0x10000) {
      var ch = utf32 - 0x10000;
      str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));
    } else {
      str += String.fromCharCode(utf32);
    }
  }
}
Module['UTF32ToString'] = UTF32ToString;


function stringToUTF32(str, outPtr) {
  var iChar = 0;
  for(var iCodeUnit = 0; iCodeUnit < str.length; ++iCodeUnit) {
    // 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.
    var codeUnit = str.charCodeAt(iCodeUnit); // possibly a lead surrogate
    if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) {
      var trailSurrogate = str.charCodeAt(++iCodeUnit);
      codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF);
    }
    HEAP32[(((outPtr)+(iChar*4))>>2)]=codeUnit;
    ++iChar;
  }
  // Null-terminate the pointer to the HEAP.
  HEAP32[(((outPtr)+(iChar*4))>>2)]=0;
}
Module['stringToUTF32'] = stringToUTF32;

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 final = 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()';
    }
    final = parse();
  } catch(e) {
    final += '?';
  }
  if (final.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 final;
}

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) {
  return (x+4095)&-4096;
}

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() {
  abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with ALLOW_MEMORY_GROWTH which adjusts the size at runtime but prevents some optimizations, or (3) set Module.TOTAL_MEMORY before the program runs.');
}


var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880;
var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 536870912;
var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;

var totalMemory = 64*1024;
while (totalMemory < TOTAL_MEMORY || totalMemory < 2*TOTAL_STACK) {
  if (totalMemory < 16*1024*1024) {
    totalMemory *= 2;
  } else {
    totalMemory += 16*1024*1024
  }
}
if (totalMemory !== TOTAL_MEMORY) {
  Module.printErr('increasing TOTAL_MEMORY to ' + totalMemory + ' to be compliant with the asm.js spec');
  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 ret = (new Runtime.UTF8Processor()).processJSString(stringy);
  if (length) {
    ret.length = length;
  }
  if (!dontAddNull) {
    ret.push(0);
  }
  return ret;
}
Module['intArrayFromString'] = intArrayFromString;

function intArrayToString(array) {
  var ret = [];
  for (var i = 0; i < array.length; i++) {
    var chr = array[i];
    if (chr > 0xFF) {
      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];
    HEAP8[(((buffer)+(i))>>0)]=chr;
    i = i + 1;
  }
}
Module['writeStringToMemory'] = writeStringToMemory;

function writeArrayToMemory(array, buffer) {
  for (var i = 0; i < array.length; i++) {
    HEAP8[(((buffer)+(i))>>0)]=array[i];
  }
}
Module['writeArrayToMemory'] = writeArrayToMemory;

function writeAsciiToMemory(str, buffer, dontAddNull) {
  for (var i = 0; i < str.length; i++) {
    HEAP8[(((buffer)+(i))>>0)]=str.charCodeAt(i);
  }
  if (!dontAddNull) HEAP8[(((buffer)+(str.length))>>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'];


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;

// 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

function addRunDependency(id) {
  runDependencies++;
  if (Module['monitorRunDependencies']) {
    Module['monitorRunDependencies'](runDependencies);
  }
}
Module['addRunDependency'] = addRunDependency;
function removeRunDependency(id) {
  runDependencies--;
  if (Module['monitorRunDependencies']) {
    Module['monitorRunDependencies'](runDependencies);
  }
  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 ===





STATIC_BASE = 8;

STATICTOP = STATIC_BASE + 2384;
  /* global initializers */ __ATINIT__.push();
  

/* memory initializer */ allocate([115,45,62,110,95,112,104,121,115,95,109,101,109,95,114,97,110,103,101,32,60,32,80,72,89,83,95,77,69,77,95,82,65,78,71,69,95,77,65,88,0,0,0,0,0,0,0,0,114,105,115,99,118,101,109,117,46,99,0,0,0,0,0,0,99,112,117,95,114,101,103,105,115,116,101,114,95,114,97,109,0,0,0,0,0,0,0,0,99,112,117,95,114,101,103,105,115,116,101,114,95,100,101,118,105,99,101,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,123,32,118,97,114,32,116,101,114,109,95,114,120,95,102,105,102,111,32,61,32,34,34,59,32,99,111,110,115,111,108,101,95,119,114,105,116,101,49,32,61,32,99,119,114,97,112,40,39,99,111,110,115,111,108,101,95,113,117,101,117,101,95,99,104,97,114,39,44,32,110,117,108,108,44,32,91,39,110,117,109,98,101,114,39,93,41,59,32,102,117,110,99,116,105,111,110,32,116,101,114,109,95,104,97,110,100,108,101,114,40,115,116,114,41,32,123,32,118,97,114,32,105,59,32,102,111,114,40,105,32,61,32,48,59,32,105,32,60,32,115,116,114,46,108,101,110,103,116,104,59,32,105,43,43,41,32,123,32,99,111,110,115,111,108,101,95,119,114,105,116,101,49,40,115,116,114,46,99,104,97,114,67,111,100,101,65,116,40,105,41,41,59,32,125,32,125,32,116,101,114,109,32,61,32,110,101,119,32,84,101,114,109,40,56,48,44,32,51,48,44,32,116,101,114,109,95,104,97,110,100,108,101,114,41,59,32,116,101,114,109,46,111,112,101,110,40,41,59,32,125,0,0,0,0,0,114,111,111,116,45,114,105,115,99,118,54,52,47,98,108,107,37,48,57,117,46,98,105,110,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,98,98,108,54,52,46,98,105,110,0,0,0,0,0,0,0,112,108,97,116,102,111,114,109,32,123,10,32,32,118,101,110,100,111,114,32,117,99,98,59,10,32,32,97,114,99,104,32,115,112,105,107,101,59,10,125,59,10,114,116,99,32,123,10,32,32,97,100,100,114,32,48,120,37,108,108,120,59,10,125,59,10,114,97,109,32,123,10,32,32,48,32,123,10,32,32,32,32,97,100,100,114,32,48,120,37,108,108,120,59,10,32,32,32,32,115,105,122,101,32,48,120,37,108,108,120,59,10,32,32,125,59,10,125,59,10,99,111,114,101,32,123,10,32,32,48,32,123,10,32,32,32,32,48,32,123,10,32,32,32,32,32,32,105,115,97,32,114,118,54,52,105,109,97,102,100,59,10,32,32,32,32,32,32,116,105,109,101,99,109,112,32,48,120,37,108,108,120,59,10,32,32,32,32,32,32,105,112,105,32,48,120,52,48,48,48,49,48,48,48,59,10,32,32,32,32,125,59,10,32,32,125,59,10,125,59,10,0,0,0,115,105,122,101,32,61,61,32,98,102,45,62,98,108,111,99,107,95,115,105,122,101,32,42,32,53,49,50,0,0,0,0,98,102,95,114,101,97,100,95,111,110,108,111,97,100,0,0,0,0,0,0,0,0,0,0,123,32,116,101,114,109,46,119,114,105,116,101,40,83,116,114,105,110,103,46,102,114,111,109,67,104,97,114,67,111,100,101,40,36,48,41,41,59,32,125,0,0,0,0,0,0,0,0,115,105,122,101,95,108,111,103,50,32,61,61,32,50,0,0,104,116,105,102,95,119,114,105,116,101,0,0,0,0,0,0,72,84,73,70,58,32,117,110,115,117,112,112,111,114,116,101,100,32,116,111,104,111,115,116,61,48,120,37,48,49,54,108,108,120,10,0,0,0,0,0,104,116,105,102,95,114,101,97,100,0,0,0,0,0,0,0,112,108,105,99,95,119,114,105,116,101,0,0,0,0,0,0,112,108,105,99,95,114,101,97,100,0,0,0,0,0,0,0,114,116,99,95,119,114,105,116,101,0,0,0,0,0,0,0,114,116,99,95,114,101,97,100,0,0,0,0,0,0,0,0,105,109,97,103,101,32,116,111,111,32,98,105,103,0,0,0,101,114,114,111,114,32,119,104,105,108,101,32,108,111,97,100,105,110,103,32,105,109,97,103,101,0,0,0,0,0,0,0,10,80,111,119,101,114,32,111,102,102,46,0,0,0,0,0,97,49,32,60,32,98,0,0,46,47,115,111,102,116,102,112,95,116,101,109,112,108,97,116,101,46,104,0,0,0,0,0,100,105,118,114,101,109,95,117,54,52,0,0,0,0,0,0,115,104,105,102,116,32,62,61,32,48,0,0,0,0,0,0,110,111,114,109,97,108,105,122,101,50,95,115,102,54,52,0,110,111,114,109,97,108,105,122,101,95,115,102,54,52,0,0,110,111,114,109,97,108,105,122,101,50,95,115,102,51,50,0,110,111,114,109,97,108,105,122,101,95,115,102,51,50,0,0,82,73,83,67,86,69,77,85,32,72,65,82,68,68,73,83,75,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17,0,10,0,17,17,17,0,0,0,0,5,0,0,0,0,0,0,9,0,0,0,0,11,0,0,0,0,0,0,0,0,17,0,15,10,17,17,17,3,10,7,0,1,19,9,11,11,0,0,9,6,11,0,0,11,0,6,17,0,0,0,17,17,17,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,17,0,10,10,17,17,17,0,10,0,0,2,0,9,11,0,0,0,9,0,11,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,12,0,0,0,0,9,12,0,0,0,0,0,12,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,13,0,0,0,4,13,0,0,0,0,9,14,0,0,0,0,0,14,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,15,0,0,0,0,15,0,0,0,0,9,16,0,0,0,0,0,16,0,0,16,0,0,18,0,0,0,18,18,18,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,0,0,0,18,18,18,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,10,0,0,0,0,9,11,0,0,0,0,0,11,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,12,0,0,0,0,9,12,0,0,0,0,0,12,0,0,12,0,0,45,43,32,32,32,48,88,48,120,0,0,0,0,0,0,0,40,110,117,108,108,41,0,0,45,48,88,43,48,88,32,48,88,45,48,120,43,48,120,32,48,120,0,0,0,0,0,0,105,110,102,0,0,0,0,0,73,78,70,0,0,0,0,0,110,97,110,0,0,0,0,0,78,65,78,0,0,0,0,0,48,49,50,51,52,53,54,55,56,57,65,66,67,68,69,70,46,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_NONE, Runtime.GLOBAL_BASE);




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];

}


  
  function _emscripten_get_now() {
      if (!_emscripten_get_now.actual) {
        if (ENVIRONMENT_IS_NODE) {
          _emscripten_get_now.actual = function _emscripten_get_now_actual() {
            var t = process['hrtime']();
            return t[0] * 1e3 + t[1] / 1e6;
          }
        } else if (typeof dateNow !== 'undefined') {
          _emscripten_get_now.actual = dateNow;
        } else if (ENVIRONMENT_IS_WEB && window['performance'] && window['performance']['now']) {
          _emscripten_get_now.actual = function _emscripten_get_now_actual() { return window['performance']['now'](); };
        } else {
          _emscripten_get_now.actual = Date.now;
        }
      }
      return _emscripten_get_now.actual();
    }
  
  function _emscripten_get_now_is_monotonic() {
      // return whether emscripten_get_now is guaranteed monotonic; the Date.now
      // implementation is not :(
      return ENVIRONMENT_IS_NODE || (typeof dateNow !== 'undefined') ||
          (ENVIRONMENT_IS_WEB && window['performance'] && window['performance']['now']);
    }
  
  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};
  
  
  var ___errno_state=0;function ___setErrNo(value) {
      // For convenient setting and returning of errno.
      HEAP32[((___errno_state)>>2)]=value;
      return value;
    }function _clock_gettime(clk_id, tp) {
      // int clock_gettime(clockid_t clk_id, struct timespec *tp);
      var now;
      if (clk_id === 0) {
        now = Date.now();
      } else if (clk_id === 1 && _emscripten_get_now_is_monotonic()) {
        now = _emscripten_get_now();
      } else {
        ___setErrNo(ERRNO_CODES.EINVAL);
        return -1;
      }
      HEAP32[((tp)>>2)]=(now/1000)|0; // seconds
      HEAP32[(((tp)+(4))>>2)]=((now % 1000)*1000*1000)|0; // nanoseconds
      return 0;
    }

  var _BDtoIHigh=true;

   
  Module["_i64Subtract"] = _i64Subtract;

  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();
    }

   
  Module["_bitshift64Ashr"] = _bitshift64Ashr;

   
  Module["_memset"] = _memset;

  var _BDtoILow=true;

   
  Module["_bitshift64Lshr"] = _bitshift64Lshr;

  
  
  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"};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["_bitshift64Shl"] = _bitshift64Shl;

  function _abort() {
      Module['abort']();
    }

  function _emscripten_async_wget_data(url, arg, onload, onerror) {
      Browser.asyncLoad(Pointer_stringify(url), function(byteArray) {
        var buffer = _malloc(byteArray.length);
        HEAPU8.set(byteArray, buffer);
        Runtime.dynCall('viii', onload, [arg, buffer, byteArray.length]);
        _free(buffer);
      }, function() {
        if (onerror) Runtime.dynCall('vi', onerror, [arg]);
      }, true /* no need for run dependency, this is async but will not do any prepare etc. step */ );
    }

   
  Module["_i64Add"] = _i64Add;

  
  
  
  
  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('/');
      }};
  
  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
          if (stream.tty.output.length) {
            stream.tty.ops.put_char(stream.tty, 10);
          }
        },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) {
              result = process['stdin']['read']();
              if (!result) {
                if (process['stdin']['_readableState'] && process['stdin']['_readableState']['ended']) {
                  return null;  // EOF
                }
                return undefined;  // no data available
              }
            } 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'](tty.output.join(''));
            tty.output = [];
          } else {
            tty.output.push(TTY.utf8.processCChar(val));
          }
        }},default_tty1_ops:{put_char:function (tty, val) {
          if (val === null || val === 10) {
            Module['printErr'](tty.output.join(''));
            tty.output = [];
          } else {
            tty.output.push(TTY.utf8.processCChar(val));
          }
        }}};
  
  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
              }
            },
            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?
              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);
          }
          stream.ungotten = [];
          stream.position = position;
          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 };
        }}};
  
  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);
          }
  
          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() {
          callback(this.error);
        };
      },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() { callback(this.error); };
  
          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() { callback(this.error); };
      },storeRemoteEntry:function (store, path, entry, callback) {
        var req = store.put(entry, path);
        req.onsuccess = function() { callback(null); };
        req.onerror = function() { callback(this.error); };
      },removeRemoteEntry:function (store, path, callback) {
        var req = store.delete(path);
        req.onsuccess = function() { callback(null); };
        req.onerror = function() { callback(this.error); };
      },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() { done(this.error); };
  
        // 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 {
            return fs.readlinkSync(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) {
          // 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);
          }
  
          stream.position = position;
          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
      // we don't currently perform any user-space buffering of data
    }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 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);
        }
        return stream.stream_ops.llseek(stream, offset, whence);
      },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);
      },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 = '';
          var utf8 = new Runtime.UTF8Processor();
          for (var i = 0; i < length; i++) {
            ret += utf8.processCChar(buf[i]);
          }
        } 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 utf8 = new Runtime.UTF8Processor();
          var buf = new Uint8Array(utf8.processJSString(data));
          FS.write(stream, buf, 0, buf.length, 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');
        HEAP32[((_stdin)>>2)]=FS.getPtrForStream(stdin);
        assert(stdin.fd === 0, 'invalid handle for stdin (' + stdin.fd + ')');
  
        var stdout = FS.open('/dev/stdout', 'w');
        HEAP32[((_stdout)>>2)]=FS.getPtrForStream(stdout);
        assert(stdout.fd === 1, 'invalid handle for stdout (' + stdout.fd + ')');
  
        var stderr = FS.open('/dev/stderr', 'w');
        HEAP32[((_stderr)>>2)]=FS.getPtrForStream(stderr);
        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];
        };
        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;
      }};
  
  
  
  
  function _mkport() { throw 'TODO' }var SOCKFS={mount:function (mount) {
        // If Module['websocket'] has already been defined (e.g. for configuring
        // the subprotocol/url) use that, if not initialise it to a new object.
        Module['websocket'] = (Module['websocket'] && 
                               ('object' === typeof Module['websocket'])) ? Module['websocket'] : {};
  
        // Add the Event registration mechanism to the exported websocket configuration
        // object so we can register network callbacks from native JavaScript too.
        // For more documentation see system/include/emscripten/emscripten.h
        Module['websocket']._callbacks = {};
        Module['websocket']['on'] = function(event, callback) {
  	    if ('function' === typeof callback) {
  		  this._callbacks[event] = callback;
          }
  	    return this;
        };
  
        Module['websocket'].emit = function(event, param) {
  	    if ('function' === typeof this._callbacks[event]) {
  		  this._callbacks[event].call(this, param);
          }
        };
  
        // If debug is enabled register simple default logging callbacks for each Event.
  
        return FS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
      },createSocket:function (family, type, protocol) {
        var streaming = type == 1;
        if (protocol) {
          assert(streaming == (protocol == 6)); // if SOCK_STREAM, must be tcp
        }
  
        // create our internal socket structure
        var sock = {
          family: family,
          type: type,
          protocol: protocol,
          server: null,
          error: null, // Used in getsockopt for SOL_SOCKET/SO_ERROR test
          peers: {},
          pending: [],
          recv_queue: [],
          sock_ops: SOCKFS.websocket_sock_ops
        };
  
        // create the filesystem node to store the socket structure
        var name = SOCKFS.nextname();
        var node = FS.createNode(SOCKFS.root, name, 49152, 0);
        node.sock = sock;
  
        // and the wrapping stream that enables library functions such
        // as read and write to indirectly interact with the socket
        var stream = FS.createStream({
          path: name,
          node: node,
          flags: FS.modeStringToFlags('r+'),
          seekable: false,
          stream_ops: SOCKFS.stream_ops
        });
  
        // map the new stream to the socket structure (sockets have a 1:1
        // relationship with a stream)
        sock.stream = stream;
  
        return sock;
      },getSocket:function (fd) {
        var stream = FS.getStream(fd);
        if (!stream || !FS.isSocket(stream.node.mode)) {
          return null;
        }
        return stream.node.sock;
      },stream_ops:{poll:function (stream) {
          var sock = stream.node.sock;
          return sock.sock_ops.poll(sock);
        },ioctl:function (stream, request, varargs) {
          var sock = stream.node.sock;
          return sock.sock_ops.ioctl(sock, request, varargs);
        },read:function (stream, buffer, offset, length, position /* ignored */) {
          var sock = stream.node.sock;
          var msg = sock.sock_ops.recvmsg(sock, length);
          if (!msg) {
            // socket is closed
            return 0;
          }
          buffer.set(msg.buffer, offset);
          return msg.buffer.length;
        },write:function (stream, buffer, offset, length, position /* ignored */) {
          var sock = stream.node.sock;
          return sock.sock_ops.sendmsg(sock, buffer, offset, length);
        },close:function (stream) {
          var sock = stream.node.sock;
          sock.sock_ops.close(sock);
        }},nextname:function () {
        if (!SOCKFS.nextname.current) {
          SOCKFS.nextname.current = 0;
        }
        return 'socket[' + (SOCKFS.nextname.current++) + ']';
      },websocket_sock_ops:{createPeer:function (sock, addr, port) {
          var ws;
  
          if (typeof addr === 'object') {
            ws = addr;
            addr = null;
            port = null;
          }
  
          if (ws) {
            // for sockets that've already connected (e.g. we're the server)
            // we can inspect the _socket property for the address
            if (ws._socket) {
              addr = ws._socket.remoteAddress;
              port = ws._socket.remotePort;
            }
            // if we're just now initializing a connection to the remote,
            // inspect the url property
            else {
              var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws.url);
              if (!result) {
                throw new Error('WebSocket URL must be in the format ws(s)://address:port');
              }
              addr = result[1];
              port = parseInt(result[2], 10);
            }
          } else {
            // create the actual websocket object and connect
            try {
              // runtimeConfig gets set to true if WebSocket runtime configuration is available.
              var runtimeConfig = (Module['websocket'] && ('object' === typeof Module['websocket']));
  
              // The default value is 'ws://' the replace is needed because the compiler replaces '//' comments with '#'
              // comments without checking context, so we'd end up with ws:#, the replace swaps the '#' for '//' again.
              var url = 'ws:#'.replace('#', '//');
  
              if (runtimeConfig) {
                if ('string' === typeof Module['websocket']['url']) {
                  url = Module['websocket']['url']; // Fetch runtime WebSocket URL config.
                }
              }
  
              if (url === 'ws://' || url === 'wss://') { // Is the supplied URL config just a prefix, if so complete it.
                var parts = addr.split('/');
                url = url + parts[0] + ":" + port + "/" + parts.slice(1).join('/');
              }
  
              // Make the WebSocket subprotocol (Sec-WebSocket-Protocol) default to binary if no configuration is set.
              var subProtocols = 'binary'; // The default value is 'binary'
  
              if (runtimeConfig) {
                if ('string' === typeof Module['websocket']['subprotocol']) {
                  subProtocols = Module['websocket']['subprotocol']; // Fetch runtime WebSocket subprotocol config.
                }
              }
  
              // The regex trims the string (removes spaces at the beginning and end, then splits the string by
              // <any space>,<any space> into an Array. Whitespace removal is important for Websockify and ws.
              subProtocols = subProtocols.replace(/^ +| +$/g,"").split(/ *, */);
  
              // The node ws library API for specifying optional subprotocol is slightly different than the browser's.
              var opts = ENVIRONMENT_IS_NODE ? {'protocol': subProtocols.toString()} : subProtocols;
  
              // If node we use the ws library.
              var WebSocket = ENVIRONMENT_IS_NODE ? require('ws') : window['WebSocket'];
              ws = new WebSocket(url, opts);
              ws.binaryType = 'arraybuffer';
            } catch (e) {
              throw new FS.ErrnoError(ERRNO_CODES.EHOSTUNREACH);
            }
          }
  
  
          var peer = {
            addr: addr,
            port: port,
            socket: ws,
            dgram_send_queue: []
          };
  
          SOCKFS.websocket_sock_ops.addPeer(sock, peer);
          SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
  
          // if this is a bound dgram socket, send the port number first to allow
          // us to override the ephemeral port reported to us by remotePort on the
          // remote end.
          if (sock.type === 2 && typeof sock.sport !== 'undefined') {
            peer.dgram_send_queue.push(new Uint8Array([
                255, 255, 255, 255,
                'p'.charCodeAt(0), 'o'.charCodeAt(0), 'r'.charCodeAt(0), 't'.charCodeAt(0),
                ((sock.sport & 0xff00) >> 8) , (sock.sport & 0xff)
            ]));
          }
  
          return peer;
        },getPeer:function (sock, addr, port) {
          return sock.peers[addr + ':' + port];
        },addPeer:function (sock, peer) {
          sock.peers[peer.addr + ':' + peer.port] = peer;
        },removePeer:function (sock, peer) {
          delete sock.peers[peer.addr + ':' + peer.port];
        },handlePeerEvents:function (sock, peer) {
          var first = true;
  
          var handleOpen = function () {
  
            Module['websocket'].emit('open', sock.stream.fd);
  
            try {
              var queued = peer.dgram_send_queue.shift();
              while (queued) {
                peer.socket.send(queued);
                queued = peer.dgram_send_queue.shift();
              }
            } catch (e) {
              // not much we can do here in the way of proper error handling as we've already
              // lied and said this data was sent. shut it down.
              peer.socket.close();
            }
          };
  
          function handleMessage(data) {
            assert(typeof data !== 'string' && data.byteLength !== undefined);  // must receive an ArrayBuffer
            data = new Uint8Array(data);  // make a typed array view on the array buffer
  
  
            // if this is the port message, override the peer's port with it
            var wasfirst = first;
            first = false;
            if (wasfirst &&
                data.length === 10 &&
                data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 &&
                data[4] === 'p'.charCodeAt(0) && data[5] === 'o'.charCodeAt(0) && data[6] === 'r'.charCodeAt(0) && data[7] === 't'.charCodeAt(0)) {
              // update the peer's port and it's key in the peer map
              var newport = ((data[8] << 8) | data[9]);
              SOCKFS.websocket_sock_ops.removePeer(sock, peer);
              peer.port = newport;
              SOCKFS.websocket_sock_ops.addPeer(sock, peer);
              return;
            }
  
            sock.recv_queue.push({ addr: peer.addr, port: peer.port, data: data });
            Module['websocket'].emit('message', sock.stream.fd);
          };
  
          if (ENVIRONMENT_IS_NODE) {
            peer.socket.on('open', handleOpen);
            peer.socket.on('message', function(data, flags) {
              if (!flags.binary) {
                return;
              }
              handleMessage((new Uint8Array(data)).buffer);  // copy from node Buffer -> ArrayBuffer
            });
            peer.socket.on('close', function() {
              Module['websocket'].emit('close', sock.stream.fd);
            });
            peer.socket.on('error', function(error) {
              // Although the ws library may pass errors that may be more descriptive than
              // ECONNREFUSED they are not necessarily the expected error code e.g. 
              // ENOTFOUND on getaddrinfo seems to be node.js specific, so using ECONNREFUSED
              // is still probably the most useful thing to do.
              sock.error = ERRNO_CODES.ECONNREFUSED; // Used in getsockopt for SOL_SOCKET/SO_ERROR test.
              Module['websocket'].emit('error', [sock.stream.fd, sock.error, 'ECONNREFUSED: Connection refused']);
              // don't throw
            });
          } else {
            peer.socket.onopen = handleOpen;
            peer.socket.onclose = function() {
              Module['websocket'].emit('close', sock.stream.fd);
            };
            peer.socket.onmessage = function peer_socket_onmessage(event) {
              handleMessage(event.data);
            };
            peer.socket.onerror = function(error) {
              // The WebSocket spec only allows a 'simple event' to be thrown on error,
              // so we only really know as much as ECONNREFUSED.
              sock.error = ERRNO_CODES.ECONNREFUSED; // Used in getsockopt for SOL_SOCKET/SO_ERROR test.
              Module['websocket'].emit('error', [sock.stream.fd, sock.error, 'ECONNREFUSED: Connection refused']);
            };
          }
        },poll:function (sock) {
          if (sock.type === 1 && sock.server) {
            // listen sockets should only say they're available for reading
            // if there are pending clients.
            return sock.pending.length ? (64 | 1) : 0;
          }
  
          var mask = 0;
          var dest = sock.type === 1 ?  // we only care about the socket state for connection-based sockets
            SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport) :
            null;
  
          if (sock.recv_queue.length ||
              !dest ||  // connection-less sockets are always ready to read
              (dest && dest.socket.readyState === dest.socket.CLOSING) ||
              (dest && dest.socket.readyState === dest.socket.CLOSED)) {  // let recv return 0 once closed
            mask |= (64 | 1);
          }
  
          if (!dest ||  // connection-less sockets are always ready to write
              (dest && dest.socket.readyState === dest.socket.OPEN)) {
            mask |= 4;
          }
  
          if ((dest && dest.socket.readyState === dest.socket.CLOSING) ||
              (dest && dest.socket.readyState === dest.socket.CLOSED)) {
            mask |= 16;
          }
  
          return mask;
        },ioctl:function (sock, request, arg) {
          switch (request) {
            case 21531:
              var bytes = 0;
              if (sock.recv_queue.length) {
                bytes = sock.recv_queue[0].data.length;
              }
              HEAP32[((arg)>>2)]=bytes;
              return 0;
            default:
              return ERRNO_CODES.EINVAL;
          }
        },close:function (sock) {
          // if we've spawned a listen server, close it
          if (sock.server) {
            try {
              sock.server.close();
            } catch (e) {
            }
            sock.server = null;
          }
          // close any peer connections
          var peers = Object.keys(sock.peers);
          for (var i = 0; i < peers.length; i++) {
            var peer = sock.peers[peers[i]];
            try {
              peer.socket.close();
            } catch (e) {
            }
            SOCKFS.websocket_sock_ops.removePeer(sock, peer);
          }
          return 0;
        },bind:function (sock, addr, port) {
          if (typeof sock.saddr !== 'undefined' || typeof sock.sport !== 'undefined') {
            throw new FS.ErrnoError(ERRNO_CODES.EINVAL);  // already bound
          }
          sock.saddr = addr;
          sock.sport = port || _mkport();
          // in order to emulate dgram sockets, we need to launch a listen server when
          // binding on a connection-less socket
          // note: this is only required on the server side
          if (sock.type === 2) {
            // close the existing server if it exists
            if (sock.server) {
              sock.server.close();
              sock.server = null;
            }
            // swallow error operation not supported error that occurs when binding in the
            // browser where this isn't supported
            try {
              sock.sock_ops.listen(sock, 0);
            } catch (e) {
              if (!(e instanceof FS.ErrnoError)) throw e;
              if (e.errno !== ERRNO_CODES.EOPNOTSUPP) throw e;
            }
          }
        },connect:function (sock, addr, port) {
          if (sock.server) {
            throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
          }
  
          // TODO autobind
          // if (!sock.addr && sock.type == 2) {
          // }
  
          // early out if we're already connected / in the middle of connecting
          if (typeof sock.daddr !== 'undefined' && typeof sock.dport !== 'undefined') {
            var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
            if (dest) {
              if (dest.socket.readyState === dest.socket.CONNECTING) {
                throw new FS.ErrnoError(ERRNO_CODES.EALREADY);
              } else {
                throw new FS.ErrnoError(ERRNO_CODES.EISCONN);
              }
            }
          }
  
          // add the socket to our peer list and set our
          // destination address / port to match
          var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
          sock.daddr = peer.addr;
          sock.dport = peer.port;
  
          // always "fail" in non-blocking mode
          throw new FS.ErrnoError(ERRNO_CODES.EINPROGRESS);
        },listen:function (sock, backlog) {
          if (!ENVIRONMENT_IS_NODE) {
            throw new FS.ErrnoError(ERRNO_CODES.EOPNOTSUPP);
          }
          if (sock.server) {
             throw new FS.ErrnoError(ERRNO_CODES.EINVAL);  // already listening
          }
          var WebSocketServer = require('ws').Server;
          var host = sock.saddr;
          sock.server = new WebSocketServer({
            host: host,
            port: sock.sport
            // TODO support backlog
          });
          Module['websocket'].emit('listen', sock.stream.fd); // Send Event with listen fd.
  
          sock.server.on('connection', function(ws) {
            if (sock.type === 1) {
              var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
  
              // create a peer on the new socket
              var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws);
              newsock.daddr = peer.addr;
              newsock.dport = peer.port;
  
              // push to queue for accept to pick up
              sock.pending.push(newsock);
              Module['websocket'].emit('connection', newsock.stream.fd);
            } else {
              // create a peer on the listen socket so calling sendto
              // with the listen socket and an address will resolve
              // to the correct client
              SOCKFS.websocket_sock_ops.createPeer(sock, ws);
              Module['websocket'].emit('connection', sock.stream.fd);
            }
          });
          sock.server.on('closed', function() {
            Module['websocket'].emit('close', sock.stream.fd);
            sock.server = null;
          });
          sock.server.on('error', function(error) {
            // Although the ws library may pass errors that may be more descriptive than
            // ECONNREFUSED they are not necessarily the expected error code e.g. 
            // ENOTFOUND on getaddrinfo seems to be node.js specific, so using EHOSTUNREACH
            // is still probably the most useful thing to do. This error shouldn't
            // occur in a well written app as errors should get trapped in the compiled
            // app's own getaddrinfo call.
            sock.error = ERRNO_CODES.EHOSTUNREACH; // Used in getsockopt for SOL_SOCKET/SO_ERROR test.
            Module['websocket'].emit('error', [sock.stream.fd, sock.error, 'EHOSTUNREACH: Host is unreachable']);
            // don't throw
          });
        },accept:function (listensock) {
          if (!listensock.server) {
            throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
          }
          var newsock = listensock.pending.shift();
          newsock.stream.flags = listensock.stream.flags;
          return newsock;
        },getname:function (sock, peer) {
          var addr, port;
          if (peer) {
            if (sock.daddr === undefined || sock.dport === undefined) {
              throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
            }
            addr = sock.daddr;
            port = sock.dport;
          } else {
            // TODO saddr and sport will be set for bind()'d UDP sockets, but what
            // should we be returning for TCP sockets that've been connect()'d?
            addr = sock.saddr || 0;
            port = sock.sport || 0;
          }
          return { addr: addr, port: port };
        },sendmsg:function (sock, buffer, offset, length, addr, port) {
          if (sock.type === 2) {
            // connection-less sockets will honor the message address,
            // and otherwise fall back to the bound destination address
            if (addr === undefined || port === undefined) {
              addr = sock.daddr;
              port = sock.dport;
            }
            // if there was no address to fall back to, error out
            if (addr === undefined || port === undefined) {
              throw new FS.ErrnoError(ERRNO_CODES.EDESTADDRREQ);
            }
          } else {
            // connection-based sockets will only use the bound
            addr = sock.daddr;
            port = sock.dport;
          }
  
          // find the peer for the destination address
          var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr, port);
  
          // early out if not connected with a connection-based socket
          if (sock.type === 1) {
            if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
              throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
            } else if (dest.socket.readyState === dest.socket.CONNECTING) {
              throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
            }
          }
  
          // create a copy of the incoming data to send, as the WebSocket API
          // doesn't work entirely with an ArrayBufferView, it'll just send
          // the entire underlying buffer
          var data;
          if (buffer instanceof Array || buffer instanceof ArrayBuffer) {
            data = buffer.slice(offset, offset + length);
          } else {  // ArrayBufferView
            data = buffer.buffer.slice(buffer.byteOffset + offset, buffer.byteOffset + offset + length);
          }
  
          // if we're emulating a connection-less dgram socket and don't have
          // a cached connection, queue the buffer to send upon connect and
          // lie, saying the data was sent now.
          if (sock.type === 2) {
            if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
              // if we're not connected, open a new connection
              if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
                dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr, port);
              }
              dest.dgram_send_queue.push(data);
              return length;
            }
          }
  
          try {
            // send the actual data
            dest.socket.send(data);
            return length;
          } catch (e) {
            throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
          }
        },recvmsg:function (sock, length) {
          // http://pubs.opengroup.org/onlinepubs/7908799/xns/recvmsg.html
          if (sock.type === 1 && sock.server) {
            // tcp servers should not be recv()'ing on the listen socket
            throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
          }
  
          var queued = sock.recv_queue.shift();
          if (!queued) {
            if (sock.type === 1) {
              var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
  
              if (!dest) {
                // if we have a destination address but are not connected, error out
                throw new FS.ErrnoError(ERRNO_CODES.ENOTCONN);
              }
              else if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
                // return null if the socket has closed
                return null;
              }
              else {
                // else, our socket is in a valid state but truly has nothing available
                throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
              }
            } else {
              throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);
            }
          }
  
          // queued.data will be an ArrayBuffer if it's unadulterated, but if it's
          // requeued TCP data it'll be an ArrayBufferView
          var queuedLength = queued.data.byteLength || queued.data.length;
          var queuedOffset = queued.data.byteOffset || 0;
          var queuedBuffer = queued.data.buffer || queued.data;
          var bytesRead = Math.min(length, queuedLength);
          var res = {
            buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
            addr: queued.addr,
            port: queued.port
          };
  
  
          // push back any unread data for TCP connections
          if (sock.type === 1 && bytesRead < queuedLength) {
            var bytesRemaining = queuedLength - bytesRead;
            queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
            sock.recv_queue.unshift(queued);
          }
  
          return res;
        }}};function _send(fd, buf, len, flags) {
      var sock = SOCKFS.getSocket(fd);
      if (!sock) {
        ___setErrNo(ERRNO_CODES.EBADF);
        return -1;
      }
      // TODO honor flags
      return _write(fd, buf, len);
    }
  
  function _pwrite(fildes, buf, nbyte, offset) {
      // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
      var stream = FS.getStream(fildes);
      if (!stream) {
        ___setErrNo(ERRNO_CODES.EBADF);
        return -1;
      }
      try {
        var slab = HEAP8;
        return FS.write(stream, slab, buf, nbyte, offset);
      } catch (e) {
        FS.handleFSError(e);
        return -1;
      }
    }function _write(fildes, buf, nbyte) {
      // ssize_t write(int fildes, const void *buf, size_t nbyte);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
      var stream = FS.getStream(fildes);
      if (!stream) {
        ___setErrNo(ERRNO_CODES.EBADF);
        return -1;
      }
  
  
      try {
        var slab = HEAP8;
        return FS.write(stream, slab, buf, nbyte);
      } catch (e) {
        FS.handleFSError(e);
        return -1;
      }
    }
  
  function _fileno(stream) {
      // int fileno(FILE *stream);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/fileno.html
      stream = FS.getStreamFromPtr(stream);
      if (!stream) return -1;
      return stream.fd;
    }function _fwrite(ptr, size, nitems, stream) {
      // size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/fwrite.html
      var bytesToWrite = nitems * size;
      if (bytesToWrite == 0) return 0;
      var fd = _fileno(stream);
      var bytesWritten = _write(fd, ptr, bytesToWrite);
      if (bytesWritten == -1) {
        var streamObj = FS.getStreamFromPtr(stream);
        if (streamObj) streamObj.error = true;
        return 0;
      } else {
        return (bytesWritten / size)|0;
      }
    }
  
  
   
  Module["_strlen"] = _strlen;
  
  function __reallyNegative(x) {
      return x < 0 || (x === 0 && (1/x) === -Infinity);
    }function __formatString(format, varargs) {
      var textIndex = format;
      var argIndex = 0;
      function getNextArg(type) {
        // NOTE: Explicitly ignoring type safety. Otherwise this fails:
        //       int x = 4; printf("%c\n", (char)x);
        var ret;
        if (type === 'double') {
          ret = (HEAP32[((tempDoublePtr)>>2)]=HEAP32[(((varargs)+(argIndex))>>2)],HEAP32[(((tempDoublePtr)+(4))>>2)]=HEAP32[(((varargs)+((argIndex)+(4)))>>2)],(+(HEAPF64[(tempDoublePtr)>>3])));
        } else if (type == 'i64') {
          ret = [HEAP32[(((varargs)+(argIndex))>>2)],
                 HEAP32[(((varargs)+(argIndex+4))>>2)]];
  
        } else {
          type = 'i32'; // varargs are always i32, i64, or double
          ret = HEAP32[(((varargs)+(argIndex))>>2)];
        }
        argIndex += Runtime.getNativeFieldSize(type);
        return ret;
      }
  
      var ret = [];
      var curr, next, currArg;
      while(1) {
        var startTextIndex = textIndex;
        curr = HEAP8[((textIndex)>>0)];
        if (curr === 0) break;
        next = HEAP8[((textIndex+1)>>0)];
        if (curr == 37) {
          // Handle flags.
          var flagAlwaysSigned = false;
          var flagLeftAlign = false;
          var flagAlternative = false;
          var flagZeroPad = false;
          var flagPadSign = false;
          flagsLoop: while (1) {
            switch (next) {
              case 43:
                flagAlwaysSigned = true;
                break;
              case 45:
                flagLeftAlign = true;
                break;
              case 35:
                flagAlternative = true;
                break;
              case 48:
                if (flagZeroPad) {
                  break flagsLoop;
                } else {
                  flagZeroPad = true;
                  break;
                }
              case 32:
                flagPadSign = true;
                break;
              default:
                break flagsLoop;
            }
            textIndex++;
            next = HEAP8[((textIndex+1)>>0)];
          }
  
          // Handle width.
          var width = 0;
          if (next == 42) {
            width = getNextArg('i32');
            textIndex++;
            next = HEAP8[((textIndex+1)>>0)];
          } else {
            while (next >= 48 && next <= 57) {
              width = width * 10 + (next - 48);
              textIndex++;
              next = HEAP8[((textIndex+1)>>0)];
            }
          }
  
          // Handle precision.
          var precisionSet = false, precision = -1;
          if (next == 46) {
            precision = 0;
            precisionSet = true;
            textIndex++;
            next = HEAP8[((textIndex+1)>>0)];
            if (next == 42) {
              precision = getNextArg('i32');
              textIndex++;
            } else {
              while(1) {
                var precisionChr = HEAP8[((textIndex+1)>>0)];
                if (precisionChr < 48 ||
                    precisionChr > 57) break;
                precision = precision * 10 + (precisionChr - 48);
                textIndex++;
              }
            }
            next = HEAP8[((textIndex+1)>>0)];
          }
          if (precision < 0) {
            precision = 6; // Standard default.
            precisionSet = false;
          }
  
          // Handle integer sizes. WARNING: These assume a 32-bit architecture!
          var argSize;
          switch (String.fromCharCode(next)) {
            case 'h':
              var nextNext = HEAP8[((textIndex+2)>>0)];
              if (nextNext == 104) {
                textIndex++;
                argSize = 1; // char (actually i32 in varargs)
              } else {
                argSize = 2; // short (actually i32 in varargs)
              }
              break;
            case 'l':
              var nextNext = HEAP8[((textIndex+2)>>0)];
              if (nextNext == 108) {
                textIndex++;
                argSize = 8; // long long
              } else {
                argSize = 4; // long
              }
              break;
            case 'L': // long long
            case 'q': // int64_t
            case 'j': // intmax_t
              argSize = 8;
              break;
            case 'z': // size_t
            case 't': // ptrdiff_t
            case 'I': // signed ptrdiff_t or unsigned size_t
              argSize = 4;
              break;
            default:
              argSize = null;
          }
          if (argSize) textIndex++;
          next = HEAP8[((textIndex+1)>>0)];
  
          // Handle type specifier.
          switch (String.fromCharCode(next)) {
            case 'd': case 'i': case 'u': case 'o': case 'x': case 'X': case 'p': {
              // Integer.
              var signed = next == 100 || next == 105;
              argSize = argSize || 4;
              var currArg = getNextArg('i' + (argSize * 8));
              var origArg = currArg;
              var argText;
              // Flatten i64-1 [low, high] into a (slightly rounded) double
              if (argSize == 8) {
                currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 117);
              }
              // Truncate to requested size.
              if (argSize <= 4) {
                var limit = Math.pow(256, argSize) - 1;
                currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
              }
              // Format the number.
              var currAbsArg = Math.abs(currArg);
              var prefix = '';
              if (next == 100 || next == 105) {
                if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], null); else
                argText = reSign(currArg, 8 * argSize, 1).toString(10);
              } else if (next == 117) {
                if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], true); else
                argText = unSign(currArg, 8 * argSize, 1).toString(10);
                currArg = Math.abs(currArg);
              } else if (next == 111) {
                argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
              } else if (next == 120 || next == 88) {
                prefix = (flagAlternative && currArg != 0) ? '0x' : '';
                if (argSize == 8 && i64Math) {
                  if (origArg[1]) {
                    argText = (origArg[1]>>>0).toString(16);
                    var lower = (origArg[0]>>>0).toString(16);
                    while (lower.length < 8) lower = '0' + lower;
                    argText += lower;
                  } else {
                    argText = (origArg[0]>>>0).toString(16);
                  }
                } else
                if (currArg < 0) {
                  // Represent negative numbers in hex as 2's complement.
                  currArg = -currArg;
                  argText = (currAbsArg - 1).toString(16);
                  var buffer = [];
                  for (var i = 0; i < argText.length; i++) {
                    buffer.push((0xF - parseInt(argText[i], 16)).toString(16));
                  }
                  argText = buffer.join('');
                  while (argText.length < argSize * 2) argText = 'f' + argText;
                } else {
                  argText = currAbsArg.toString(16);
                }
                if (next == 88) {
                  prefix = prefix.toUpperCase();
                  argText = argText.toUpperCase();
                }
              } else if (next == 112) {
                if (currAbsArg === 0) {
                  argText = '(nil)';
                } else {
                  prefix = '0x';
                  argText = currAbsArg.toString(16);
                }
              }
              if (precisionSet) {
                while (argText.length < precision) {
                  argText = '0' + argText;
                }
              }
  
              // Add sign if needed
              if (currArg >= 0) {
                if (flagAlwaysSigned) {
                  prefix = '+' + prefix;
                } else if (flagPadSign) {
                  prefix = ' ' + prefix;
                }
              }
  
              // Move sign to prefix so we zero-pad after the sign
              if (argText.charAt(0) == '-') {
                prefix = '-' + prefix;
                argText = argText.substr(1);
              }
  
              // Add padding.
              while (prefix.length + argText.length < width) {
                if (flagLeftAlign) {
                  argText += ' ';
                } else {
                  if (flagZeroPad) {
                    argText = '0' + argText;
                  } else {
                    prefix = ' ' + prefix;
                  }
                }
              }
  
              // Insert the result into the buffer.
              argText = prefix + argText;
              argText.split('').forEach(function(chr) {
                ret.push(chr.charCodeAt(0));
              });
              break;
            }
            case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': {
              // Float.
              var currArg = getNextArg('double');
              var argText;
              if (isNaN(currArg)) {
                argText = 'nan';
                flagZeroPad = false;
              } else if (!isFinite(currArg)) {
                argText = (currArg < 0 ? '-' : '') + 'inf';
                flagZeroPad = false;
              } else {
                var isGeneral = false;
                var effectivePrecision = Math.min(precision, 20);
  
                // Convert g/G to f/F or e/E, as per:
                // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
                if (next == 103 || next == 71) {
                  isGeneral = true;
                  precision = precision || 1;
                  var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
                  if (precision > exponent && exponent >= -4) {
                    next = ((next == 103) ? 'f' : 'F').charCodeAt(0);
                    precision -= exponent + 1;
                  } else {
                    next = ((next == 103) ? 'e' : 'E').charCodeAt(0);
                    precision--;
                  }
                  effectivePrecision = Math.min(precision, 20);
                }
  
                if (next == 101 || next == 69) {
                  argText = currArg.toExponential(effectivePrecision);
                  // Make sure the exponent has at least 2 digits.
                  if (/[eE][-+]\d$/.test(argText)) {
                    argText = argText.slice(0, -1) + '0' + argText.slice(-1);
                  }
                } else if (next == 102 || next == 70) {
                  argText = currArg.toFixed(effectivePrecision);
                  if (currArg === 0 && __reallyNegative(currArg)) {
                    argText = '-' + argText;
                  }
                }
  
                var parts = argText.split('e');
                if (isGeneral && !flagAlternative) {
                  // Discard trailing zeros and periods.
                  while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
                         (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
                    parts[0] = parts[0].slice(0, -1);
                  }
                } else {
                  // Make sure we have a period in alternative mode.
                  if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
                  // Zero pad until required precision.
                  while (precision > effectivePrecision++) parts[0] += '0';
                }
                argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
  
                // Capitalize 'E' if needed.
                if (next == 69) argText = argText.toUpperCase();
  
                // Add sign.
                if (currArg >= 0) {
                  if (flagAlwaysSigned) {
                    argText = '+' + argText;
                  } else if (flagPadSign) {
                    argText = ' ' + argText;
                  }
                }
              }
  
              // Add padding.
              while (argText.length < width) {
                if (flagLeftAlign) {
                  argText += ' ';
                } else {
                  if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
                    argText = argText[0] + '0' + argText.slice(1);
                  } else {
                    argText = (flagZeroPad ? '0' : ' ') + argText;
                  }
                }
              }
  
              // Adjust case.
              if (next < 97) argText = argText.toUpperCase();
  
              // Insert the result into the buffer.
              argText.split('').forEach(function(chr) {
                ret.push(chr.charCodeAt(0));
              });
              break;
            }
            case 's': {
              // String.
              var arg = getNextArg('i8*');
              var argLength = arg ? _strlen(arg) : '(null)'.length;
              if (precisionSet) argLength = Math.min(argLength, precision);
              if (!flagLeftAlign) {
                while (argLength < width--) {
                  ret.push(32);
                }
              }
              if (arg) {
                for (var i = 0; i < argLength; i++) {
                  ret.push(HEAPU8[((arg++)>>0)]);
                }
              } else {
                ret = ret.concat(intArrayFromString('(null)'.substr(0, argLength), true));
              }
              if (flagLeftAlign) {
                while (argLength < width--) {
                  ret.push(32);
                }
              }
              break;
            }
            case 'c': {
              // Character.
              if (flagLeftAlign) ret.push(getNextArg('i8'));
              while (--width > 0) {
                ret.push(32);
              }
              if (!flagLeftAlign) ret.push(getNextArg('i8'));
              break;
            }
            case 'n': {
              // Write the length written so far to the next parameter.
              var ptr = getNextArg('i32*');
              HEAP32[((ptr)>>2)]=ret.length;
              break;
            }
            case '%': {
              // Literal percent sign.
              ret.push(curr);
              break;
            }
            default: {
              // Unknown specifiers remain untouched.
              for (var i = startTextIndex; i < textIndex + 2; i++) {
                ret.push(HEAP8[((i)>>0)]);
              }
            }
          }
          textIndex += 2;
          // TODO: Support a/A (hex float) and m (last error) specifiers.
          // TODO: Support %1${specifier} for arg selection.
        } else {
          ret.push(curr);
          textIndex += 1;
        }
      }
      return ret;
    }function _fprintf(stream, format, varargs) {
      // int fprintf(FILE *restrict stream, const char *restrict format, ...);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
      var result = __formatString(format, varargs);
      var stack = Runtime.stackSave();
      var ret = _fwrite(allocate(result, 'i8', ALLOC_STACK), 1, result.length, stream);
      Runtime.stackRestore(stack);
      return ret;
    }function _printf(format, varargs) {
      // int printf(const char *restrict format, ...);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
      var stdout = HEAP32[((_stdout)>>2)];
      return _fprintf(stdout, format, varargs);
    }


  
  function _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.getAsmConst(code, 0)();
    }

  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;
    }

  
  function _fputs(s, stream) {
      // int fputs(const char *restrict s, FILE *restrict stream);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputs.html
      var fd = _fileno(stream);
      return _write(fd, s, _strlen(s));
    }
  
  function _fputc(c, stream) {
      // int fputc(int c, FILE *stream);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html
      var chr = unSign(c & 0xFF);
      HEAP8[((_fputc.ret)>>0)]=chr;
      var fd = _fileno(stream);
      var ret = _write(fd, _fputc.ret, 1);
      if (ret == -1) {
        var streamObj = FS.getStreamFromPtr(stream);
        if (streamObj) streamObj.error = true;
        return -1;
      } else {
        return chr;
      }
    }function _puts(s) {
      // int puts(const char *s);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/puts.html
      // NOTE: puts() always writes an extra newline.
      var stdout = HEAP32[((_stdout)>>2)];
      var ret = _fputs(s, stdout);
      if (ret < 0) {
        return ret;
      } else {
        var newlineRet = _fputc(10, stdout);
        return (newlineRet < 0) ? -1 : ret + 1;
      }
    }

  var ctlz_i8 = allocate([8,7,6,6,5,5,5,5,4,4,4,4,4,4,4,4,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_STATIC); 
  Module["_llvm_ctlz_i32"] = _llvm_ctlz_i32;

  function ___errno_location() {
      return ___errno_state;
    }

  var _BItoD=true;

  function _emscripten_asm_const_int(code) {
      var args = Array.prototype.slice.call(arguments, 1);
      return Runtime.getAsmConst(code, args.length).apply(null, args) | 0;
    }

  
  function __exit(status) {
      // void _exit(int status);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html
      Module['exit'](status);
    }function _exit(status) {
      __exit(status);
    }

  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) self.alloc(bytes);
      return ret;  // Previous break location.
    }

  function _time(ptr) {
      var ret = (Date.now()/1000)|0;
      if (ptr) {
        HEAP32[((ptr)>>2)]=ret;
      }
      return ret;
    }

  
  
  function _emscripten_set_main_loop_timing(mode, value) {
      Browser.mainLoop.timingMode = mode;
      Browser.mainLoop.timingValue = value;
  
      if (!Browser.mainLoop.func) {
        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) {
      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 (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);
          _emscripten_set_main_loop_timing(timingMode, timingValue);
        },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);
          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!
            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) {
        Browser.lockPointer = lockPointer;
        Browser.resizeCanvas = resizeCanvas;
        if (typeof Browser.lockPointer === 'undefined') Browser.lockPointer = true;
        if (typeof Browser.resizeCanvas === 'undefined') Browser.resizeCanvas = false;
  
        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);
        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);
        };
      },safeRequestAnimationFrame:function (func) {
        return Browser.requestAnimationFrame(function() {
          if (!ABORT) func();
        });
      },safeSetTimeout:function (func, timeout) {
        Module['noExitRuntime'] = true;
        return setTimeout(function() {
          if (!ABORT) func();
        }, timeout);
      },safeSetInterval:function (func, timeout) {
        Module['noExitRuntime'] = true;
        return setInterval(function() {
          if (!ABORT) func();
        }, 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 (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 = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
        	flags = flags | 0x00800000; // set SDL_FULLSCREEN flag
        	HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
        }
        Browser.updateResizeListeners();
      },setWindowedCanvasSize:function () {
        // check if SDL is available       
        if (typeof SDL != "undefined") {
        	var flags = HEAPU32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)];
        	flags = flags & ~0x00800000; // clear SDL_FULLSCREEN flag
        	HEAP32[((SDL.screen+Runtime.QUANTUM_SIZE*0)>>2)]=flags
        }
        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;
      }};

  function _llvm_ctlz_i64(l, h) {
      var ret = _llvm_ctlz_i32(h);
      if (ret == 32) ret += _llvm_ctlz_i32(l);
      return ((asm["setTempRet0"](0),ret)|0);
    }

  function _emscripten_async_call(func, arg, millis) {
      Module['noExitRuntime'] = true;
  
      function wrapper() {
        Runtime.getFuncWrapper(func, 'vi')(arg);
      }
  
      if (millis >= 0) {
        Browser.safeSetTimeout(wrapper, millis);
      } else {
        Browser.safeRequestAnimationFrame(wrapper);
      }
    }
___errno_state = Runtime.staticAlloc(4); HEAP32[((___errno_state)>>2)]=0;
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() } });TTY.utf8 = new Runtime.UTF8Processor();
if (ENVIRONMENT_IS_NODE) { var fs = require("fs"); NODEFS.staticInit(); }
__ATINIT__.push({ func: function() { SOCKFS.root = FS.mount(SOCKFS, {}, null); } });
_fputc.ret = allocate([0], "i8", ALLOC_STATIC);
Module["requestFullScreen"] = function Module_requestFullScreen(lockPointer, resizeCanvas) { Browser.requestFullScreen(lockPointer, resizeCanvas) };
  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() }
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 invoke_iiiiiiii(index,a1,a2,a3,a4,a5,a6,a7) {
  try {
    return Module["dynCall_iiiiiiii"](index,a1,a2,a3,a4,a5,a6,a7);
  } 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_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_ii(index,a1) {
  try {
    return Module["dynCall_ii"](index,a1);
  } 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_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_viiiiii(index,a1,a2,a3,a4,a5,a6) {
  try {
    Module["dynCall_viiiiii"](index,a1,a2,a3,a4,a5,a6);
  } 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 };
  Module.asmLibraryArg = { "abort": abort, "assert": assert, "min": Math_min, "invoke_iiiiiiii": invoke_iiiiiiii, "invoke_iiii": invoke_iiii, "invoke_vi": invoke_vi, "invoke_vii": invoke_vii, "invoke_ii": invoke_ii, "invoke_viii": invoke_viii, "invoke_iiiii": invoke_iiiii, "invoke_viiiiii": invoke_viiiiii, "_emscripten_get_now_is_monotonic": _emscripten_get_now_is_monotonic, "_send": _send, "__reallyNegative": __reallyNegative, "_emscripten_asm_const_int": _emscripten_asm_const_int, "___assert_fail": ___assert_fail, "_fflush": _fflush, "_clock_gettime": _clock_gettime, "_llvm_ctlz_i64": _llvm_ctlz_i64, "_pwrite": _pwrite, "_strerror_r": _strerror_r, "_emscripten_set_main_loop_timing": _emscripten_set_main_loop_timing, "_sbrk": _sbrk, "_emscripten_asm_const": _emscripten_asm_const, "_emscripten_get_now": _emscripten_get_now, "_emscripten_memcpy_big": _emscripten_memcpy_big, "_fileno": _fileno, "_sysconf": _sysconf, "___setErrNo": ___setErrNo, "_emscripten_async_wget_data": _emscripten_async_wget_data, "_puts": _puts, "_mkport": _mkport, "_write": _write, "_emscripten_set_main_loop": _emscripten_set_main_loop, "___errno_location": ___errno_location, "_printf": _printf, "__exit": __exit, "_fputc": _fputc, "_abort": _abort, "_fwrite": _fwrite, "_time": _time, "_fprintf": _fprintf, "_strerror": _strerror, "__formatString": __formatString, "_fputs": _fputs, "_exit": _exit, "_emscripten_async_call": _emscripten_async_call, "STACKTOP": STACKTOP, "STACK_MAX": STACK_MAX, "tempDoublePtr": tempDoublePtr, "ABORT": ABORT, "cttz_i8": cttz_i8, "ctlz_i8": ctlz_i8, "NaN": NaN, "Infinity": Infinity };
  // EMSCRIPTEN_START_ASM
  var asm = (function(global, env, buffer) {
    'use asm';
    
    var HEAP8 = new global.Int8Array(buffer);
    var HEAP16 = new global.Int16Array(buffer);
    var HEAP32 = new global.Int32Array(buffer);
    var HEAPU8 = new global.Uint8Array(buffer);
    var HEAPU16 = new global.Uint16Array(buffer);
    var HEAPU32 = new global.Uint32Array(buffer);
    var HEAPF32 = new global.Float32Array(buffer);
    var HEAPF64 = new global.Float64Array(buffer);

  
  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 ctlz_i8=env.ctlz_i8|0;

    var __THREW__ = 0;
    var threwValue = 0;
    var setjmpId = 0;
    var undef = 0;
    var nan = +env.NaN, inf = +env.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 abort=env.abort;
  var assert=env.assert;
  var Math_min=env.min;
  var invoke_iiiiiiii=env.invoke_iiiiiiii;
  var invoke_iiii=env.invoke_iiii;
  var invoke_vi=env.invoke_vi;
  var invoke_vii=env.invoke_vii;
  var invoke_ii=env.invoke_ii;
  var invoke_viii=env.invoke_viii;
  var invoke_iiiii=env.invoke_iiiii;
  var invoke_viiiiii=env.invoke_viiiiii;
  var _emscripten_get_now_is_monotonic=env._emscripten_get_now_is_monotonic;
  var _send=env._send;
  var __reallyNegative=env.__reallyNegative;
  var _emscripten_asm_const_int=env._emscripten_asm_const_int;
  var ___assert_fail=env.___assert_fail;
  var _fflush=env._fflush;
  var _clock_gettime=env._clock_gettime;
  var _llvm_ctlz_i64=env._llvm_ctlz_i64;
  var _pwrite=env._pwrite;
  var _strerror_r=env._strerror_r;
  var _emscripten_set_main_loop_timing=env._emscripten_set_main_loop_timing;
  var _sbrk=env._sbrk;
  var _emscripten_asm_const=env._emscripten_asm_const;
  var _emscripten_get_now=env._emscripten_get_now;
  var _emscripten_memcpy_big=env._emscripten_memcpy_big;
  var _fileno=env._fileno;
  var _sysconf=env._sysconf;
  var ___setErrNo=env.___setErrNo;
  var _emscripten_async_wget_data=env._emscripten_async_wget_data;
  var _puts=env._puts;
  var _mkport=env._mkport;
  var _write=env._write;
  var _emscripten_set_main_loop=env._emscripten_set_main_loop;
  var ___errno_location=env.___errno_location;
  var _printf=env._printf;
  var __exit=env.__exit;
  var _fputc=env._fputc;
  var _abort=env._abort;
  var _fwrite=env._fwrite;
  var _time=env._time;
  var _fprintf=env._fprintf;
  var _strerror=env._strerror;
  var __formatString=env.__formatString;
  var _fputs=env._fputs;
  var _exit=env._exit;
  var _emscripten_async_call=env._emscripten_async_call;
  var tempFloat = 0.0;

  // EMSCRIPTEN_START_FUNCS
function _riscv_cpu_interp64($s, $n_cycles) {
 $s = $s | 0;
 $n_cycles = $n_cycles | 0;
 var $0 = 0, $1000 = 0, $102 = 0, $1024 = 0, $1037 = 0, $1045 = 0, $106 = 0, $1065 = 0, $1067 = 0, $1070 = 0, $1071 = 0, $1079 = 0, $1080 = 0, $1081 = 0, $1083 = 0, $1086 = 0, $1087 = 0, $1089 = 0, $1104 = 0, $1106 = 0, $112 = 0, $1121 = 0, $1123 = 0, $113 = 0, $1136 = 0, $1138 = 0, $1150 = 0, $1155 = 0, $116 = 0, $1165 = 0, $1173 = 0, $1178 = 0, $1180 = 0, $1187 = 0, $1192 = 0, $1194 = 0, $12 = 0, $1201 = 0, $1211 = 0, $1213 = 0, $1216 = 0, $1217 = 0, $1219 = 0, $1221 = 0, $1231 = 0, $1241 = 0, $1243 = 0, $1246 = 0, $1247 = 0, $1249 = 0, $1252 = 0, $1253 = 0, $1255 = 0, $1259 = 0, $1263 = 0, $1265 = 0, $1268 = 0, $1269 = 0, $1271 = 0, $1274 = 0, $1275 = 0, $1281 = 0, $1282 = 0, $1283 = 0, $1284 = 0, $1285 = 0, $1286 = 0, $1287 = 0, $129 = 0, $1290 = 0, $1293 = 0, $1294 = 0, $1296 = 0, $1297 = 0, $1299 = 0, $1300 = 0, $1303 = 0, $1304 = 0, $1305 = 0, $1313 = 0, $1314 = 0, $1315 = 0, $1316 = 0, $1317 = 0, $1318 = 0, $1319 = 0, $1322 = 0, $1325 = 0, $1326 = 0, $1328 = 0, $1331 = 0, $1336 = 0, $1337 = 0, $1338 = 0, $1339 = 0, $134 = 0, $1340 = 0, $1341 = 0, $1342 = 0, $1345 = 0, $1348 = 0, $1349 = 0, $135 = 0, $1351 = 0, $139 = 0, $1417 = 0, $1419 = 0, $1422 = 0, $1423 = 0, $1425 = 0, $1428 = 0, $1429 = 0, $1431 = 0, $1434 = 0, $1435 = 0, $145 = 0, $1455 = 0, $1457 = 0, $146 = 0, $1460 = 0, $1461 = 0, $1467 = 0, $1468 = 0, $1469 = 0, $1470 = 0, $1475 = 0, $1476 = 0, $1480 = 0, $1484 = 0, $1486 = 0, $1489 = 0, $149 = 0, $1496 = 0, $1497 = 0, $1498 = 0, $1499 = 0, $1504 = 0, $1505 = 0, $1509 = 0, $1514 = 0, $1515 = 0, $1517 = 0, $1520 = 0, $1521 = 0, $1523 = 0, $1531 = 0, $1532 = 0, $1533 = 0, $1540 = 0, $1544 = 0, $1548 = 0, $1552 = 0, $1556 = 0, $1561 = 0, $1562 = 0, $1566 = 0, $1567 = 0, $1569 = 0, $1572 = 0, $1573 = 0, $1575 = 0, $1583 = 0, $1584 = 0, $1585 = 0, $1592 = 0, $1596 = 0, $1600 = 0, $1604 = 0, $1608 = 0, $1613 = 0, $1614 = 0, $1619 = 0, $1623 = 0, $1627 = 0, $1631 = 0, $1635 = 0, $1639 = 0, $1643 = 0, $1649 = 0, $1660 = 0, $1664 = 0, $1666 = 0, $1669 = 0, $1672 = 0, $1694 = 0, $1698 = 0, $1709 = 0, $171 = 0, $1715 = 0, $1730 = 0, $1736 = 0, $175 = 0, $1751 = 0, $1752 = 0, $1754 = 0, $1757 = 0, $1758 = 0, $1764 = 0, $1765 = 0, $1766 = 0, $1771 = 0, $1772 = 0, $1773 = 0, $1778 = 0, $1779 = 0, $1780 = 0, $1785 = 0, $1786 = 0, $1787 = 0, $1791 = 0, $1795 = 0, $1799 = 0, $1803 = 0, $1807 = 0, $181 = 0, $1818 = 0, $182 = 0, $1820 = 0, $1822 = 0, $1825 = 0, $1828 = 0, $1841 = 0, $1843 = 0, $1846 = 0, $1847 = 0, $185 = 0, $1851 = 0, $1860 = 0, $1862 = 0, $1865 = 0, $1868 = 0, $1880 = 0, $1887 = 0, $1893 = 0, $1900 = 0, $1902 = 0, $1905 = 0, $1906 = 0, $1908 = 0, $1911 = 0, $1912 = 0, $1916 = 0, $1917 = 0, $1918 = 0, $1922 = 0, $1923 = 0, $1924 = 0, $1928 = 0, $1929 = 0, $1930 = 0, $1934 = 0, $1935 = 0, $1936 = 0, $1945 = 0, $1954 = 0, $1963 = 0, $1972 = 0, $1976 = 0, $198 = 0, $1987 = 0, $1989 = 0, $1992 = 0, $1994 = 0, $1996 = 0, $1999 = 0, $2000 = 0, $2008 = 0, $2009 = 0, $2012 = 0, $203 = 0, $2032 = 0, $2036 = 0, $2038 = 0, $204 = 0, $2051 = 0, $2056 = 0, $2057 = 0, $2061 = 0, $2069 = 0, $2070 = 0, $2071 = 0, $2073 = 0, $2076 = 0, $2077 = 0, $2079 = 0, $208 = 0, $2092 = 0, $2094 = 0, $2106 = 0, $2129 = 0, $2133 = 0, $2139 = 0, $214 = 0, $2145 = 0, $215 = 0, $2151 = 0, $2153 = 0, $216 = 0, $2176 = 0, $218 = 0, $2180 = 0, $2186 = 0, $2192 = 0, $2199 = 0, $2201 = 0, $221 = 0, $2224 = 0, $2228 = 0, $2235 = 0, $224 = 0, $2241 = 0, $2247 = 0, $2249 = 0, $2273 = 0, $2277 = 0, $2284 = 0, $2290 = 0, $2297 = 0, $2299 = 0, $2315 = 0, $2331 = 0, $2347 = 0, $236 = 0, $2363 = 0, $2373 = 0, $2384 = 0, $2389 = 0, $2392 = 0, $2403 = 0, $241 = 0, $2412 = 0, $2413 = 0, $2417 = 0, $2423 = 0, $2431 = 0, $2432 = 0, $2448 = 0, $2464 = 0, $247 = 0, $248 = 0, $2490 = 0, $2498 = 0, $2500 = 0, $2502 = 0, $2505 = 0, $251 = 0, $2544 = 0, $2554 = 0, $2564 = 0, $2568 = 0, $257 = 0, $2575 = 0, $2579 = 0, $2586 = 0, $2590 = 0, $2597 = 0, $2607 = 0, $2615 = 0, $2617 = 0, $2620 = 0, $2629 = 0, $2633 = 0, $2639 = 0, $2647 = 0, $2651 = 0, $2657 = 0, $2665 = 0, $2669 = 0, $2675 = 0, $2683 = 0, $2687 = 0, $2693 = 0, $270 = 0, $2701 = 0, $2705 = 0, $2713 = 0, $2717 = 0, $2731 = 0, $2732 = 0, $2736 = 0, $2751 = 0, $2752 = 0, $2756 = 0, $276 = 0, $2769 = 0, $277 = 0, $2770 = 0, $2774 = 0, $278 = 0, $2780 = 0, $2786 = 0, $2788 = 0, $2792 = 0, $2798 = 0, $280 = 0, $2804 = 0, $2806 = 0, $2810 = 0, $2816 = 0, $2819 = 0, $2825 = 0, $2828 = 0, $283 = 0, $2834 = 0, $2836 = 0, $2842 = 0, $2844 = 0, $2846 = 0, $2849 = 0, $2850 = 0, $2856 = 0, $286 = 0, $2863 = 0, $2869 = 0, $2876 = 0, $2882 = 0, $2891 = 0, $2901 = 0, $2903 = 0, $2913 = 0, $2915 = 0, $2919 = 0, $2925 = 0, $2927 = 0, $2931 = 0, $2937 = 0, $2939 = 0, $2951 = 0, $2955 = 0, $2961 = 0, $2968 = 0, $2970 = 0, $2973 = 0, $2976 = 0, $298 = 0, $2981 = 0, $2982 = 0, $2986 = 0, $2992 = 0, $2994 = 0, $2998 = 0, $3000 = 0, $3003 = 0, $3004 = 0, $3010 = 0, $3012 = 0, $3016 = 0, $303 = 0, $304 = 0, $305 = 0, $315 = 0, $319 = 0, $329 = 0, $335 = 0, $339 = 0, $349 = 0, $355 = 0, $359 = 0, $361 = 0, $364 = 0, $365 = 0, $367 = 0, $371 = 0, $373 = 0, $379 = 0, $386 = 0, $387 = 0, $391 = 0, $397 = 0, $405 = 0, $409 = 0, $415 = 0, $422 = 0, $423 = 0, $427 = 0, $433 = 0, $440 = 0, $441 = 0, $445 = 0, $451 = 0, $458 = 0, $459 = 0, $463 = 0, $469 = 0, $479 = 0, $483 = 0, $489 = 0, $499 = 0, $507 = 0, $520 = 0, $53 = 0, $533 = 0, $534 = 0, $535 = 0, $543 = 0, $547 = 0, $55 = 0, $553 = 0, $554 = 0, $557 = 0, $570 = 0, $575 = 0, $576 = 0, $58 = 0, $580 = 0, $586 = 0, $587 = 0, $59 = 0, $590 = 0, $6 = 0, $61 = 0, $612 = 0, $616 = 0, $622 = 0, $623 = 0, $626 = 0, $639 = 0, $644 = 0, $645 = 0, $649 = 0, $656 = 0, $661 = 0, $662 = 0, $666 = 0, $670 = 0, $677 = 0, $683 = 0, $689 = 0, $691 = 0, $695 = 0, $701 = 0, $702 = 0, $703 = 0, $705 = 0, $708 = 0, $711 = 0, $723 = 0, $728 = 0, $734 = 0, $735 = 0, $738 = 0, $744 = 0, $757 = 0, $763 = 0, $764 = 0, $765 = 0, $767 = 0, $770 = 0, $773 = 0, $785 = 0, $792 = 0, $798 = 0, $800 = 0, $804 = 0, $808 = 0, $81 = 0, $816 = 0, $817 = 0, $820 = 0, $824 = 0, $835 = 0, $841 = 0, $850 = 0, $855 = 0, $856 = 0, $861 = 0, $867 = 0, $87 = 0, $872 = 0, $873 = 0, $878 = 0, $88 = 0, $886 = 0, $888 = 0, $89 = 0, $896 = 0, $897 = 0, $90 = 0, $900 = 0, $91 = 0, $92 = 0, $921 = 0, $926 = 0, $93 = 0, $94 = 0, $947 = 0, $952 = 0, $976 = 0, $add$i = 0, $and10 = 0, $and1072 = 0, $and12 = 0, $and1201 = 0, $and1216 = 0, $and1396 = 0, $and1423 = 0, $and1450 = 0, $and1453 = 0, $and1488 = 0, $and1491 = 0, $and1529 = 0, $and1532 = 0, $and1570 = 0, $and1573 = 0, $and1614 = 0, $and20$i$i = 0, $and229 = 0, $and398 = 0, $and574 = 0, $and584 = 0, $and739 = 0, $and8 = 0, $and826 = 0, $and856 = 0, $and886 = 0, $arrayidx = 0, $arrayidx156 = 0, $arrayidx171 = 0, $arrayidx241 = 0, $arrayidx260 = 0, $arrayidx273 = 0, $arrayidx280 = 0, $arrayidx287 = 0, $arrayidx295 = 0, $arrayidx303 = 0, $arrayidx313 = 0, $arrayidx406 = 0, $arrayidx506 = 0, $arrayidx516 = 0, $call1770 = 0, $call1777 = 0, $cmp1095 = 0, $cmp477 = 0, $cmp480 = 0, $cond$0 = 0, $conv$i = 0, $conv$i1053 = 0, $conv$i1067 = 0, $conv$i1083 = 0, $conv$i1100 = 0, $conv$i1133 = 0, $conv$i1155 = 0, $conv$i1176 = 0, $conv$i1194 = 0, $conv$i1213 = 0, $conv$i1254 = 0, $conv$i1274 = 0, $conv$i1295 = 0, $conv$i1314 = 0, $conv$i1333 = 0, $conv$i1352 = 0, $conv$i1361 = 0, $conv$i1403 = 0, $conv$i1424 = 0, $conv$i1528 = 0, $conv$i1544 = 0, $conv$i1562 = 0, $conv$i1579 = 0, $conv$i1596 = 0, $conv$i1619 = 0, $conv$i1641 = 0, $conv$i1662 = 0, $conv$i1684 = 0, $conv$i1707 = 0, $conv$i1730 = 0, $conv$i1752 = 0, $conv$i1775 = 0, $conv$i1798 = 0, $conv$i1825 = 0, $conv$i1852 = 0, $conv$i1881 = 0, $conv18$i = 0, $conv18$i1374 = 0, $conv2$i$i = 0, $enabled_ints$0$i$i = 0, $err$0 = 0, $fflags = 0, $i$05$i$i = 0, $i$07$i$i = 0, $i$07$i$i$i = 0, $i$07$i$i$i$i = 0, $i$07$i$i$i$i1385 = 0, $insn = 0, $insn_counter2220 = 0, $load_res = 0, $mideleg$i$i = 0, $mie = 0, $mip = 0, $mstatus$i$i = 0, $mul991 = 0, $n_cycles$addr$02173 = 0, $neg$i = 0, $neg$i1366 = 0, $or = 0, $or$i$i = 0, $or232 = 0, $or236 = 0, $or26 = 0, $or265 = 0, $priv1169 = 0, $retval$0$i1444 = 0, $retval$0$i1449 = 0, $retval$0$i5$i = 0, $shl1037 = 0, $shl8$i = 0, $shl8$i1369 = 0, $shr = 0, $shr$i1541 = 0, $shr$i1658 = 0, $shr$i1789 = 0, $shr$i1842 = 0, $shr$i1910 = 0, $shr$i1927 = 0, $shr$i1944 = 0, $shr$i1966 = 0, $shr$i1970 = 0, $shr1043 = 0, $shr1049 = 0, $shr1061 = 0, $shr11 = 0, $shr1221 = 0, $shr1319 = 0, $shr1397 = 0, $shr1428 = 0, $shr1451 = 0, $shr1489 = 0, $shr1530 = 0, $shr1571 = 0, $shr17 = 0, $shr228 = 0, $shr397 = 0, $shr602 = 0, $shr613 = 0, $shr626 = 0, $shr628 = 0, $shr668 = 0, $shr676 = 0, $shr744 = 0, $shr779 = 0, $shr857 = 0, $shr904 = 0, $shr978 = 0, $storemerge$i11121984$ph = 0, $storemerge$i12262037$ph = 0, $storemerge$i13271990$ph = 0, $storemerge$i13271994$ph = 0, $storemerge$i16091998$ph = 0, $storemerge$i16542006$ph = 0, $storemerge$i16752010$ph = 0, $storemerge$i16972014$ph = 0, $storemerge$i17202018$ph = 0, $storemerge$i17432022$ph = 0, $storemerge$i18652028$ph = 0, $storemerge$in$i = 0, $storemerge$in$i1144 = 0, $storemerge$in$i1166 = 0, $storemerge$in$i1205 = 0, $storemerge$in$i1285 = 0, $storemerge$in$i1630 = 0, $storemerge$in$i1836 = 0, $storemerge$in$i1892 = 0, $val$12$in = 0, $val$2$in = 0, $val$9$in = 0, $val$i = 0, $val$i1097 = 0, $val$i1130 = 0, $val$i1152 = 0, $val$i1191 = 0, $val$i1210 = 0, $val$i1251 = 0, $val$i1271 = 0, $val$i1311 = 0, $val$i1593 = 0, $val$i1616 = 0, $val$i1638 = 0, $val$i1659 = 0, $val$i1681 = 0, $val$i1704 = 0, $val$i1727 = 0, $val$i1822 = 0, $val$i1849 = 0, $val$i1878 = 0, $val2 = 0, label = 0, sp = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 176 | 0;
 $val$i1878 = sp + 152 | 0;
 $val$i1849 = sp + 144 | 0;
 $val$i1822 = sp + 136 | 0;
 $val$i1727 = sp + 128 | 0;
 $val$i1704 = sp + 120 | 0;
 $val$i1681 = sp + 112 | 0;
 $val$i1659 = sp + 104 | 0;
 $val$i1638 = sp + 96 | 0;
 $val$i1616 = sp + 88 | 0;
 $val$i1593 = sp + 80 | 0;
 $val$i1311 = sp + 72 | 0;
 $val$i1271 = sp + 64 | 0;
 $val$i1251 = sp + 56 | 0;
 $val$i1210 = sp + 48 | 0;
 $val$i1191 = sp + 40 | 0;
 $val$i1152 = sp + 32 | 0;
 $val$i1130 = sp + 24 | 0;
 $val$i1097 = sp + 16 | 0;
 $val$i = sp + 8 | 0;
 $insn = sp + 160 | 0;
 $val2 = sp;
 if (!$n_cycles) {
  STACKTOP = sp;
  return;
 }
 $mip = $s + 608 | 0;
 $mie = $s + 560 | 0;
 $arrayidx = $s + 24 | 0;
 $insn_counter2220 = $s + 528 | 0;
 $arrayidx506 = $s + 16 | 0;
 $priv1169 = $s + 526 | 0;
 $load_res = $s + 720 | 0;
 $fflags = $s + 520 | 0;
 $mstatus$i$i = $s + 552 | 0;
 $mideleg$i$i = $s + 640 | 0;
 $n_cycles$addr$02173 = $n_cycles;
 L4 : while (1) {
  $0 = $mip;
  $6 = $mie;
  $12 = HEAP32[$6 >> 2] & HEAP32[$0 >> 2];
  if (!(($12 | 0) == 0 ? (HEAP32[$6 + 4 >> 2] & HEAP32[$0 + 4 >> 2] | 0) == 0 : 0)) if ($12) {
   $conv2$i$i = HEAPU8[$priv1169 >> 0] | 0;
   if (($conv2$i$i | 0) == 3) if ((HEAP32[$mstatus$i$i >> 2] & 8 | 0) == 0 & 0 == 0) $enabled_ints$0$i$i = 0; else $enabled_ints$0$i$i = ~HEAP32[$mideleg$i$i >> 2]; else if (($conv2$i$i | 0) == 1) $enabled_ints$0$i$i = (HEAP32[$mstatus$i$i >> 2] & 2 | 0) == 0 & 0 == 0 ? ~HEAP32[$mideleg$i$i >> 2] : -1; else $enabled_ints$0$i$i = -1;
   $and20$i$i = $enabled_ints$0$i$i & $12;
   if ($and20$i$i) {
    $i$05$i$i = 0;
    while (1) {
     if (1 << $i$05$i$i & $and20$i$i) {
      $retval$0$i5$i = $i$05$i$i;
      break;
     }
     $i$05$i$i = $i$05$i$i + 1 | 0;
     if (($i$05$i$i | 0) >= 32) {
      $retval$0$i5$i = 32;
      break;
     }
    }
    _raise_exception2($s, $retval$0$i5$i | -2147483648, 0, 0);
   }
  }
  $53 = $s;
  $55 = HEAP32[$53 >> 2] | 0;
  $58 = HEAP32[$53 + 4 >> 2] | 0;
  $59 = _bitshift64Lshr($55 | 0, $58 | 0, 12) | 0;
  $conv$i = $59 & 255;
  $61 = $s + ($conv$i << 4) + 9592 | 0;
  if (((HEAP32[$61 >> 2] | 0) == ($55 & -4096 | 0) ? (HEAP32[$61 + 4 >> 2] | 0) == ($58 | 0) : 0) & (($55 & 4095 | 0) != 4094 | 0 != 0)) {
   $add$i = (HEAP32[$s + ($conv$i << 4) + 9600 >> 2] | 0) + $55 | 0;
   $or$i$i = HEAPU16[$add$i + 2 >> 1] << 16 | HEAPU16[$add$i >> 1];
   HEAP32[$insn >> 2] = $or$i$i;
   $87 = $55;
   $88 = $58;
   $91 = $or$i$i;
  } else {
   if (_target_read_insn_slow($s, $insn, $55, $58, 0) | 0) break;
   $81 = $s;
   $87 = HEAP32[$81 >> 2] | 0;
   $88 = HEAP32[$81 + 4 >> 2] | 0;
   $91 = HEAP32[$insn >> 2] | 0;
  }
  $89 = _i64Add($87 | 0, $88 | 0, 4, 0) | 0;
  $90 = tempRet0;
  $shr = $91 >>> 7;
  $and8 = $shr & 31;
  $and10 = $91 >>> 15 & 31;
  $shr11 = $91 >>> 20;
  $and12 = $shr11 & 31;
  L24 : do switch ($91 & 127 | 0) {
  case 124:
  case 120:
  case 116:
  case 112:
  case 108:
  case 104:
  case 100:
  case 96:
  case 92:
  case 88:
  case 84:
  case 80:
  case 76:
  case 72:
  case 68:
  case 64:
  case 60:
  case 56:
  case 52:
  case 48:
  case 44:
  case 40:
  case 36:
  case 32:
  case 28:
  case 24:
  case 20:
  case 16:
  case 12:
  case 8:
  case 4:
  case 0:
   {
    $92 = _i64Add($87 | 0, $88 | 0, 2, 0) | 0;
    $93 = tempRet0;
    $shr17 = $91 >>> 2;
    $or = $shr17 & 7 | 8;
    switch ($91 >>> 13 & 7 | 0) {
    case 2:
     {
      $139 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      $145 = _i64Add(HEAP32[$139 >> 2] | 0, HEAP32[$139 + 4 >> 2] | 0, $shr & 56 | $91 >>> 4 & 4 | $91 << 1 & 64 | 0, 0) | 0;
      $146 = tempRet0;
      $conv$i1213 = (_bitshift64Lshr($145 | 0, $146 | 0, 12) | 0) & 255;
      $149 = $s + ($conv$i1213 << 4) + 1400 | 0;
      if ((HEAP32[$149 >> 2] | 0) == ($145 & -4065 | 0) ? (HEAP32[$149 + 4 >> 2] | 0) == ($146 | 0) : 0) $storemerge$i12262037$ph = HEAP32[(HEAP32[$s + ($conv$i1213 << 4) + 1408 >> 2] | 0) + $145 >> 2] | 0; else {
       if (_target_read_slow($s, $val$i1210, $145, $146, 2) | 0) break L4;
       $storemerge$i12262037$ph = HEAP32[$val$i1210 >> 2] | 0;
      }
      $171 = $s + ($or << 3) + 8 | 0;
      HEAP32[$171 >> 2] = $storemerge$i12262037$ph;
      HEAP32[$171 + 4 >> 2] = (($storemerge$i12262037$ph | 0) < 0) << 31 >> 31;
      $3000 = $92;
      $3003 = $93;
      break L24;
      break;
     }
    case 7:
     {
      $270 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      $276 = _i64Add(HEAP32[$270 >> 2] | 0, HEAP32[$270 + 4 >> 2] | 0, $shr & 56 | $91 << 1 & 192 | 0, 0) | 0;
      $277 = tempRet0;
      $278 = $s + ($or << 3) + 8 | 0;
      $280 = HEAP32[$278 >> 2] | 0;
      $283 = HEAP32[$278 + 4 >> 2] | 0;
      $conv$i1424 = (_bitshift64Lshr($276 | 0, $277 | 0, 12) | 0) & 255;
      $286 = $s + ($conv$i1424 << 4) + 5496 | 0;
      if ((HEAP32[$286 >> 2] | 0) == ($276 & -4033 | 0) ? (HEAP32[$286 + 4 >> 2] | 0) == ($277 | 0) : 0) {
       $298 = (HEAP32[$s + ($conv$i1424 << 4) + 5504 >> 2] | 0) + $276 | 0;
       HEAP32[$298 >> 2] = $280;
       HEAP32[$298 + 4 >> 2] = $283;
       $3000 = $92;
       $3003 = $93;
       break L24;
      } else if (!(_target_write_slow($s, $276, $277, $280, $283, 3) | 0)) {
       $3000 = $92;
       $3003 = $93;
       break L24;
      } else break L4;
      break;
     }
    case 6:
     {
      $241 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      $247 = _i64Add(HEAP32[$241 >> 2] | 0, HEAP32[$241 + 4 >> 2] | 0, $shr & 56 | $91 >>> 4 & 4 | $91 << 1 & 64 | 0, 0) | 0;
      $248 = tempRet0;
      $251 = HEAP32[$s + ($or << 3) + 8 >> 2] | 0;
      $conv$i1403 = (_bitshift64Lshr($247 | 0, $248 | 0, 12) | 0) & 255;
      $257 = $s + ($conv$i1403 << 4) + 5496 | 0;
      if ((HEAP32[$257 >> 2] | 0) == ($247 & -4065 | 0) ? (HEAP32[$257 + 4 >> 2] | 0) == ($248 | 0) : 0) {
       HEAP32[(HEAP32[$s + ($conv$i1403 << 4) + 5504 >> 2] | 0) + $247 >> 2] = $251;
       $3000 = $92;
       $3003 = $93;
       break L24;
      } else if (!(_target_write_slow($s, $247, $248, $251, 0, 2) | 0)) {
       $3000 = $92;
       $3003 = $93;
       break L24;
      } else break L4;
      break;
     }
    case 5:
     {
      $208 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      $214 = _i64Add(HEAP32[$208 >> 2] | 0, HEAP32[$208 + 4 >> 2] | 0, $shr & 56 | $91 << 1 & 192 | 0, 0) | 0;
      $215 = tempRet0;
      $216 = $s + ($or << 3) + 264 | 0;
      $218 = HEAP32[$216 >> 2] | 0;
      $221 = HEAP32[$216 + 4 >> 2] | 0;
      $conv$i1333 = (_bitshift64Lshr($214 | 0, $215 | 0, 12) | 0) & 255;
      $224 = $s + ($conv$i1333 << 4) + 5496 | 0;
      if ((HEAP32[$224 >> 2] | 0) == ($214 & -4033 | 0) ? (HEAP32[$224 + 4 >> 2] | 0) == ($215 | 0) : 0) {
       $236 = (HEAP32[$s + ($conv$i1333 << 4) + 5504 >> 2] | 0) + $214 | 0;
       HEAP32[$236 >> 2] = $218;
       HEAP32[$236 + 4 >> 2] = $221;
       $3000 = $92;
       $3003 = $93;
       break L24;
      } else if (!(_target_write_slow($s, $214, $215, $218, $221, 3) | 0)) {
       $3000 = $92;
       $3003 = $93;
       break L24;
      } else break L4;
      break;
     }
    case 3:
     {
      $175 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      $181 = _i64Add(HEAP32[$175 >> 2] | 0, HEAP32[$175 + 4 >> 2] | 0, $shr & 56 | $91 << 1 & 192 | 0, 0) | 0;
      $182 = tempRet0;
      $conv$i1274 = (_bitshift64Lshr($181 | 0, $182 | 0, 12) | 0) & 255;
      $185 = $s + ($conv$i1274 << 4) + 1400 | 0;
      if ((HEAP32[$185 >> 2] | 0) == ($181 & -4033 | 0) ? (HEAP32[$185 + 4 >> 2] | 0) == ($182 | 0) : 0) $storemerge$in$i1285 = (HEAP32[$s + ($conv$i1274 << 4) + 1408 >> 2] | 0) + $181 | 0; else if (!(_target_read_slow($s, $val$i1271, $181, $182, 3) | 0)) $storemerge$in$i1285 = $val$i1271; else break L4;
      $198 = $storemerge$in$i1285;
      $203 = HEAP32[$198 + 4 >> 2] | 0;
      $204 = $s + ($or << 3) + 8 | 0;
      HEAP32[$204 >> 2] = HEAP32[$198 >> 2];
      HEAP32[$204 + 4 >> 2] = $203;
      $3000 = $92;
      $3003 = $93;
      break L24;
      break;
     }
    case 0:
     {
      $or26 = $shr & 48 | $91 >>> 1 & 960 | $91 >>> 4 & 4 | $shr17 & 8;
      if (!$or26) {
       label = 478;
       break L4;
      }
      $94 = $arrayidx;
      $102 = $s + ($or << 3) + 8 | 0;
      HEAP32[$102 >> 2] = _i64Add(HEAP32[$94 >> 2] | 0, HEAP32[$94 + 4 >> 2] | 0, $or26 | 0, 0) | 0;
      HEAP32[$102 + 4 >> 2] = tempRet0;
      $3000 = $92;
      $3003 = $93;
      break L24;
      break;
     }
    case 1:
     {
      $106 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      $112 = _i64Add(HEAP32[$106 >> 2] | 0, HEAP32[$106 + 4 >> 2] | 0, $shr & 56 | $91 << 1 & 192 | 0, 0) | 0;
      $113 = tempRet0;
      $conv$i1133 = (_bitshift64Lshr($112 | 0, $113 | 0, 12) | 0) & 255;
      $116 = $s + ($conv$i1133 << 4) + 1400 | 0;
      if ((HEAP32[$116 >> 2] | 0) == ($112 & -4033 | 0) ? (HEAP32[$116 + 4 >> 2] | 0) == ($113 | 0) : 0) $storemerge$in$i1144 = (HEAP32[$s + ($conv$i1133 << 4) + 1408 >> 2] | 0) + $112 | 0; else if (!(_target_read_slow($s, $val$i1130, $112, $113, 3) | 0)) $storemerge$in$i1144 = $val$i1130; else break L4;
      $129 = $storemerge$in$i1144;
      $134 = HEAP32[$129 + 4 >> 2] | 0;
      $135 = $s + ($or << 3) + 264 | 0;
      HEAP32[$135 >> 2] = HEAP32[$129 >> 2];
      HEAP32[$135 + 4 >> 2] = $134;
      $3000 = $92;
      $3003 = $93;
      break L24;
      break;
     }
    default:
     {
      label = 478;
      break L4;
     }
    }
    break;
   }
  case 15:
   {
    $and1201 = $91 >>> 12 & 7;
    if (!$and1201) if (!($91 & -267387008)) {
     $3000 = $89;
     $3003 = $90;
     break L24;
    } else {
     label = 478;
     break L4;
    } else if (($and1201 | 0) == 1) if (($91 | 0) == 4111) {
     $3000 = $89;
     $3003 = $90;
     break L24;
    } else {
     label = 478;
     break L4;
    } else {
     label = 478;
     break L4;
    }
    break;
   }
  case 55:
   {
    if (!$and8) {
     $3000 = $89;
     $3003 = $90;
    } else {
     $and574 = $91 & -4096;
     $792 = $s + ($and8 << 3) + 8 | 0;
     HEAP32[$792 >> 2] = $and574;
     HEAP32[$792 + 4 >> 2] = (($and574 | 0) < 0) << 31 >> 31;
     $3000 = $89;
     $3003 = $90;
    }
    break;
   }
  case 23:
   {
    if (!$and8) {
     $3000 = $89;
     $3003 = $90;
    } else {
     $and584 = $91 & -4096;
     $798 = _i64Add($and584 | 0, (($and584 | 0) < 0) << 31 >> 31 | 0, $87 | 0, $88 | 0) | 0;
     $800 = $s + ($and8 << 3) + 8 | 0;
     HEAP32[$800 >> 2] = $798;
     HEAP32[$800 + 4 >> 2] = tempRet0;
     $3000 = $89;
     $3003 = $90;
    }
    break;
   }
  case 103:
   {
    $shr613 = $91 >> 20;
    if ($and8) {
     $820 = $s + ($and8 << 3) + 8 | 0;
     HEAP32[$820 >> 2] = $89;
     HEAP32[$820 + 4 >> 2] = $90;
    }
    $824 = $s + ($and10 << 3) + 8 | 0;
    $3000 = (_i64Add(HEAP32[$824 >> 2] | 0, HEAP32[$824 + 4 >> 2] | 0, $shr613 | 0, (($shr613 | 0) < 0) << 31 >> 31 | 0) | 0) & -2;
    $3003 = tempRet0;
    break;
   }
  case 99:
   {
    $shr626 = $91 >>> 12;
    $shr628 = $91 >>> 13 & 3;
    if (!$shr628) {
     $835 = $s + ($and10 << 3) + 8 | 0;
     $841 = $s + ($and12 << 3) + 8 | 0;
     $cond$0 = ((HEAP32[$835 >> 2] | 0) == (HEAP32[$841 >> 2] | 0) ? (HEAP32[$835 + 4 >> 2] | 0) == (HEAP32[$841 + 4 >> 2] | 0) : 0) & 1;
    } else if (($shr628 | 0) == 2) {
     $850 = $s + ($and10 << 3) + 8 | 0;
     $855 = HEAP32[$850 + 4 >> 2] | 0;
     $856 = $s + ($and12 << 3) + 8 | 0;
     $861 = HEAP32[$856 + 4 >> 2] | 0;
     $cond$0 = (($855 | 0) < ($861 | 0) | (($855 | 0) == ($861 | 0) ? (HEAP32[$850 >> 2] | 0) >>> 0 < (HEAP32[$856 >> 2] | 0) >>> 0 : 0)) & 1;
    } else if (($shr628 | 0) == 3) {
     $867 = $s + ($and10 << 3) + 8 | 0;
     $872 = HEAP32[$867 + 4 >> 2] | 0;
     $873 = $s + ($and12 << 3) + 8 | 0;
     $878 = HEAP32[$873 + 4 >> 2] | 0;
     $cond$0 = ($872 >>> 0 < $878 >>> 0 | (($872 | 0) == ($878 | 0) ? (HEAP32[$867 >> 2] | 0) >>> 0 < (HEAP32[$873 >> 2] | 0) >>> 0 : 0)) & 1;
    } else {
     label = 478;
     break L4;
    }
    if (($cond$0 | 0) == ($shr626 & 1 | 0)) {
     $3000 = $89;
     $3003 = $90;
    } else {
     $shr668 = ($91 >>> 19 & 4096 | $shr11 & 2016 | $shr & 30 | $91 << 4 & 2048) << 19 >> 19;
     $886 = _i64Add($shr668 | 0, (($shr668 | 0) < 0) << 31 >> 31 | 0, $87 | 0, $88 | 0) | 0;
     $3000 = $886;
     $3003 = tempRet0;
    }
    break;
   }
  case 111:
   {
    $shr602 = ($shr11 & 2046 | $91 & 1044480 | $91 >>> 11 & 1048576 | $91 >>> 9 & 2048) << 11 >> 11;
    if (!$and8) {
     $816 = $87;
     $817 = $88;
    } else {
     $804 = $s + ($and8 << 3) + 8 | 0;
     HEAP32[$804 >> 2] = $89;
     HEAP32[$804 + 4 >> 2] = $90;
     $808 = $s;
     $816 = HEAP32[$808 >> 2] | 0;
     $817 = HEAP32[$808 + 4 >> 2] | 0;
    }
    $3000 = _i64Add($816 | 0, $817 | 0, $shr602 | 0, (($shr602 | 0) < 0) << 31 >> 31 | 0) | 0;
    $3003 = tempRet0;
    break;
   }
  case 3:
   {
    $shr676 = $91 >> 20;
    $888 = $s + ($and10 << 3) + 8 | 0;
    $896 = _i64Add(HEAP32[$888 >> 2] | 0, HEAP32[$888 + 4 >> 2] | 0, $shr676 | 0, (($shr676 | 0) < 0) << 31 >> 31 | 0) | 0;
    $897 = tempRet0;
    switch ($91 >>> 12 & 7 | 0) {
    case 1:
     {
      $conv$i1707 = (_bitshift64Lshr($896 | 0, $897 | 0, 12) | 0) & 255;
      $926 = $s + ($conv$i1707 << 4) + 1400 | 0;
      if ((HEAP32[$926 >> 2] | 0) == ($896 & -4081 | 0) ? (HEAP32[$926 + 4 >> 2] | 0) == ($897 | 0) : 0) $storemerge$i17202018$ph = HEAP16[(HEAP32[$s + ($conv$i1707 << 4) + 1408 >> 2] | 0) + $896 >> 1] | 0; else {
       if (_target_read_slow($s, $val$i1704, $896, $897, 1) | 0) break L4;
       $storemerge$i17202018$ph = HEAP32[$val$i1704 >> 2] & 65535;
      }
      $947 = $storemerge$i17202018$ph << 16 >> 16;
      $1067 = $947;
      $1070 = (($947 | 0) < 0) << 31 >> 31;
      break;
     }
    case 0:
     {
      $conv$i1730 = (_bitshift64Lshr($896 | 0, $897 | 0, 12) | 0) & 255;
      $900 = $s + ($conv$i1730 << 4) + 1400 | 0;
      if ((HEAP32[$900 >> 2] | 0) == ($896 & -4089 | 0) ? (HEAP32[$900 + 4 >> 2] | 0) == ($897 | 0) : 0) $storemerge$i17432022$ph = HEAP8[(HEAP32[$s + ($conv$i1730 << 4) + 1408 >> 2] | 0) + $896 >> 0] | 0; else {
       if (_target_read_slow($s, $val$i1727, $896, $897, 0) | 0) break L4;
       $storemerge$i17432022$ph = HEAP32[$val$i1727 >> 2] & 255;
      }
      $921 = $storemerge$i17432022$ph << 24 >> 24;
      $1067 = $921;
      $1070 = (($921 | 0) < 0) << 31 >> 31;
      break;
     }
    case 4:
     {
      $conv$i1662 = (_bitshift64Lshr($896 | 0, $897 | 0, 12) | 0) & 255;
      $976 = $s + ($conv$i1662 << 4) + 1400 | 0;
      if ((HEAP32[$976 >> 2] | 0) == ($896 & -4089 | 0) ? (HEAP32[$976 + 4 >> 2] | 0) == ($897 | 0) : 0) $storemerge$i16752010$ph = HEAP8[(HEAP32[$s + ($conv$i1662 << 4) + 1408 >> 2] | 0) + $896 >> 0] | 0; else {
       if (_target_read_slow($s, $val$i1659, $896, $897, 0) | 0) break L4;
       $storemerge$i16752010$ph = HEAP32[$val$i1659 >> 2] & 255;
      }
      $1067 = $storemerge$i16752010$ph & 255;
      $1070 = 0;
      break;
     }
    case 2:
     {
      $conv$i1684 = (_bitshift64Lshr($896 | 0, $897 | 0, 12) | 0) & 255;
      $952 = $s + ($conv$i1684 << 4) + 1400 | 0;
      if ((HEAP32[$952 >> 2] | 0) == ($896 & -4065 | 0) ? (HEAP32[$952 + 4 >> 2] | 0) == ($897 | 0) : 0) $storemerge$i16972014$ph = HEAP32[(HEAP32[$s + ($conv$i1684 << 4) + 1408 >> 2] | 0) + $896 >> 2] | 0; else {
       if (_target_read_slow($s, $val$i1681, $896, $897, 2) | 0) break L4;
       $storemerge$i16972014$ph = HEAP32[$val$i1681 >> 2] | 0;
      }
      $1067 = $storemerge$i16972014$ph;
      $1070 = (($storemerge$i16972014$ph | 0) < 0) << 31 >> 31;
      break;
     }
    case 5:
     {
      $conv$i1641 = (_bitshift64Lshr($896 | 0, $897 | 0, 12) | 0) & 255;
      $1000 = $s + ($conv$i1641 << 4) + 1400 | 0;
      if ((HEAP32[$1000 >> 2] | 0) == ($896 & -4081 | 0) ? (HEAP32[$1000 + 4 >> 2] | 0) == ($897 | 0) : 0) $storemerge$i16542006$ph = HEAP16[(HEAP32[$s + ($conv$i1641 << 4) + 1408 >> 2] | 0) + $896 >> 1] | 0; else {
       if (_target_read_slow($s, $val$i1638, $896, $897, 1) | 0) break L4;
       $storemerge$i16542006$ph = HEAP32[$val$i1638 >> 2] & 65535;
      }
      $1067 = $storemerge$i16542006$ph & 65535;
      $1070 = 0;
      break;
     }
    case 3:
     {
      $conv$i1619 = (_bitshift64Lshr($896 | 0, $897 | 0, 12) | 0) & 255;
      $1024 = $s + ($conv$i1619 << 4) + 1400 | 0;
      if ((HEAP32[$1024 >> 2] | 0) == ($896 & -4033 | 0) ? (HEAP32[$1024 + 4 >> 2] | 0) == ($897 | 0) : 0) $storemerge$in$i1630 = (HEAP32[$s + ($conv$i1619 << 4) + 1408 >> 2] | 0) + $896 | 0; else if (!(_target_read_slow($s, $val$i1616, $896, $897, 3) | 0)) $storemerge$in$i1630 = $val$i1616; else break L4;
      $1037 = $storemerge$in$i1630;
      $1067 = HEAP32[$1037 >> 2] | 0;
      $1070 = HEAP32[$1037 + 4 >> 2] | 0;
      break;
     }
    case 6:
     {
      $conv$i1596 = (_bitshift64Lshr($896 | 0, $897 | 0, 12) | 0) & 255;
      $1045 = $s + ($conv$i1596 << 4) + 1400 | 0;
      if ((HEAP32[$1045 >> 2] | 0) == ($896 & -4065 | 0) ? (HEAP32[$1045 + 4 >> 2] | 0) == ($897 | 0) : 0) $storemerge$i16091998$ph = HEAP32[(HEAP32[$s + ($conv$i1596 << 4) + 1408 >> 2] | 0) + $896 >> 2] | 0; else {
       if (_target_read_slow($s, $val$i1593, $896, $897, 2) | 0) break L4;
       $storemerge$i16091998$ph = HEAP32[$val$i1593 >> 2] | 0;
      }
      $1067 = $storemerge$i16091998$ph;
      $1070 = 0;
      break;
     }
    default:
     {
      label = 478;
      break L4;
     }
    }
    if (!$and8) {
     $3000 = $89;
     $3003 = $90;
    } else {
     $1065 = $s + ($and8 << 3) + 8 | 0;
     HEAP32[$1065 >> 2] = $1067;
     HEAP32[$1065 + 4 >> 2] = $1070;
     $3000 = $89;
     $3003 = $90;
    }
    break;
   }
  case 27:
   {
    $and856 = $91 >>> 12 & 7;
    $shr857 = $91 >> 20;
    $1247 = $s + ($and10 << 3) + 8 | 0;
    $1249 = HEAP32[$1247 >> 2] | 0;
    $1252 = HEAP32[$1247 + 4 >> 2] | 0;
    do if (!$and856) {
     $1253 = _i64Add($1249 | 0, $1252 | 0, $shr857 | 0, 0) | 0;
     $val$2$in = $1253;
    } else if (($and856 | 0) == 1) {
     if ($shr857 >>> 0 > 31) {
      label = 478;
      break L4;
     }
     $1255 = _bitshift64Shl($1249 | 0, $1252 | 0, $shr857 & 31 | 0) | 0;
     $val$2$in = $1255;
    } else if (($and856 | 0) == 5) {
     if ($shr857 & -1056) {
      label = 478;
      break L4;
     }
     $and886 = $shr857 & 31;
     if (!($shr857 & 1024)) {
      $val$2$in = $1249 >>> $and886;
      break;
     } else {
      $val$2$in = $1249 >> $and886;
      break;
     }
    } else {
     label = 478;
     break L4;
    } while (0);
    if (!$and8) {
     $3000 = $89;
     $3003 = $90;
    } else {
     $1259 = $s + ($and8 << 3) + 8 | 0;
     HEAP32[$1259 >> 2] = $val$2$in;
     HEAP32[$1259 + 4 >> 2] = (($val$2$in | 0) < 0) << 31 >> 31;
     $3000 = $89;
     $3003 = $90;
    }
    break;
   }
  case 51:
   {
    $shr904 = $91 >>> 25;
    $1263 = $s + ($and10 << 3) + 8 | 0;
    $1265 = HEAP32[$1263 >> 2] | 0;
    $1268 = HEAP32[$1263 + 4 >> 2] | 0;
    $1269 = $s + ($and12 << 3) + 8 | 0;
    $1271 = HEAP32[$1269 >> 2] | 0;
    $1274 = HEAP32[$1269 + 4 >> 2] | 0;
    $1275 = $val2;
    HEAP32[$1275 >> 2] = $1271;
    HEAP32[$1275 + 4 >> 2] = $1274;
    L138 : do if (($shr904 | 0) == 1) switch ($91 >>> 12 & 7 | 0) {
    case 0:
     {
      $1419 = ___muldi3($1271 | 0, $1274 | 0, $1265 | 0, $1268 | 0) | 0;
      $1422 = tempRet0;
      break L138;
      break;
     }
    case 5:
     {
      if (($1271 | 0) == 0 & ($1274 | 0) == 0) {
       $1419 = -1;
       $1422 = -1;
       break L138;
      }
      $1419 = ___udivdi3($1265 | 0, $1268 | 0, $1271 | 0, $1274 | 0) | 0;
      $1422 = tempRet0;
      break L138;
      break;
     }
    case 6:
     {
      if (($1271 | 0) == 0 & ($1274 | 0) == 0) {
       $1419 = $1265;
       $1422 = $1268;
       break L138;
      }
      if (($1265 | 0) == -2147483648 & ($1268 | 0) == 0 & (($1271 | 0) == -1 & ($1274 | 0) == -1)) {
       $1419 = 0;
       $1422 = 0;
       break L138;
      }
      $1419 = ___remdi3($1265 | 0, $1268 | 0, $1271 | 0, $1274 | 0) | 0;
      $1422 = tempRet0;
      break L138;
      break;
     }
    case 7:
     {
      if (($1271 | 0) == 0 & ($1274 | 0) == 0) {
       $1419 = $1265;
       $1422 = $1268;
       break L138;
      }
      $1419 = ___uremdi3($1265 | 0, $1268 | 0, $1271 | 0, $1274 | 0) | 0;
      $1422 = tempRet0;
      break L138;
      break;
     }
    case 1:
     {
      ___muldi3($1271 | 0, 0, $1265 | 0, 0) | 0;
      $1281 = tempRet0;
      $1282 = ___muldi3($1274 | 0, 0, $1265 | 0, 0) | 0;
      $1283 = tempRet0;
      $1284 = ___muldi3($1271 | 0, 0, $1268 | 0, 0) | 0;
      $1285 = tempRet0;
      $1286 = ___muldi3($1274 | 0, 0, $1268 | 0, 0) | 0;
      $1287 = tempRet0;
      _i64Add(_i64Add($1281 | 0, 0, $1282 | 0, 0) | 0, tempRet0 | 0, $1284 | 0, 0) | 0;
      $1290 = tempRet0;
      $1293 = _i64Add(_i64Add($1285 | 0, 0, $1283 | 0, 0) | 0, tempRet0 | 0, $1290 | 0, 0) | 0;
      $1294 = tempRet0;
      _i64Add($1293 | 0, $1294 | 0, $1286 | 0, 0) | 0;
      _i64Add(0, tempRet0 | 0, $1286 | 0, $1287 | 0) | 0;
      $1296 = tempRet0;
      $1297 = _i64Add($1293 | 0, $1294 | 0, $1286 | 0, $1287 | 0) | 0;
      $1299 = ($1268 | 0) < 0;
      $1300 = _i64Subtract(0, 0, $1265 | 0, $1268 | 0) | 0;
      $1303 = $1299 ? tempRet0 : 0;
      $1304 = ($1274 | 0) < 0;
      $1305 = _i64Subtract(0, 0, $1271 | 0, $1274 | 0) | 0;
      $1419 = _i64Add(_i64Add(($1304 ? $1305 : 0) | 0, ($1304 ? tempRet0 : 0) | 0, ($1299 ? $1300 : 0) | 0, $1303 | 0) | 0, tempRet0 | 0, $1297 | 0, $1296 | 0) | 0;
      $1422 = tempRet0;
      break L138;
      break;
     }
    case 2:
     {
      ___muldi3($1271 | 0, 0, $1265 | 0, 0) | 0;
      $1313 = tempRet0;
      $1314 = ___muldi3($1274 | 0, 0, $1265 | 0, 0) | 0;
      $1315 = tempRet0;
      $1316 = ___muldi3($1271 | 0, 0, $1268 | 0, 0) | 0;
      $1317 = tempRet0;
      $1318 = ___muldi3($1274 | 0, 0, $1268 | 0, 0) | 0;
      $1319 = tempRet0;
      _i64Add(_i64Add($1313 | 0, 0, $1314 | 0, 0) | 0, tempRet0 | 0, $1316 | 0, 0) | 0;
      $1322 = tempRet0;
      $1325 = _i64Add(_i64Add($1317 | 0, 0, $1315 | 0, 0) | 0, tempRet0 | 0, $1322 | 0, 0) | 0;
      $1326 = tempRet0;
      _i64Add($1325 | 0, $1326 | 0, $1318 | 0, 0) | 0;
      _i64Add(0, tempRet0 | 0, $1318 | 0, $1319 | 0) | 0;
      $1328 = tempRet0;
      $1331 = ($1268 | 0) < 0;
      $1419 = _i64Subtract(_i64Add($1325 | 0, $1326 | 0, $1318 | 0, $1319 | 0) | 0, $1328 | 0, ($1331 ? $1265 : 0) | 0, ($1331 ? $1268 : 0) | 0) | 0;
      $1422 = tempRet0;
      break L138;
      break;
     }
    case 4:
     {
      if (($1271 | 0) == 0 & ($1274 | 0) == 0) {
       $1419 = -1;
       $1422 = -1;
       break L138;
      }
      if (($1265 | 0) == -2147483648 & ($1268 | 0) == 0 & (($1271 | 0) == -1 & ($1274 | 0) == -1)) {
       $1419 = -2147483648;
       $1422 = 0;
       break L138;
      }
      $1419 = ___divdi3($1265 | 0, $1268 | 0, $1271 | 0, $1274 | 0) | 0;
      $1422 = tempRet0;
      break L138;
      break;
     }
    case 3:
     {
      ___muldi3($1271 | 0, 0, $1265 | 0, 0) | 0;
      $1336 = tempRet0;
      $1337 = ___muldi3($1274 | 0, 0, $1265 | 0, 0) | 0;
      $1338 = tempRet0;
      $1339 = ___muldi3($1271 | 0, 0, $1268 | 0, 0) | 0;
      $1340 = tempRet0;
      $1341 = ___muldi3($1274 | 0, 0, $1268 | 0, 0) | 0;
      $1342 = tempRet0;
      _i64Add(_i64Add($1336 | 0, 0, $1337 | 0, 0) | 0, tempRet0 | 0, $1339 | 0, 0) | 0;
      $1345 = tempRet0;
      $1348 = _i64Add(_i64Add($1340 | 0, 0, $1338 | 0, 0) | 0, tempRet0 | 0, $1345 | 0, 0) | 0;
      $1349 = tempRet0;
      _i64Add($1348 | 0, $1349 | 0, $1341 | 0, 0) | 0;
      _i64Add(0, tempRet0 | 0, $1341 | 0, $1342 | 0) | 0;
      $1351 = tempRet0;
      $1419 = _i64Add($1348 | 0, $1349 | 0, $1341 | 0, $1342 | 0) | 0;
      $1422 = $1351;
      break L138;
      break;
     }
    default:
     {
      label = 478;
      break L4;
     }
    } else {
     if ($shr904 & 95) {
      label = 478;
      break L4;
     }
     do switch ($91 >>> 12 & 7 | $91 >>> 27 & 8 | 0) {
     case 0:
      {
       $1419 = _i64Add($1271 | 0, $1274 | 0, $1265 | 0, $1268 | 0) | 0;
       $1422 = tempRet0;
       break L138;
       break;
      }
     case 8:
      {
       $1419 = _i64Subtract($1265 | 0, $1268 | 0, $1271 | 0, $1274 | 0) | 0;
       $1422 = tempRet0;
       break L138;
       break;
      }
     case 1:
      {
       $1419 = _bitshift64Shl($1265 | 0, $1268 | 0, $1271 & 63 | 0) | 0;
       $1422 = tempRet0;
       break L138;
       break;
      }
     case 2:
      {
       $1419 = (($1268 | 0) < ($1274 | 0) | ($1268 | 0) == ($1274 | 0) & $1265 >>> 0 < $1271 >>> 0) & 1;
       $1422 = 0;
       break L138;
       break;
      }
     case 4:
      {
       $1419 = $1271 ^ $1265;
       $1422 = $1274 ^ $1268;
       break L138;
       break;
      }
     case 5:
      {
       $1419 = _bitshift64Lshr($1265 | 0, $1268 | 0, $1271 & 63 | 0) | 0;
       $1422 = tempRet0;
       break L138;
       break;
      }
     case 13:
      {
       $1419 = _bitshift64Ashr($1265 | 0, $1268 | 0, $1271 & 63 | 0) | 0;
       $1422 = tempRet0;
       break L138;
       break;
      }
     case 6:
      {
       $1419 = $1271 | $1265;
       $1422 = $1274 | $1268;
       break L138;
       break;
      }
     case 7:
      {
       $1419 = $1271 & $1265;
       $1422 = $1274 & $1268;
       break L138;
       break;
      }
     case 3:
      {
       $1419 = ($1268 >>> 0 < $1274 >>> 0 | ($1268 | 0) == ($1274 | 0) & $1265 >>> 0 < $1271 >>> 0) & 1;
       $1422 = 0;
       break L138;
       break;
      }
     default:
      {
       label = 478;
       break L4;
      }
     } while (0);
    } while (0);
    if (!$and8) {
     $3000 = $89;
     $3003 = $90;
    } else {
     $1417 = $s + ($and8 << 3) + 8 | 0;
     HEAP32[$1417 >> 2] = $1419;
     HEAP32[$1417 + 4 >> 2] = $1422;
     $3000 = $89;
     $3003 = $90;
    }
    break;
   }
  case 59:
   {
    $shr978 = $91 >>> 25;
    $1423 = $s + ($and10 << 3) + 8 | 0;
    $1425 = HEAP32[$1423 >> 2] | 0;
    $1428 = HEAP32[$1423 + 4 >> 2] | 0;
    $1429 = $s + ($and12 << 3) + 8 | 0;
    $1431 = HEAP32[$1429 >> 2] | 0;
    $1434 = HEAP32[$1429 + 4 >> 2] | 0;
    $1435 = $val2;
    HEAP32[$1435 >> 2] = $1431;
    HEAP32[$1435 + 4 >> 2] = $1434;
    L171 : do if (($shr978 | 0) == 1) switch ($91 >>> 12 & 7 | 0) {
    case 6:
     {
      if (!$1431) $retval$0$i1449 = $1425; else if (($1425 | 0) == -2147483648 & ($1431 | 0) == -1) $retval$0$i1449 = 0; else $retval$0$i1449 = ($1425 | 0) % ($1431 | 0) | 0;
      $1457 = $retval$0$i1449;
      $1460 = 0;
      break L171;
      break;
     }
    case 7:
     {
      if (!$1431) $retval$0$i1444 = $1425; else $retval$0$i1444 = ($1425 >>> 0) % ($1431 >>> 0) | 0;
      $1457 = $retval$0$i1444;
      $1460 = 0;
      break L171;
      break;
     }
    case 0:
     {
      $mul991 = Math_imul($1431, $1425) | 0;
      $1457 = $mul991;
      $1460 = (($mul991 | 0) < 0) << 31 >> 31;
      break L171;
      break;
     }
    case 4:
     {
      if (!$1431) {
       $1457 = -1;
       $1460 = 0;
       break L171;
      }
      if (($1425 | 0) == -2147483648 & ($1431 | 0) == -1) {
       $1457 = -2147483648;
       $1460 = 0;
       break L171;
      }
      $1457 = ($1425 | 0) / ($1431 | 0) | 0;
      $1460 = 0;
      break L171;
      break;
     }
    case 5:
     {
      if (!$1431) {
       $1457 = -1;
       $1460 = 0;
       break L171;
      }
      $1457 = ($1425 >>> 0) / ($1431 >>> 0) | 0;
      $1460 = 0;
      break L171;
      break;
     }
    default:
     {
      label = 478;
      break L4;
     }
    } else {
     if ($shr978 & 95) {
      label = 478;
      break L4;
     }
     switch ($91 >>> 12 & 7 | $91 >>> 27 & 8 | 0) {
     case 0:
      {
       $1457 = _bitshift64Ashr(0, _i64Add($1431 | 0, $1434 | 0, $1425 | 0, $1428 | 0) | 0, 32) | 0;
       $1460 = tempRet0;
       break L171;
       break;
      }
     case 8:
      {
       $1457 = _bitshift64Ashr(0, _i64Subtract($1425 | 0, $1428 | 0, $1431 | 0, $1434 | 0) | 0, 32) | 0;
       $1460 = tempRet0;
       break L171;
       break;
      }
     case 1:
      {
       $shl1037 = $1425 << ($1431 & 31);
       $1457 = $shl1037;
       $1460 = (($shl1037 | 0) < 0) << 31 >> 31;
       break L171;
       break;
      }
     case 5:
      {
       $shr1043 = $1425 >>> ($1431 & 31);
       $1457 = $shr1043;
       $1460 = (($shr1043 | 0) < 0) << 31 >> 31;
       break L171;
       break;
      }
     case 13:
      {
       $shr1049 = $1425 >> ($1431 & 31);
       $1457 = $shr1049;
       $1460 = (($shr1049 | 0) < 0) << 31 >> 31;
       break L171;
       break;
      }
     default:
      {
       label = 478;
       break L4;
      }
     }
    } while (0);
    if (!$and8) {
     $3000 = $89;
     $3003 = $90;
    } else {
     $1455 = $s + ($and8 << 3) + 8 | 0;
     HEAP32[$1455 >> 2] = $1457;
     HEAP32[$1455 + 4 >> 2] = $1460;
     $3000 = $89;
     $3003 = $90;
    }
    break;
   }
  case 126:
  case 122:
  case 118:
  case 114:
  case 110:
  case 106:
  case 102:
  case 98:
  case 94:
  case 90:
  case 86:
  case 82:
  case 78:
  case 74:
  case 70:
  case 66:
  case 62:
  case 58:
  case 54:
  case 50:
  case 46:
  case 42:
  case 38:
  case 34:
  case 30:
  case 26:
  case 22:
  case 18:
  case 14:
  case 10:
  case 6:
  case 2:
   {
    $533 = _i64Add($87 | 0, $88 | 0, 2, 0) | 0;
    $534 = tempRet0;
    $shr397 = $91 >>> 2;
    $and398 = $shr397 & 31;
    switch ($91 >>> 13 & 7 | 0) {
    case 2:
     {
      $580 = $arrayidx;
      $586 = _i64Add(HEAP32[$580 >> 2] | 0, HEAP32[$580 + 4 >> 2] | 0, $shr & 32 | $shr397 & 28 | $91 << 4 & 192 | 0, 0) | 0;
      $587 = tempRet0;
      $conv$i1852 = (_bitshift64Lshr($586 | 0, $587 | 0, 12) | 0) & 255;
      $590 = $s + ($conv$i1852 << 4) + 1400 | 0;
      if ((HEAP32[$590 >> 2] | 0) == ($586 & -4065 | 0) ? (HEAP32[$590 + 4 >> 2] | 0) == ($587 | 0) : 0) $storemerge$i18652028$ph = HEAP32[(HEAP32[$s + ($conv$i1852 << 4) + 1408 >> 2] | 0) + $586 >> 2] | 0; else {
       if (_target_read_slow($s, $val$i1849, $586, $587, 2) | 0) break L4;
       $storemerge$i18652028$ph = HEAP32[$val$i1849 >> 2] | 0;
      }
      if (!$and8) {
       $3000 = $533;
       $3003 = $534;
       break L24;
      }
      $612 = $s + ($and8 << 3) + 8 | 0;
      HEAP32[$612 >> 2] = $storemerge$i18652028$ph;
      HEAP32[$612 + 4 >> 2] = (($storemerge$i18652028$ph | 0) < 0) << 31 >> 31;
      $3000 = $533;
      $3003 = $534;
      break L24;
      break;
     }
    case 4:
     {
      $cmp477 = ($and398 | 0) == 0;
      $cmp480 = ($and8 | 0) == 0;
      if (!($91 & 4096)) if ($cmp477) {
       if ($cmp480) {
        label = 478;
        break L4;
       }
       $649 = $s + ($and8 << 3) + 8 | 0;
       $3000 = HEAP32[$649 >> 2] & -2;
       $3003 = HEAP32[$649 + 4 >> 2] | 0;
       break L24;
      } else {
       if ($cmp480) {
        $3000 = $533;
        $3003 = $534;
        break L24;
       }
       $656 = $s + ($and398 << 3) + 8 | 0;
       $661 = HEAP32[$656 + 4 >> 2] | 0;
       $662 = $s + ($and8 << 3) + 8 | 0;
       HEAP32[$662 >> 2] = HEAP32[$656 >> 2];
       HEAP32[$662 + 4 >> 2] = $661;
       $3000 = $533;
       $3003 = $534;
       break L24;
      } else if ($cmp477) {
       if ($cmp480) {
        label = 97;
        break L4;
       }
       $666 = $arrayidx506;
       HEAP32[$666 >> 2] = $533;
       HEAP32[$666 + 4 >> 2] = $534;
       $670 = $s + ($and8 << 3) + 8 | 0;
       $3000 = HEAP32[$670 >> 2] & -2;
       $3003 = HEAP32[$670 + 4 >> 2] | 0;
       break L24;
      } else {
       if ($cmp480) {
        $3000 = $533;
        $3003 = $534;
        break L24;
       }
       $arrayidx516 = $s + ($and8 << 3) + 8 | 0;
       $677 = $arrayidx516;
       $683 = $s + ($and398 << 3) + 8 | 0;
       $689 = _i64Add(HEAP32[$683 >> 2] | 0, HEAP32[$683 + 4 >> 2] | 0, HEAP32[$677 >> 2] | 0, HEAP32[$677 + 4 >> 2] | 0) | 0;
       $691 = $arrayidx516;
       HEAP32[$691 >> 2] = $689;
       HEAP32[$691 + 4 >> 2] = tempRet0;
       $3000 = $533;
       $3003 = $534;
       break L24;
      }
      break;
     }
    case 3:
     {
      $616 = $arrayidx;
      $622 = _i64Add(HEAP32[$616 >> 2] | 0, HEAP32[$616 + 4 >> 2] | 0, $shr & 32 | $shr397 & 24 | $91 << 4 & 448 | 0, 0) | 0;
      $623 = tempRet0;
      $conv$i1825 = (_bitshift64Lshr($622 | 0, $623 | 0, 12) | 0) & 255;
      $626 = $s + ($conv$i1825 << 4) + 1400 | 0;
      if ((HEAP32[$626 >> 2] | 0) == ($622 & -4033 | 0) ? (HEAP32[$626 + 4 >> 2] | 0) == ($623 | 0) : 0) $storemerge$in$i1836 = (HEAP32[$s + ($conv$i1825 << 4) + 1408 >> 2] | 0) + $622 | 0; else if (!(_target_read_slow($s, $val$i1822, $622, $623, 3) | 0)) $storemerge$in$i1836 = $val$i1822; else break L4;
      $639 = $storemerge$in$i1836;
      $644 = HEAP32[$639 + 4 >> 2] | 0;
      if (!$and8) {
       $3000 = $533;
       $3003 = $534;
       break L24;
      }
      $645 = $s + ($and8 << 3) + 8 | 0;
      HEAP32[$645 >> 2] = HEAP32[$639 >> 2];
      HEAP32[$645 + 4 >> 2] = $644;
      $3000 = $533;
      $3003 = $534;
      break L24;
      break;
     }
    case 5:
     {
      $695 = $arrayidx;
      $701 = _i64Add(HEAP32[$695 >> 2] | 0, HEAP32[$695 + 4 >> 2] | 0, $shr & 56 | $91 >>> 1 & 448 | 0, 0) | 0;
      $702 = tempRet0;
      $703 = $s + ($and398 << 3) + 264 | 0;
      $705 = HEAP32[$703 >> 2] | 0;
      $708 = HEAP32[$703 + 4 >> 2] | 0;
      $conv$i1798 = (_bitshift64Lshr($701 | 0, $702 | 0, 12) | 0) & 255;
      $711 = $s + ($conv$i1798 << 4) + 5496 | 0;
      if ((HEAP32[$711 >> 2] | 0) == ($701 & -4033 | 0) ? (HEAP32[$711 + 4 >> 2] | 0) == ($702 | 0) : 0) {
       $723 = (HEAP32[$s + ($conv$i1798 << 4) + 5504 >> 2] | 0) + $701 | 0;
       HEAP32[$723 >> 2] = $705;
       HEAP32[$723 + 4 >> 2] = $708;
       $3000 = $533;
       $3003 = $534;
       break L24;
      } else if (!(_target_write_slow($s, $701, $702, $705, $708, 3) | 0)) {
       $3000 = $533;
       $3003 = $534;
       break L24;
      } else break L4;
      break;
     }
    case 0:
     {
      if (!$and8) {
       $3000 = $533;
       $3003 = $534;
       break L24;
      }
      $arrayidx406 = $s + ($and8 << 3) + 8 | 0;
      $535 = $arrayidx406;
      $543 = $arrayidx406;
      HEAP32[$543 >> 2] = _bitshift64Shl(HEAP32[$535 >> 2] | 0, HEAP32[$535 + 4 >> 2] | 0, $shr & 32 | $and398 | 0) | 0;
      HEAP32[$543 + 4 >> 2] = tempRet0;
      $3000 = $533;
      $3003 = $534;
      break L24;
      break;
     }
    case 6:
     {
      $728 = $arrayidx;
      $734 = _i64Add(HEAP32[$728 >> 2] | 0, HEAP32[$728 + 4 >> 2] | 0, $shr & 60 | $91 >>> 1 & 192 | 0, 0) | 0;
      $735 = tempRet0;
      $738 = HEAP32[$s + ($and398 << 3) + 8 >> 2] | 0;
      $conv$i1775 = (_bitshift64Lshr($734 | 0, $735 | 0, 12) | 0) & 255;
      $744 = $s + ($conv$i1775 << 4) + 5496 | 0;
      if ((HEAP32[$744 >> 2] | 0) == ($734 & -4065 | 0) ? (HEAP32[$744 + 4 >> 2] | 0) == ($735 | 0) : 0) {
       HEAP32[(HEAP32[$s + ($conv$i1775 << 4) + 5504 >> 2] | 0) + $734 >> 2] = $738;
       $3000 = $533;
       $3003 = $534;
       break L24;
      } else if (!(_target_write_slow($s, $734, $735, $738, 0, 2) | 0)) {
       $3000 = $533;
       $3003 = $534;
       break L24;
      } else break L4;
      break;
     }
    case 7:
     {
      $757 = $arrayidx;
      $763 = _i64Add(HEAP32[$757 >> 2] | 0, HEAP32[$757 + 4 >> 2] | 0, $shr & 56 | $91 >>> 1 & 448 | 0, 0) | 0;
      $764 = tempRet0;
      $765 = $s + ($and398 << 3) + 8 | 0;
      $767 = HEAP32[$765 >> 2] | 0;
      $770 = HEAP32[$765 + 4 >> 2] | 0;
      $conv$i1752 = (_bitshift64Lshr($763 | 0, $764 | 0, 12) | 0) & 255;
      $773 = $s + ($conv$i1752 << 4) + 5496 | 0;
      if ((HEAP32[$773 >> 2] | 0) == ($763 & -4033 | 0) ? (HEAP32[$773 + 4 >> 2] | 0) == ($764 | 0) : 0) {
       $785 = (HEAP32[$s + ($conv$i1752 << 4) + 5504 >> 2] | 0) + $763 | 0;
       HEAP32[$785 >> 2] = $767;
       HEAP32[$785 + 4 >> 2] = $770;
       $3000 = $533;
       $3003 = $534;
       break L24;
      } else if (!(_target_write_slow($s, $763, $764, $767, $770, 3) | 0)) {
       $3000 = $533;
       $3003 = $534;
       break L24;
      } else break L4;
      break;
     }
    case 1:
     {
      $547 = $arrayidx;
      $553 = _i64Add(HEAP32[$547 >> 2] | 0, HEAP32[$547 + 4 >> 2] | 0, $shr & 32 | $shr397 & 24 | $91 << 4 & 448 | 0, 0) | 0;
      $554 = tempRet0;
      $conv$i1881 = (_bitshift64Lshr($553 | 0, $554 | 0, 12) | 0) & 255;
      $557 = $s + ($conv$i1881 << 4) + 1400 | 0;
      if ((HEAP32[$557 >> 2] | 0) == ($553 & -4033 | 0) ? (HEAP32[$557 + 4 >> 2] | 0) == ($554 | 0) : 0) $storemerge$in$i1892 = (HEAP32[$s + ($conv$i1881 << 4) + 1408 >> 2] | 0) + $553 | 0; else if (!(_target_read_slow($s, $val$i1878, $553, $554, 3) | 0)) $storemerge$in$i1892 = $val$i1878; else break L4;
      $570 = $storemerge$in$i1892;
      $575 = HEAP32[$570 + 4 >> 2] | 0;
      $576 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$576 >> 2] = HEAP32[$570 >> 2];
      HEAP32[$576 + 4 >> 2] = $575;
      $3000 = $533;
      $3003 = $534;
      break L24;
      break;
     }
    default:
     {
      label = 478;
      break L4;
     }
    }
    break;
   }
  case 125:
  case 121:
  case 117:
  case 113:
  case 109:
  case 105:
  case 101:
  case 97:
  case 93:
  case 89:
  case 85:
  case 81:
  case 77:
  case 73:
  case 69:
  case 65:
  case 61:
  case 57:
  case 53:
  case 49:
  case 45:
  case 41:
  case 37:
  case 33:
  case 29:
  case 25:
  case 21:
  case 17:
  case 13:
  case 9:
  case 5:
  case 1:
   {
    $303 = _i64Add($87 | 0, $88 | 0, 2, 0) | 0;
    $304 = tempRet0;
    switch ($91 >>> 13 & 7 | 0) {
    case 2:
     {
      if (!$and8) {
       $3000 = $303;
       $3003 = $304;
       break L24;
      }
      $shr$i1658 = ($shr & 32 | $91 >>> 2 & 31) << 26 >> 26;
      $335 = $s + ($and8 << 3) + 8 | 0;
      HEAP32[$335 >> 2] = $shr$i1658;
      HEAP32[$335 + 4 >> 2] = (($shr$i1658 | 0) < 0) << 31 >> 31;
      $3000 = $303;
      $3003 = $304;
      break L24;
      break;
     }
    case 1:
     {
      if (!$and8) {
       $3000 = $303;
       $3003 = $304;
       break L24;
      }
      $arrayidx171 = $s + ($and8 << 3) + 8 | 0;
      $319 = $arrayidx171;
      $329 = $arrayidx171;
      HEAP32[$329 >> 2] = _bitshift64Ashr(0, _i64Add(HEAP32[$319 >> 2] | 0, HEAP32[$319 + 4 >> 2] | 0, ($shr & 32 | $91 >>> 2 & 31) << 26 >> 26 | 0, 0) | 0, 32) | 0;
      HEAP32[$329 + 4 >> 2] = tempRet0;
      $3000 = $303;
      $3003 = $304;
      break L24;
      break;
     }
    case 3:
     {
      if (!$and8) {
       $3000 = $303;
       $3003 = $304;
       break L24;
      } else if (($and8 | 0) != 2) {
       $shr$i1842 = ($91 << 19 & -2147483648 | $91 << 24 & 2080374784) >> 14;
       $355 = $s + ($and8 << 3) + 8 | 0;
       HEAP32[$355 >> 2] = $shr$i1842;
       HEAP32[$355 + 4 >> 2] = (($shr$i1842 | 0) < 0) << 31 >> 31;
       $3000 = $303;
       $3003 = $304;
       break L24;
      }
      $shr$i1789 = ($91 >>> 3 & 512 | $91 >>> 2 & 16 | $91 << 1 & 64 | $91 << 4 & 384 | $91 << 3 & 32) << 22 >> 22;
      if (!$shr$i1789) {
       label = 478;
       break L4;
      }
      $339 = $arrayidx;
      $349 = $arrayidx;
      HEAP32[$349 >> 2] = _i64Add(HEAP32[$339 >> 2] | 0, HEAP32[$339 + 4 >> 2] | 0, $shr$i1789 | 0, (($shr$i1789 | 0) < 0) << 31 >> 31 | 0) | 0;
      HEAP32[$349 + 4 >> 2] = tempRet0;
      $3000 = $303;
      $3003 = $304;
      break L24;
      break;
     }
    case 4:
     {
      $shr228 = $91 >>> 10;
      $and229 = $shr228 & 3;
      $or232 = $shr & 7 | 8;
      if (($and229 | 0) == 2) {
       $shr$i1970 = ($shr & 32 | $91 >>> 2 & 31) << 26 >> 26;
       $arrayidx260 = $s + ($or232 << 3) + 8 | 0;
       $379 = $arrayidx260;
       $386 = HEAP32[$379 + 4 >> 2] & (($shr$i1970 | 0) < 0) << 31 >> 31;
       $387 = $arrayidx260;
       HEAP32[$387 >> 2] = HEAP32[$379 >> 2] & $shr$i1970;
       HEAP32[$387 + 4 >> 2] = $386;
       $3000 = $303;
       $3003 = $304;
       break L24;
      } else if (($and229 | 0) == 3) {
       $or265 = $91 >>> 2 & 7 | 8;
       switch ($91 >>> 5 & 3 | $shr228 & 4 | 0) {
       case 0:
        {
         $arrayidx273 = $s + ($or232 << 3) + 8 | 0;
         $391 = $arrayidx273;
         $397 = $s + ($or265 << 3) + 8 | 0;
         $405 = $arrayidx273;
         HEAP32[$405 >> 2] = _i64Subtract(HEAP32[$391 >> 2] | 0, HEAP32[$391 + 4 >> 2] | 0, HEAP32[$397 >> 2] | 0, HEAP32[$397 + 4 >> 2] | 0) | 0;
         HEAP32[$405 + 4 >> 2] = tempRet0;
         $3000 = $303;
         $3003 = $304;
         break L24;
         break;
        }
       case 1:
        {
         $arrayidx280 = $s + ($or232 << 3) + 8 | 0;
         $409 = $arrayidx280;
         $415 = $s + ($or265 << 3) + 8 | 0;
         $422 = HEAP32[$415 + 4 >> 2] ^ HEAP32[$409 + 4 >> 2];
         $423 = $arrayidx280;
         HEAP32[$423 >> 2] = HEAP32[$415 >> 2] ^ HEAP32[$409 >> 2];
         HEAP32[$423 + 4 >> 2] = $422;
         $3000 = $303;
         $3003 = $304;
         break L24;
         break;
        }
       case 2:
        {
         $arrayidx287 = $s + ($or232 << 3) + 8 | 0;
         $427 = $arrayidx287;
         $433 = $s + ($or265 << 3) + 8 | 0;
         $440 = HEAP32[$433 + 4 >> 2] | HEAP32[$427 + 4 >> 2];
         $441 = $arrayidx287;
         HEAP32[$441 >> 2] = HEAP32[$433 >> 2] | HEAP32[$427 >> 2];
         HEAP32[$441 + 4 >> 2] = $440;
         $3000 = $303;
         $3003 = $304;
         break L24;
         break;
        }
       case 3:
        {
         $arrayidx295 = $s + ($or232 << 3) + 8 | 0;
         $445 = $arrayidx295;
         $451 = $s + ($or265 << 3) + 8 | 0;
         $458 = HEAP32[$451 + 4 >> 2] & HEAP32[$445 + 4 >> 2];
         $459 = $arrayidx295;
         HEAP32[$459 >> 2] = HEAP32[$451 >> 2] & HEAP32[$445 >> 2];
         HEAP32[$459 + 4 >> 2] = $458;
         $3000 = $303;
         $3003 = $304;
         break L24;
         break;
        }
       case 4:
        {
         $arrayidx303 = $s + ($or232 << 3) + 8 | 0;
         $463 = $arrayidx303;
         $469 = $s + ($or265 << 3) + 8 | 0;
         $479 = $arrayidx303;
         HEAP32[$479 >> 2] = _bitshift64Ashr(0, _i64Subtract(HEAP32[$463 >> 2] | 0, HEAP32[$463 + 4 >> 2] | 0, HEAP32[$469 >> 2] | 0, HEAP32[$469 + 4 >> 2] | 0) | 0, 32) | 0;
         HEAP32[$479 + 4 >> 2] = tempRet0;
         $3000 = $303;
         $3003 = $304;
         break L24;
         break;
        }
       case 5:
        {
         $arrayidx313 = $s + ($or232 << 3) + 8 | 0;
         $483 = $arrayidx313;
         $489 = $s + ($or265 << 3) + 8 | 0;
         $499 = $arrayidx313;
         HEAP32[$499 >> 2] = _bitshift64Ashr(0, _i64Add(HEAP32[$489 >> 2] | 0, HEAP32[$489 + 4 >> 2] | 0, HEAP32[$483 >> 2] | 0, HEAP32[$483 + 4 >> 2] | 0) | 0, 32) | 0;
         HEAP32[$499 + 4 >> 2] = tempRet0;
         $3000 = $303;
         $3003 = $304;
         break L24;
         break;
        }
       default:
        {
         label = 478;
         break L4;
        }
       }
      } else if (($and229 | 0) == 1 | ($and229 | 0) == 0) {
       $or236 = $shr & 32 | $91 >>> 2 & 31;
       $arrayidx241 = $s + ($or232 << 3) + 8 | 0;
       $359 = $arrayidx241;
       $361 = HEAP32[$359 >> 2] | 0;
       $364 = HEAP32[$359 + 4 >> 2] | 0;
       if (!$and229) {
        $365 = _bitshift64Lshr($361 | 0, $364 | 0, $or236 | 0) | 0;
        $367 = $arrayidx241;
        HEAP32[$367 >> 2] = $365;
        HEAP32[$367 + 4 >> 2] = tempRet0;
        $3000 = $303;
        $3003 = $304;
        break L24;
       } else {
        $371 = _bitshift64Ashr($361 | 0, $364 | 0, $or236 | 0) | 0;
        $373 = $arrayidx241;
        HEAP32[$373 >> 2] = $371;
        HEAP32[$373 + 4 >> 2] = tempRet0;
        $3000 = $303;
        $3003 = $304;
        break L24;
       }
      } else {
       $3000 = $303;
       $3003 = $304;
       break L24;
      }
      break;
     }
    case 5:
     {
      $shr$i1966 = $91 >>> 1;
      $shr$i1944 = ($shr$i1966 & 2048 | $shr & 16 | $shr$i1966 & 768 | $91 << 2 & 1024 | $shr$i1966 & 64 | $91 << 1 & 128 | $91 >>> 2 & 14 | $91 << 3 & 32) << 20 >> 20;
      $3000 = _i64Add($shr$i1944 | 0, (($shr$i1944 | 0) < 0) << 31 >> 31 | 0, $87 | 0, $88 | 0) | 0;
      $3003 = tempRet0;
      break L24;
      break;
     }
    case 6:
     {
      $507 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      if (!((HEAP32[$507 >> 2] | 0) == 0 & (HEAP32[$507 + 4 >> 2] | 0) == 0)) {
       $3000 = $303;
       $3003 = $304;
       break L24;
      }
      $shr$i1927 = ($91 >>> 4 & 256 | $shr & 24 | $91 << 1 & 192 | $91 >>> 2 & 6 | $91 << 3 & 32) << 23 >> 23;
      $3000 = _i64Add($shr$i1927 | 0, (($shr$i1927 | 0) < 0) << 31 >> 31 | 0, $87 | 0, $88 | 0) | 0;
      $3003 = tempRet0;
      break L24;
      break;
     }
    case 7:
     {
      $520 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      if ((HEAP32[$520 >> 2] | 0) == 0 & (HEAP32[$520 + 4 >> 2] | 0) == 0) {
       $3000 = $303;
       $3003 = $304;
       break L24;
      }
      $shr$i1910 = ($91 >>> 4 & 256 | $shr & 24 | $91 << 1 & 192 | $91 >>> 2 & 6 | $91 << 3 & 32) << 23 >> 23;
      $3000 = _i64Add($shr$i1910 | 0, (($shr$i1910 | 0) < 0) << 31 >> 31 | 0, $87 | 0, $88 | 0) | 0;
      $3003 = tempRet0;
      break L24;
      break;
     }
    case 0:
     {
      if (!$and8) {
       $3000 = $303;
       $3003 = $304;
       break L24;
      }
      $shr$i1541 = ($shr & 32 | $91 >>> 2 & 31) << 26 >> 26;
      $arrayidx156 = $s + ($and8 << 3) + 8 | 0;
      $305 = $arrayidx156;
      $315 = $arrayidx156;
      HEAP32[$315 >> 2] = _i64Add(HEAP32[$305 >> 2] | 0, HEAP32[$305 + 4 >> 2] | 0, $shr$i1541 | 0, (($shr$i1541 | 0) < 0) << 31 >> 31 | 0) | 0;
      HEAP32[$315 + 4 >> 2] = tempRet0;
      $3000 = $303;
      $3003 = $304;
      break L24;
      break;
     }
    default:
     {
      label = 478;
      break L4;
     }
    }
    break;
   }
  case 115:
   {
    $shr1061 = $91 >>> 12;
    if (!($shr1061 & 4)) {
     $1461 = $s + ($and10 << 3) + 8 | 0;
     $1467 = HEAP32[$1461 >> 2] | 0;
     $1468 = HEAP32[$1461 + 4 >> 2] | 0;
    } else {
     $1467 = $and10;
     $1468 = 0;
    }
    $and1072 = $shr1061 & 3;
    if (($and1072 | 0) == 1) {
     if (_csr_read($s, $val2, $shr11, 1) | 0) {
      label = 478;
      break L4;
     }
     $1469 = _csr_write($s, $shr11, $1467, $1468) | 0;
     if (($1469 | 0) < 0) {
      label = 478;
      break L4;
     }
     if ($and8) {
      $1470 = $val2;
      $1475 = HEAP32[$1470 + 4 >> 2] | 0;
      $1476 = $s + ($and8 << 3) + 8 | 0;
      HEAP32[$1476 >> 2] = HEAP32[$1470 >> 2];
      HEAP32[$1476 + 4 >> 2] = $1475;
     }
     if (($1469 | 0) > 0) {
      label = 264;
      break L4;
     } else {
      $3000 = $89;
      $3003 = $90;
      break L24;
     }
    } else if (($and1072 | 0) == 3 | ($and1072 | 0) == 2) {
     $cmp1095 = ($and10 | 0) != 0;
     if (_csr_read($s, $val2, $shr11, $cmp1095 & 1) | 0) {
      label = 478;
      break L4;
     }
     $1484 = $val2;
     $1486 = HEAP32[$1484 >> 2] | 0;
     $1489 = HEAP32[$1484 + 4 >> 2] | 0;
     if ($cmp1095) {
      if (($and1072 | 0) == 2) {
       $1496 = $1486 | $1467;
       $1497 = $1489 | $1468;
      } else {
       $1496 = $1486 & ~$1467;
       $1497 = $1489 & ~$1468;
      }
      $1498 = _csr_write($s, $shr11, $1496, $1497) | 0;
      if (($1498 | 0) < 0) {
       label = 478;
       break L4;
      } else $err$0 = $1498;
     } else $err$0 = 0;
     if ($and8) {
      $1499 = $val2;
      $1504 = HEAP32[$1499 + 4 >> 2] | 0;
      $1505 = $s + ($and8 << 3) + 8 | 0;
      HEAP32[$1505 >> 2] = HEAP32[$1499 >> 2];
      HEAP32[$1505 + 4 >> 2] = $1504;
     }
     if (($err$0 | 0) > 0) {
      label = 274;
      break L4;
     } else {
      $3000 = $89;
      $3003 = $90;
      break L24;
     }
    } else if (!$and1072) {
     switch ($shr11 | 0) {
     case 261:
      {
       if ($91 & 32640) {
        label = 478;
        break L4;
       }
       $1643 = $mip;
       $1649 = $mie;
       if ((HEAP32[$1649 >> 2] & HEAP32[$1643 >> 2] | 0) == 0 ? (HEAP32[$1649 + 4 >> 2] & HEAP32[$1643 + 4 >> 2] | 0) == 0 : 0) {
        label = 299;
        break L4;
       } else {
        $3000 = $89;
        $3003 = $90;
        break L24;
       }
       break;
      }
     case 0:
      {
       label = 276;
       break L4;
       break;
      }
     case 1:
      {
       label = 278;
       break L4;
       break;
      }
     case 258:
      {
       label = 280;
       break L4;
       break;
      }
     case 770:
      {
       label = 286;
       break L4;
       break;
      }
     case 260:
      break;
     default:
      {
       label = 478;
       break L4;
      }
     }
     if ($91 & 32640) {
      label = 478;
      break L4;
     }
     if (!(HEAP8[$priv1169 >> 0] | 0)) {
      label = 478;
      break L4;
     }
     if (!$and10) {
      $i$07$i$i = 0;
      do {
       $1619 = $s + ($i$07$i$i << 4) + 1400 | 0;
       HEAP32[$1619 >> 2] = -1;
       HEAP32[$1619 + 4 >> 2] = -1;
       $1623 = $s + ($i$07$i$i << 4) + 5496 | 0;
       HEAP32[$1623 >> 2] = -1;
       HEAP32[$1623 + 4 >> 2] = -1;
       $1627 = $s + ($i$07$i$i << 4) + 9592 | 0;
       HEAP32[$1627 >> 2] = -1;
       HEAP32[$1627 + 4 >> 2] = -1;
       $i$07$i$i = $i$07$i$i + 1 | 0;
      } while (($i$07$i$i | 0) != 256);
      $3000 = $89;
      $3003 = $90;
     } else {
      $i$07$i$i$i = 0;
      do {
       $1631 = $s + ($i$07$i$i$i << 4) + 1400 | 0;
       HEAP32[$1631 >> 2] = -1;
       HEAP32[$1631 + 4 >> 2] = -1;
       $1635 = $s + ($i$07$i$i$i << 4) + 5496 | 0;
       HEAP32[$1635 >> 2] = -1;
       HEAP32[$1635 + 4 >> 2] = -1;
       $1639 = $s + ($i$07$i$i$i << 4) + 9592 | 0;
       HEAP32[$1639 >> 2] = -1;
       HEAP32[$1639 + 4 >> 2] = -1;
       $i$07$i$i$i = $i$07$i$i$i + 1 | 0;
      } while (($i$07$i$i$i | 0) != 256);
      $3000 = $89;
      $3003 = $90;
     }
    } else {
     label = 478;
     break L4;
    }
    break;
   }
  case 47:
   {
    $and1216 = $91 >>> 12 & 7;
    L317 : do if (($and1216 | 0) == 3) {
     $1820 = $s + ($and10 << 3) + 8 | 0;
     $1822 = HEAP32[$1820 >> 2] | 0;
     $1825 = HEAP32[$1820 + 4 >> 2] | 0;
     $shr1319 = $91 >>> 27;
     switch ($shr1319 | 0) {
     case 2:
      {
       if ($and12) {
        label = 478;
        break L4;
       }
       $conv$i1194 = (_bitshift64Lshr($1822 | 0, $1825 | 0, 12) | 0) & 255;
       $1828 = $s + ($conv$i1194 << 4) + 1400 | 0;
       if ((HEAP32[$1828 >> 2] | 0) == ($1822 & -4033 | 0) ? (HEAP32[$1828 + 4 >> 2] | 0) == ($1825 | 0) : 0) $storemerge$in$i1205 = (HEAP32[$s + ($conv$i1194 << 4) + 1408 >> 2] | 0) + $1822 | 0; else if (!(_target_read_slow($s, $val$i1191, $1822, $1825, 3) | 0)) $storemerge$in$i1205 = $val$i1191; else break L4;
       $1841 = $storemerge$in$i1205;
       $1843 = HEAP32[$1841 >> 2] | 0;
       $1846 = HEAP32[$1841 + 4 >> 2] | 0;
       $1847 = $load_res;
       HEAP32[$1847 >> 2] = $1822;
       HEAP32[$1847 + 4 >> 2] = $1825;
       $1996 = $1843;
       $1999 = $1846;
       break L317;
       break;
      }
     case 3:
      {
       $1851 = $load_res;
       if (!((HEAP32[$1851 >> 2] | 0) == ($1822 | 0) ? (HEAP32[$1851 + 4 >> 2] | 0) == ($1825 | 0) : 0)) {
        $1996 = 1;
        $1999 = 0;
        break L317;
       }
       $1860 = $s + ($and12 << 3) + 8 | 0;
       $1862 = HEAP32[$1860 >> 2] | 0;
       $1865 = HEAP32[$1860 + 4 >> 2] | 0;
       $conv$i1176 = (_bitshift64Lshr($1822 | 0, $1825 | 0, 12) | 0) & 255;
       $1868 = $s + ($conv$i1176 << 4) + 5496 | 0;
       if ((HEAP32[$1868 >> 2] | 0) == ($1822 & -4033 | 0) ? (HEAP32[$1868 + 4 >> 2] | 0) == ($1825 | 0) : 0) {
        $1880 = (HEAP32[$s + ($conv$i1176 << 4) + 5504 >> 2] | 0) + $1822 | 0;
        HEAP32[$1880 >> 2] = $1862;
        HEAP32[$1880 + 4 >> 2] = $1865;
        $1996 = 0;
        $1999 = 0;
        break L317;
       } else if (!(_target_write_slow($s, $1822, $1825, $1862, $1865, 3) | 0)) {
        $1996 = 0;
        $1999 = 0;
        break L317;
       } else break L4;
       break;
      }
     case 28:
     case 24:
     case 20:
     case 16:
     case 8:
     case 12:
     case 4:
     case 0:
     case 1:
      {
       $conv$i1155 = (_bitshift64Lshr($1822 | 0, $1825 | 0, 12) | 0) & 255;
       $1887 = $s + ($conv$i1155 << 4) + 1400 | 0;
       $1893 = $1822 & -4033;
       if ((HEAP32[$1887 >> 2] | 0) == ($1893 | 0) ? (HEAP32[$1887 + 4 >> 2] | 0) == ($1825 | 0) : 0) $storemerge$in$i1166 = (HEAP32[$s + ($conv$i1155 << 4) + 1408 >> 2] | 0) + $1822 | 0; else if (!(_target_read_slow($s, $val$i1152, $1822, $1825, 3) | 0)) $storemerge$in$i1166 = $val$i1152; else break L4;
       $1900 = $storemerge$in$i1166;
       $1902 = HEAP32[$1900 >> 2] | 0;
       $1905 = HEAP32[$1900 + 4 >> 2] | 0;
       $1906 = $s + ($and12 << 3) + 8 | 0;
       $1908 = HEAP32[$1906 >> 2] | 0;
       $1911 = HEAP32[$1906 + 4 >> 2] | 0;
       $1912 = $val2;
       HEAP32[$1912 >> 2] = $1908;
       HEAP32[$1912 + 4 >> 2] = $1911;
       switch ($shr1319 | 0) {
       case 20:
        {
         if (($1905 | 0) > ($1911 | 0) | ($1905 | 0) == ($1911 | 0) & $1902 >>> 0 > $1908 >>> 0) {
          $1954 = $val2;
          HEAP32[$1954 >> 2] = $1902;
          HEAP32[$1954 + 4 >> 2] = $1905;
          $1989 = $1902;
          $1992 = $1905;
         } else {
          $1989 = $1908;
          $1992 = $1911;
         }
         break;
        }
       case 24:
        {
         if ($1905 >>> 0 < $1911 >>> 0 | ($1905 | 0) == ($1911 | 0) & $1902 >>> 0 < $1908 >>> 0) {
          $1963 = $val2;
          HEAP32[$1963 >> 2] = $1902;
          HEAP32[$1963 + 4 >> 2] = $1905;
          $1989 = $1902;
          $1992 = $1905;
         } else {
          $1989 = $1908;
          $1992 = $1911;
         }
         break;
        }
       case 0:
        {
         $1916 = _i64Add($1908 | 0, $1911 | 0, $1902 | 0, $1905 | 0) | 0;
         $1917 = tempRet0;
         $1918 = $val2;
         HEAP32[$1918 >> 2] = $1916;
         HEAP32[$1918 + 4 >> 2] = $1917;
         $1989 = $1916;
         $1992 = $1917;
         break;
        }
       case 4:
        {
         $1922 = $1908 ^ $1902;
         $1923 = $1911 ^ $1905;
         $1924 = $val2;
         HEAP32[$1924 >> 2] = $1922;
         HEAP32[$1924 + 4 >> 2] = $1923;
         $1989 = $1922;
         $1992 = $1923;
         break;
        }
       case 12:
        {
         $1928 = $1908 & $1902;
         $1929 = $1911 & $1905;
         $1930 = $val2;
         HEAP32[$1930 >> 2] = $1928;
         HEAP32[$1930 + 4 >> 2] = $1929;
         $1989 = $1928;
         $1992 = $1929;
         break;
        }
       case 8:
        {
         $1934 = $1908 | $1902;
         $1935 = $1911 | $1905;
         $1936 = $val2;
         HEAP32[$1936 >> 2] = $1934;
         HEAP32[$1936 + 4 >> 2] = $1935;
         $1989 = $1934;
         $1992 = $1935;
         break;
        }
       case 16:
        {
         if (($1905 | 0) < ($1911 | 0) | ($1905 | 0) == ($1911 | 0) & $1902 >>> 0 < $1908 >>> 0) {
          $1945 = $val2;
          HEAP32[$1945 >> 2] = $1902;
          HEAP32[$1945 + 4 >> 2] = $1905;
          $1989 = $1902;
          $1992 = $1905;
         } else {
          $1989 = $1908;
          $1992 = $1911;
         }
         break;
        }
       case 1:
        {
         $1989 = $1908;
         $1992 = $1911;
         break;
        }
       case 28:
        {
         if ($1905 >>> 0 > $1911 >>> 0 | ($1905 | 0) == ($1911 | 0) & $1902 >>> 0 > $1908 >>> 0) {
          $1972 = $val2;
          HEAP32[$1972 >> 2] = $1902;
          HEAP32[$1972 + 4 >> 2] = $1905;
          $1989 = $1902;
          $1992 = $1905;
         } else {
          $1989 = $1908;
          $1992 = $1911;
         }
         break;
        }
       default:
        {
         label = 478;
         break L4;
        }
       }
       $1976 = $s + ($conv$i1155 << 4) + 5496 | 0;
       if ((HEAP32[$1976 >> 2] | 0) == ($1893 | 0) ? (HEAP32[$1976 + 4 >> 2] | 0) == ($1825 | 0) : 0) {
        $1987 = (HEAP32[$s + ($conv$i1155 << 4) + 5504 >> 2] | 0) + $1822 | 0;
        HEAP32[$1987 >> 2] = $1989;
        HEAP32[$1987 + 4 >> 2] = $1992;
        $1996 = $1902;
        $1999 = $1905;
        break L317;
       } else if (!(_target_write_slow($s, $1822, $1825, $1989, $1992, 3) | 0)) {
        $1996 = $1902;
        $1999 = $1905;
        break L317;
       } else break L4;
       break;
      }
     default:
      {
       label = 478;
       break L4;
      }
     }
    } else if (($and1216 | 0) == 2) {
     $1664 = $s + ($and10 << 3) + 8 | 0;
     $1666 = HEAP32[$1664 >> 2] | 0;
     $1669 = HEAP32[$1664 + 4 >> 2] | 0;
     $shr1221 = $91 >>> 27;
     switch ($shr1221 | 0) {
     case 3:
      {
       $1698 = $load_res;
       if (!((HEAP32[$1698 >> 2] | 0) == ($1666 | 0) ? (HEAP32[$1698 + 4 >> 2] | 0) == ($1669 | 0) : 0)) {
        $1996 = 1;
        $1999 = 0;
        break L317;
       }
       $1709 = HEAP32[$s + ($and12 << 3) + 8 >> 2] | 0;
       $conv$i1295 = (_bitshift64Lshr($1666 | 0, $1669 | 0, 12) | 0) & 255;
       $1715 = $s + ($conv$i1295 << 4) + 5496 | 0;
       if ((HEAP32[$1715 >> 2] | 0) == ($1666 & -4065 | 0) ? (HEAP32[$1715 + 4 >> 2] | 0) == ($1669 | 0) : 0) {
        HEAP32[(HEAP32[$s + ($conv$i1295 << 4) + 5504 >> 2] | 0) + $1666 >> 2] = $1709;
        $1996 = 0;
        $1999 = 0;
        break L317;
       } else if (!(_target_write_slow($s, $1666, $1669, $1709, 0, 2) | 0)) {
        $1996 = 0;
        $1999 = 0;
        break L317;
       } else break L4;
       break;
      }
     case 28:
     case 24:
     case 20:
     case 16:
     case 8:
     case 12:
     case 4:
     case 0:
     case 1:
      {
       $conv$i1254 = (_bitshift64Lshr($1666 | 0, $1669 | 0, 12) | 0) & 255;
       $1730 = $s + ($conv$i1254 << 4) + 1400 | 0;
       $1736 = $1666 & -4065;
       if ((HEAP32[$1730 >> 2] | 0) == ($1736 | 0) ? (HEAP32[$1730 + 4 >> 2] | 0) == ($1669 | 0) : 0) $storemerge$i13271994$ph = HEAP32[(HEAP32[$s + ($conv$i1254 << 4) + 1408 >> 2] | 0) + $1666 >> 2] | 0; else {
        if (_target_read_slow($s, $val$i1251, $1666, $1669, 2) | 0) break L4;
        $storemerge$i13271994$ph = HEAP32[$val$i1251 >> 2] | 0;
       }
       $1751 = (($storemerge$i13271994$ph | 0) < 0) << 31 >> 31;
       $1752 = $s + ($and12 << 3) + 8 | 0;
       $1754 = HEAP32[$1752 >> 2] | 0;
       $1757 = HEAP32[$1752 + 4 >> 2] | 0;
       $1758 = $val2;
       HEAP32[$1758 >> 2] = $1754;
       HEAP32[$1758 + 4 >> 2] = $1757;
       switch ($shr1221 | 0) {
       case 0:
        {
         $1764 = _bitshift64Ashr(0, _i64Add($1754 | 0, $1757 | 0, $storemerge$i13271994$ph | 0, $1751 | 0) | 0, 32) | 0;
         $1765 = tempRet0;
         $1766 = $val2;
         HEAP32[$1766 >> 2] = $1764;
         HEAP32[$1766 + 4 >> 2] = $1765;
         $1818 = $1764;
         $3016 = $1765;
         break;
        }
       case 24:
        {
         if ($storemerge$i13271994$ph >>> 0 < $1754 >>> 0) {
          $1799 = $val2;
          HEAP32[$1799 >> 2] = $storemerge$i13271994$ph;
          HEAP32[$1799 + 4 >> 2] = $1751;
          $1818 = $storemerge$i13271994$ph;
          $3016 = $1751;
         } else {
          $1818 = $1754;
          $3016 = $1757;
         }
         break;
        }
       case 28:
        {
         if ($storemerge$i13271994$ph >>> 0 > $1754 >>> 0) {
          $1803 = $val2;
          HEAP32[$1803 >> 2] = $storemerge$i13271994$ph;
          HEAP32[$1803 + 4 >> 2] = $1751;
          $1818 = $storemerge$i13271994$ph;
          $3016 = $1751;
         } else {
          $1818 = $1754;
          $3016 = $1757;
         }
         break;
        }
       case 4:
        {
         $1757 ^ $1751;
         $1771 = _bitshift64Ashr(0, $1754 ^ $storemerge$i13271994$ph | 0, 32) | 0;
         $1772 = tempRet0;
         $1773 = $val2;
         HEAP32[$1773 >> 2] = $1771;
         HEAP32[$1773 + 4 >> 2] = $1772;
         $1818 = $1771;
         $3016 = $1772;
         break;
        }
       case 12:
        {
         $1757 & $1751;
         $1778 = _bitshift64Ashr(0, $1754 & $storemerge$i13271994$ph | 0, 32) | 0;
         $1779 = tempRet0;
         $1780 = $val2;
         HEAP32[$1780 >> 2] = $1778;
         HEAP32[$1780 + 4 >> 2] = $1779;
         $1818 = $1778;
         $3016 = $1779;
         break;
        }
       case 8:
        {
         $1757 | $1751;
         $1785 = _bitshift64Ashr(0, $1754 | $storemerge$i13271994$ph | 0, 32) | 0;
         $1786 = tempRet0;
         $1787 = $val2;
         HEAP32[$1787 >> 2] = $1785;
         HEAP32[$1787 + 4 >> 2] = $1786;
         $1818 = $1785;
         $3016 = $1786;
         break;
        }
       case 16:
        {
         if (($storemerge$i13271994$ph | 0) < ($1754 | 0)) {
          $1791 = $val2;
          HEAP32[$1791 >> 2] = $storemerge$i13271994$ph;
          HEAP32[$1791 + 4 >> 2] = $1751;
          $1818 = $storemerge$i13271994$ph;
          $3016 = $1751;
         } else {
          $1818 = $1754;
          $3016 = $1757;
         }
         break;
        }
       case 20:
        {
         if (($storemerge$i13271994$ph | 0) > ($1754 | 0)) {
          $1795 = $val2;
          HEAP32[$1795 >> 2] = $storemerge$i13271994$ph;
          HEAP32[$1795 + 4 >> 2] = $1751;
          $1818 = $storemerge$i13271994$ph;
          $3016 = $1751;
         } else {
          $1818 = $1754;
          $3016 = $1757;
         }
         break;
        }
       case 1:
        {
         $1818 = $1754;
         $3016 = $1757;
         break;
        }
       default:
        {
         label = 478;
         break L4;
        }
       }
       $1807 = $s + ($conv$i1254 << 4) + 5496 | 0;
       if ((HEAP32[$1807 >> 2] | 0) == ($1736 | 0) ? (HEAP32[$1807 + 4 >> 2] | 0) == ($1669 | 0) : 0) {
        HEAP32[(HEAP32[$s + ($conv$i1254 << 4) + 5504 >> 2] | 0) + $1666 >> 2] = $1818;
        $1996 = $storemerge$i13271994$ph;
        $1999 = $1751;
        break L317;
       } else if (!(_target_write_slow($s, $1666, $1669, $1818, 0, 2) | 0)) {
        $1996 = $storemerge$i13271994$ph;
        $1999 = $1751;
        break L317;
       } else break L4;
       break;
      }
     case 2:
      {
       if ($and12) {
        label = 478;
        break L4;
       }
       $conv$i1314 = (_bitshift64Lshr($1666 | 0, $1669 | 0, 12) | 0) & 255;
       $1672 = $s + ($conv$i1314 << 4) + 1400 | 0;
       if ((HEAP32[$1672 >> 2] | 0) == ($1666 & -4065 | 0) ? (HEAP32[$1672 + 4 >> 2] | 0) == ($1669 | 0) : 0) $storemerge$i13271990$ph = HEAP32[(HEAP32[$s + ($conv$i1314 << 4) + 1408 >> 2] | 0) + $1666 >> 2] | 0; else {
        if (_target_read_slow($s, $val$i1311, $1666, $1669, 2) | 0) break L4;
        $storemerge$i13271990$ph = HEAP32[$val$i1311 >> 2] | 0;
       }
       $1694 = $load_res;
       HEAP32[$1694 >> 2] = $1666;
       HEAP32[$1694 + 4 >> 2] = $1669;
       $1996 = $storemerge$i13271990$ph;
       $1999 = (($storemerge$i13271990$ph | 0) < 0) << 31 >> 31;
       break L317;
       break;
      }
     default:
      {
       label = 478;
       break L4;
      }
     }
    } else {
     label = 478;
     break L4;
    } while (0);
    if (!$and8) {
     $3000 = $89;
     $3003 = $90;
    } else {
     $1994 = $s + ($and8 << 3) + 8 | 0;
     HEAP32[$1994 >> 2] = $1996;
     HEAP32[$1994 + 4 >> 2] = $1999;
     $3000 = $89;
     $3003 = $90;
    }
    break;
   }
  case 7:
   {
    $and1396 = $91 >>> 12 & 7;
    $shr1397 = $91 >> 20;
    $2000 = $s + ($and10 << 3) + 8 | 0;
    $2008 = _i64Add(HEAP32[$2000 >> 2] | 0, HEAP32[$2000 + 4 >> 2] | 0, $shr1397 | 0, (($shr1397 | 0) < 0) << 31 >> 31 | 0) | 0;
    $2009 = tempRet0;
    if (($and1396 | 0) == 3) {
     $2036 = _bitshift64Lshr($2008 | 0, $2009 | 0, 12) | 0;
     $conv$i1083 = $2036 & 255;
     $2038 = $s + ($conv$i1083 << 4) + 1400 | 0;
     if ((HEAP32[$2038 >> 2] | 0) == ($2008 & -4033 | 0) ? (HEAP32[$2038 + 4 >> 2] | 0) == ($2009 | 0) : 0) $storemerge$in$i = (HEAP32[$s + ($conv$i1083 << 4) + 1408 >> 2] | 0) + $2008 | 0; else if (!(_target_read_slow($s, $val$i, $2008, $2009, 3) | 0)) $storemerge$in$i = $val$i; else break L4;
     $2051 = $storemerge$in$i;
     $2056 = HEAP32[$2051 + 4 >> 2] | 0;
     $2057 = $s + ($and8 << 3) + 264 | 0;
     HEAP32[$2057 >> 2] = HEAP32[$2051 >> 2];
     HEAP32[$2057 + 4 >> 2] = $2056;
     $3000 = $89;
     $3003 = $90;
     break L24;
    } else if (($and1396 | 0) != 2) {
     label = 478;
     break L4;
    }
    $conv$i1100 = (_bitshift64Lshr($2008 | 0, $2009 | 0, 12) | 0) & 255;
    $2012 = $s + ($conv$i1100 << 4) + 1400 | 0;
    if ((HEAP32[$2012 >> 2] | 0) == ($2008 & -4065 | 0) ? (HEAP32[$2012 + 4 >> 2] | 0) == ($2009 | 0) : 0) $storemerge$i11121984$ph = HEAP32[(HEAP32[$s + ($conv$i1100 << 4) + 1408 >> 2] | 0) + $2008 >> 2] | 0; else {
     if (_target_read_slow($s, $val$i1097, $2008, $2009, 2) | 0) break L4;
     $storemerge$i11121984$ph = HEAP32[$val$i1097 >> 2] | 0;
    }
    $2032 = $s + ($and8 << 3) + 264 | 0;
    HEAP32[$2032 >> 2] = $storemerge$i11121984$ph;
    HEAP32[$2032 + 4 >> 2] = 0;
    $3000 = $89;
    $3003 = $90;
    break;
   }
  case 39:
   {
    $and1423 = $91 >>> 12 & 7;
    $shr1428 = ($and8 | $shr11 & 4064) << 20 >> 20;
    $2061 = $s + ($and10 << 3) + 8 | 0;
    $2069 = _i64Add(HEAP32[$2061 >> 2] | 0, HEAP32[$2061 + 4 >> 2] | 0, $shr1428 | 0, (($shr1428 | 0) < 0) << 31 >> 31 | 0) | 0;
    $2070 = tempRet0;
    $2071 = $s + ($and12 << 3) + 264 | 0;
    $2073 = HEAP32[$2071 >> 2] | 0;
    $2076 = HEAP32[$2071 + 4 >> 2] | 0;
    if (($and1423 | 0) == 3) {
     $2092 = _bitshift64Lshr($2069 | 0, $2070 | 0, 12) | 0;
     $conv$i1053 = $2092 & 255;
     $2094 = $s + ($conv$i1053 << 4) + 5496 | 0;
     if ((HEAP32[$2094 >> 2] | 0) == ($2069 & -4033 | 0) ? (HEAP32[$2094 + 4 >> 2] | 0) == ($2070 | 0) : 0) {
      $2106 = (HEAP32[$s + ($conv$i1053 << 4) + 5504 >> 2] | 0) + $2069 | 0;
      HEAP32[$2106 >> 2] = $2073;
      HEAP32[$2106 + 4 >> 2] = $2076;
      $3000 = $89;
      $3003 = $90;
      break L24;
     } else if (!(_target_write_slow($s, $2069, $2070, $2073, $2076, 3) | 0)) {
      $3000 = $89;
      $3003 = $90;
      break L24;
     } else break L4;
    } else if (($and1423 | 0) == 2) {
     $2077 = _bitshift64Lshr($2069 | 0, $2070 | 0, 12) | 0;
     $conv$i1067 = $2077 & 255;
     $2079 = $s + ($conv$i1067 << 4) + 5496 | 0;
     if ((HEAP32[$2079 >> 2] | 0) == ($2069 & -4065 | 0) ? (HEAP32[$2079 + 4 >> 2] | 0) == ($2070 | 0) : 0) {
      HEAP32[(HEAP32[$s + ($conv$i1067 << 4) + 5504 >> 2] | 0) + $2069 >> 2] = $2073;
      $3000 = $89;
      $3003 = $90;
      break L24;
     } else if (!(_target_write_slow($s, $2069, $2070, $2073, 0, 2) | 0)) {
      $3000 = $89;
      $3003 = $90;
      break L24;
     } else break L4;
    } else {
     label = 478;
     break L4;
    }
    break;
   }
  case 67:
   {
    $shr1451 = $91 >>> 27;
    $and1453 = $91 >>> 12 & 3;
    $and1450 = $91 >>> 25 & 3;
    if (!$and1450) {
     $2129 = $s + ($and8 << 3) + 264 | 0;
     HEAP32[$2129 >> 2] = _fma_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, HEAP32[$s + ($shr1451 << 3) + 264 >> 2] | 0, $and1453, $fflags) | 0;
     HEAP32[$2129 + 4 >> 2] = 0;
     $3000 = $89;
     $3003 = $90;
     break L24;
    } else if (($and1450 | 0) == 1) {
     $2133 = $s + ($and10 << 3) + 264 | 0;
     $2139 = $s + ($and12 << 3) + 264 | 0;
     $2145 = $s + ($shr1451 << 3) + 264 | 0;
     $2151 = _fma_sf64(HEAP32[$2133 >> 2] | 0, HEAP32[$2133 + 4 >> 2] | 0, HEAP32[$2139 >> 2] | 0, HEAP32[$2139 + 4 >> 2] | 0, HEAP32[$2145 >> 2] | 0, HEAP32[$2145 + 4 >> 2] | 0, $and1453, $fflags) | 0;
     $2153 = $s + ($and8 << 3) + 264 | 0;
     HEAP32[$2153 >> 2] = $2151;
     HEAP32[$2153 + 4 >> 2] = tempRet0;
     $3000 = $89;
     $3003 = $90;
     break L24;
    } else {
     label = 478;
     break L4;
    }
    break;
   }
  case 71:
   {
    $shr1489 = $91 >>> 27;
    $and1491 = $91 >>> 12 & 3;
    $and1488 = $91 >>> 25 & 3;
    if (!$and1488) {
     $2176 = $s + ($and8 << 3) + 264 | 0;
     HEAP32[$2176 >> 2] = _fma_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, HEAP32[$s + ($shr1489 << 3) + 264 >> 2] ^ -2147483648, $and1491, $fflags) | 0;
     HEAP32[$2176 + 4 >> 2] = 0;
     $3000 = $89;
     $3003 = $90;
     break L24;
    } else if (($and1488 | 0) == 1) {
     $2180 = $s + ($and10 << 3) + 264 | 0;
     $2186 = $s + ($and12 << 3) + 264 | 0;
     $2192 = $s + ($shr1489 << 3) + 264 | 0;
     $2199 = _fma_sf64(HEAP32[$2180 >> 2] | 0, HEAP32[$2180 + 4 >> 2] | 0, HEAP32[$2186 >> 2] | 0, HEAP32[$2186 + 4 >> 2] | 0, HEAP32[$2192 >> 2] | 0, HEAP32[$2192 + 4 >> 2] ^ -2147483648, $and1491, $fflags) | 0;
     $2201 = $s + ($and8 << 3) + 264 | 0;
     HEAP32[$2201 >> 2] = $2199;
     HEAP32[$2201 + 4 >> 2] = tempRet0;
     $3000 = $89;
     $3003 = $90;
     break L24;
    } else {
     label = 478;
     break L4;
    }
    break;
   }
  case 75:
   {
    $shr1530 = $91 >>> 27;
    $and1532 = $91 >>> 12 & 3;
    $and1529 = $91 >>> 25 & 3;
    if (!$and1529) {
     $2224 = $s + ($and8 << 3) + 264 | 0;
     HEAP32[$2224 >> 2] = _fma_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] ^ -2147483648, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, HEAP32[$s + ($shr1530 << 3) + 264 >> 2] | 0, $and1532, $fflags) | 0;
     HEAP32[$2224 + 4 >> 2] = 0;
     $3000 = $89;
     $3003 = $90;
     break L24;
    } else if (($and1529 | 0) == 1) {
     $2228 = $s + ($and10 << 3) + 264 | 0;
     $2235 = $s + ($and12 << 3) + 264 | 0;
     $2241 = $s + ($shr1530 << 3) + 264 | 0;
     $2247 = _fma_sf64(HEAP32[$2228 >> 2] | 0, HEAP32[$2228 + 4 >> 2] ^ -2147483648, HEAP32[$2235 >> 2] | 0, HEAP32[$2235 + 4 >> 2] | 0, HEAP32[$2241 >> 2] | 0, HEAP32[$2241 + 4 >> 2] | 0, $and1532, $fflags) | 0;
     $2249 = $s + ($and8 << 3) + 264 | 0;
     HEAP32[$2249 >> 2] = $2247;
     HEAP32[$2249 + 4 >> 2] = tempRet0;
     $3000 = $89;
     $3003 = $90;
     break L24;
    } else {
     label = 478;
     break L4;
    }
    break;
   }
  case 79:
   {
    $shr1571 = $91 >>> 27;
    $and1573 = $91 >>> 12 & 3;
    $and1570 = $91 >>> 25 & 3;
    if (!$and1570) {
     $2273 = $s + ($and8 << 3) + 264 | 0;
     HEAP32[$2273 >> 2] = _fma_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] ^ -2147483648, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, HEAP32[$s + ($shr1571 << 3) + 264 >> 2] ^ -2147483648, $and1573, $fflags) | 0;
     HEAP32[$2273 + 4 >> 2] = 0;
     $3000 = $89;
     $3003 = $90;
     break L24;
    } else if (($and1570 | 0) == 1) {
     $2277 = $s + ($and10 << 3) + 264 | 0;
     $2284 = $s + ($and12 << 3) + 264 | 0;
     $2290 = $s + ($shr1571 << 3) + 264 | 0;
     $2297 = _fma_sf64(HEAP32[$2277 >> 2] | 0, HEAP32[$2277 + 4 >> 2] ^ -2147483648, HEAP32[$2284 >> 2] | 0, HEAP32[$2284 + 4 >> 2] | 0, HEAP32[$2290 >> 2] | 0, HEAP32[$2290 + 4 >> 2] ^ -2147483648, $and1573, $fflags) | 0;
     $2299 = $s + ($and8 << 3) + 264 | 0;
     HEAP32[$2299 >> 2] = $2297;
     HEAP32[$2299 + 4 >> 2] = tempRet0;
     $3000 = $89;
     $3003 = $90;
     break L24;
    } else {
     label = 478;
     break L4;
    }
    break;
   }
  case 83:
   {
    $and1614 = $91 >>> 12 & 3;
    do switch ($91 >>> 25 | 0) {
    case 0:
     {
      $2315 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2315 >> 2] = _add_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, $and1614, $fflags) | 0;
      HEAP32[$2315 + 4 >> 2] = 0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 80:
     {
      if (!$and1614) $val$9$in = _le_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, $fflags) | 0; else if (($and1614 | 0) == 1) $val$9$in = _lt_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, $fflags) | 0; else if (($and1614 | 0) == 2) $val$9$in = _eq_quiet_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, $fflags) | 0; else {
       label = 478;
       break L4;
      }
      if (!$and8) {
       $3000 = $89;
       $3003 = $90;
       break L24;
      }
      $2544 = $s + ($and8 << 3) + 8 | 0;
      HEAP32[$2544 >> 2] = $val$9$in;
      HEAP32[$2544 + 4 >> 2] = (($val$9$in | 0) < 0) << 31 >> 31;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 4:
     {
      $2331 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2331 >> 2] = _sub_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, $and1614, $fflags) | 0;
      HEAP32[$2331 + 4 >> 2] = 0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 8:
     {
      $2347 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2347 >> 2] = _mul_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, $and1614, $fflags) | 0;
      HEAP32[$2347 + 4 >> 2] = 0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 44:
     {
      if ($and12) {
       label = 478;
       break L4;
      }
      $2373 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2373 >> 2] = _sqrt_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, $and1614, $fflags) | 0;
      HEAP32[$2373 + 4 >> 2] = 0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 12:
     {
      $2363 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2363 >> 2] = _div_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, $and1614, $fflags) | 0;
      HEAP32[$2363 + 4 >> 2] = 0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 16:
     {
      if (!$and1614) {
       $2384 = $s + ($and12 << 3) + 264 | 0;
       $2389 = HEAP32[$2384 + 4 >> 2] | 0;
       $2392 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2392 >> 2] = HEAP32[$2384 >> 2] & -2147483648 | HEAP32[$s + ($and10 << 3) + 264 >> 2] & 2147483647;
       HEAP32[$2392 + 4 >> 2] = $2389;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else if (($and1614 | 0) == 1) {
       $2403 = $s + ($and12 << 3) + 264 | 0;
       $2412 = ~HEAP32[$2403 + 4 >> 2];
       $2413 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2413 >> 2] = (HEAP32[$2403 >> 2] & -2147483648 | HEAP32[$s + ($and10 << 3) + 264 >> 2] & 2147483647) ^ -2147483648;
       HEAP32[$2413 + 4 >> 2] = $2412;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else if (($and1614 | 0) == 2) {
       $2417 = $s + ($and10 << 3) + 264 | 0;
       $2423 = $s + ($and12 << 3) + 264 | 0;
       $2431 = HEAP32[$2423 + 4 >> 2] ^ HEAP32[$2417 + 4 >> 2];
       $2432 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2432 >> 2] = HEAP32[$2423 >> 2] & -2147483648 ^ HEAP32[$2417 >> 2];
       HEAP32[$2432 + 4 >> 2] = $2431;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else {
       label = 478;
       break L4;
      }
      break;
     }
    case 20:
     {
      if (!$and1614) {
       $2448 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2448 >> 2] = _min_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, $fflags) | 0;
       HEAP32[$2448 + 4 >> 2] = 0;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else if (($and1614 | 0) == 1) {
       $2464 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2464 >> 2] = _max_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and12 << 3) + 264 >> 2] | 0, $fflags) | 0;
       HEAP32[$2464 + 4 >> 2] = 0;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else {
       label = 478;
       break L4;
      }
      break;
     }
    case 96:
     {
      if (!$and12) {
       $call1770 = _cvt_sf32_i32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, $and1614, $fflags) | 0;
       $2502 = $call1770;
       $2505 = (($call1770 | 0) < 0) << 31 >> 31;
      } else if (($and12 | 0) == 1) {
       $call1777 = _cvt_sf32_u32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, $and1614, $fflags) | 0;
       $2502 = $call1777;
       $2505 = (($call1777 | 0) < 0) << 31 >> 31;
      } else if (($and12 | 0) == 2) {
       $2490 = _cvt_sf32_i64(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, $and1614, $fflags) | 0;
       $2502 = $2490;
       $2505 = tempRet0;
      } else if (($and12 | 0) == 3) {
       $2498 = _cvt_sf32_u64(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, $and1614, $fflags) | 0;
       $2502 = $2498;
       $2505 = tempRet0;
      } else {
       label = 478;
       break L4;
      }
      if (!$and8) {
       $3000 = $89;
       $3003 = $90;
       break L24;
      }
      $2500 = $s + ($and8 << 3) + 8 | 0;
      HEAP32[$2500 >> 2] = $2502;
      HEAP32[$2500 + 4 >> 2] = $2505;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 104:
     {
      if (!$and12) {
       $2554 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2554 >> 2] = _cvt_i32_sf32(HEAP32[$s + ($and10 << 3) + 8 >> 2] | 0, $and1614, $fflags) | 0;
       HEAP32[$2554 + 4 >> 2] = 0;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else if (($and12 | 0) == 1) {
       $2564 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2564 >> 2] = _cvt_u32_sf32(HEAP32[$s + ($and10 << 3) + 8 >> 2] | 0, $and1614, $fflags) | 0;
       HEAP32[$2564 + 4 >> 2] = 0;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else if (($and12 | 0) == 2) {
       $2568 = $s + ($and10 << 3) + 8 | 0;
       $2575 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2575 >> 2] = _cvt_i64_sf32(HEAP32[$2568 >> 2] | 0, HEAP32[$2568 + 4 >> 2] | 0, $and1614, $fflags) | 0;
       HEAP32[$2575 + 4 >> 2] = 0;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else if (($and12 | 0) == 3) {
       $2579 = $s + ($and10 << 3) + 8 | 0;
       $2586 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2586 >> 2] = _cvt_u64_sf32(HEAP32[$2579 >> 2] | 0, HEAP32[$2579 + 4 >> 2] | 0, $and1614, $fflags) | 0;
       HEAP32[$2586 + 4 >> 2] = 0;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else {
       label = 478;
       break L4;
      }
      break;
     }
    case 112:
     {
      if ($and12) {
       label = 478;
       break L4;
      }
      if (!$and1614) {
       $2607 = _bitshift64Ashr(0, HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, 32) | 0;
       $2617 = $2607;
       $2620 = tempRet0;
      } else if (($and1614 | 0) == 1) {
       $2617 = _fclass_sf32(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0) | 0;
       $2620 = 0;
      } else {
       label = 478;
       break L4;
      }
      if (!$and8) {
       $3000 = $89;
       $3003 = $90;
       break L24;
      }
      $2615 = $s + ($and8 << 3) + 8 | 0;
      HEAP32[$2615 >> 2] = $2617;
      HEAP32[$2615 + 4 >> 2] = $2620;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 64:
     {
      if (($and12 | 0) != 1) {
       label = 478;
       break L4;
      }
      $2590 = $s + ($and10 << 3) + 264 | 0;
      $2597 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2597 >> 2] = _cvt_sf64_sf32(HEAP32[$2590 >> 2] | 0, HEAP32[$2590 + 4 >> 2] | 0, $and1614, $fflags) | 0;
      HEAP32[$2597 + 4 >> 2] = 0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 120:
     {
      if ($and12 | $and1614) {
       label = 478;
       break L4;
      }
      $2629 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2629 >> 2] = HEAP32[$s + ($and10 << 3) + 8 >> 2];
      HEAP32[$2629 + 4 >> 2] = 0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 81:
     {
      if (!$and1614) {
       $2850 = $s + ($and10 << 3) + 264 | 0;
       $2856 = $s + ($and12 << 3) + 264 | 0;
       $val$12$in = _le_sf64(HEAP32[$2850 >> 2] | 0, HEAP32[$2850 + 4 >> 2] | 0, HEAP32[$2856 >> 2] | 0, HEAP32[$2856 + 4 >> 2] | 0, $fflags) | 0;
      } else if (($and1614 | 0) == 1) {
       $2863 = $s + ($and10 << 3) + 264 | 0;
       $2869 = $s + ($and12 << 3) + 264 | 0;
       $val$12$in = _lt_sf64(HEAP32[$2863 >> 2] | 0, HEAP32[$2863 + 4 >> 2] | 0, HEAP32[$2869 >> 2] | 0, HEAP32[$2869 + 4 >> 2] | 0, $fflags) | 0;
      } else if (($and1614 | 0) == 2) {
       $2876 = $s + ($and10 << 3) + 264 | 0;
       $2882 = $s + ($and12 << 3) + 264 | 0;
       $val$12$in = _eq_quiet_sf64(HEAP32[$2876 >> 2] | 0, HEAP32[$2876 + 4 >> 2] | 0, HEAP32[$2882 >> 2] | 0, HEAP32[$2882 + 4 >> 2] | 0, $fflags) | 0;
      } else {
       label = 478;
       break L4;
      }
      if (!$and8) {
       $3000 = $89;
       $3003 = $90;
       break L24;
      }
      $2891 = $s + ($and8 << 3) + 8 | 0;
      HEAP32[$2891 >> 2] = $val$12$in;
      HEAP32[$2891 + 4 >> 2] = (($val$12$in | 0) < 0) << 31 >> 31;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 1:
     {
      $2633 = $s + ($and10 << 3) + 264 | 0;
      $2639 = $s + ($and12 << 3) + 264 | 0;
      $2647 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2647 >> 2] = _add_sf64(HEAP32[$2633 >> 2] | 0, HEAP32[$2633 + 4 >> 2] | 0, HEAP32[$2639 >> 2] | 0, HEAP32[$2639 + 4 >> 2] | 0, $and1614, $fflags) | 0;
      HEAP32[$2647 + 4 >> 2] = tempRet0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 5:
     {
      $2651 = $s + ($and10 << 3) + 264 | 0;
      $2657 = $s + ($and12 << 3) + 264 | 0;
      $2665 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2665 >> 2] = _sub_sf64(HEAP32[$2651 >> 2] | 0, HEAP32[$2651 + 4 >> 2] | 0, HEAP32[$2657 >> 2] | 0, HEAP32[$2657 + 4 >> 2] | 0, $and1614, $fflags) | 0;
      HEAP32[$2665 + 4 >> 2] = tempRet0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 9:
     {
      $2669 = $s + ($and10 << 3) + 264 | 0;
      $2675 = $s + ($and12 << 3) + 264 | 0;
      $2683 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2683 >> 2] = _mul_sf64(HEAP32[$2669 >> 2] | 0, HEAP32[$2669 + 4 >> 2] | 0, HEAP32[$2675 >> 2] | 0, HEAP32[$2675 + 4 >> 2] | 0, $and1614, $fflags) | 0;
      HEAP32[$2683 + 4 >> 2] = tempRet0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 45:
     {
      if ($and12) {
       label = 478;
       break L4;
      }
      $2705 = $s + ($and10 << 3) + 264 | 0;
      $2713 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2713 >> 2] = _sqrt_sf64(HEAP32[$2705 >> 2] | 0, HEAP32[$2705 + 4 >> 2] | 0, $and1614, $fflags) | 0;
      HEAP32[$2713 + 4 >> 2] = tempRet0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 13:
     {
      $2687 = $s + ($and10 << 3) + 264 | 0;
      $2693 = $s + ($and12 << 3) + 264 | 0;
      $2701 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2701 >> 2] = _div_sf64(HEAP32[$2687 >> 2] | 0, HEAP32[$2687 + 4 >> 2] | 0, HEAP32[$2693 >> 2] | 0, HEAP32[$2693 + 4 >> 2] | 0, $and1614, $fflags) | 0;
      HEAP32[$2701 + 4 >> 2] = tempRet0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 17:
     {
      if (!$and1614) {
       $2717 = $s + ($and10 << 3) + 264 | 0;
       $2731 = HEAP32[$s + ($and12 << 3) + 268 >> 2] & -2147483648 | HEAP32[$2717 + 4 >> 2] & 2147483647;
       $2732 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2732 >> 2] = HEAP32[$2717 >> 2];
       HEAP32[$2732 + 4 >> 2] = $2731;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else if (($and1614 | 0) == 1) {
       $2736 = $s + ($and10 << 3) + 264 | 0;
       $2751 = (HEAP32[$s + ($and12 << 3) + 268 >> 2] & -2147483648 | HEAP32[$2736 + 4 >> 2] & 2147483647) ^ -2147483648;
       $2752 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2752 >> 2] = HEAP32[$2736 >> 2];
       HEAP32[$2752 + 4 >> 2] = $2751;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else if (($and1614 | 0) == 2) {
       $2756 = $s + ($and10 << 3) + 264 | 0;
       $2769 = HEAP32[$s + ($and12 << 3) + 268 >> 2] & -2147483648 ^ HEAP32[$2756 + 4 >> 2];
       $2770 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2770 >> 2] = HEAP32[$2756 >> 2];
       HEAP32[$2770 + 4 >> 2] = $2769;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else {
       label = 478;
       break L4;
      }
      break;
     }
    case 21:
     {
      if (!$and1614) {
       $2774 = $s + ($and10 << 3) + 264 | 0;
       $2780 = $s + ($and12 << 3) + 264 | 0;
       $2786 = _min_sf64(HEAP32[$2774 >> 2] | 0, HEAP32[$2774 + 4 >> 2] | 0, HEAP32[$2780 >> 2] | 0, HEAP32[$2780 + 4 >> 2] | 0, $fflags) | 0;
       $2788 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2788 >> 2] = $2786;
       HEAP32[$2788 + 4 >> 2] = tempRet0;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else if (($and1614 | 0) == 1) {
       $2792 = $s + ($and10 << 3) + 264 | 0;
       $2798 = $s + ($and12 << 3) + 264 | 0;
       $2804 = _max_sf64(HEAP32[$2792 >> 2] | 0, HEAP32[$2792 + 4 >> 2] | 0, HEAP32[$2798 >> 2] | 0, HEAP32[$2798 + 4 >> 2] | 0, $fflags) | 0;
       $2806 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2806 >> 2] = $2804;
       HEAP32[$2806 + 4 >> 2] = tempRet0;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else {
       label = 478;
       break L4;
      }
      break;
     }
    case 97:
     {
      if (!$and12) {
       $2810 = $s + ($and10 << 3) + 264 | 0;
       $2816 = _cvt_sf64_i32(HEAP32[$2810 >> 2] | 0, HEAP32[$2810 + 4 >> 2] | 0, $and1614, $fflags) | 0;
       $2846 = $2816;
       $2849 = (($2816 | 0) < 0) << 31 >> 31;
      } else if (($and12 | 0) == 1) {
       $2819 = $s + ($and10 << 3) + 264 | 0;
       $2825 = _cvt_sf64_u32(HEAP32[$2819 >> 2] | 0, HEAP32[$2819 + 4 >> 2] | 0, $and1614, $fflags) | 0;
       $2846 = $2825;
       $2849 = (($2825 | 0) < 0) << 31 >> 31;
      } else if (($and12 | 0) == 2) {
       $2828 = $s + ($and10 << 3) + 264 | 0;
       $2834 = _cvt_sf64_i64(HEAP32[$2828 >> 2] | 0, HEAP32[$2828 + 4 >> 2] | 0, $and1614, $fflags) | 0;
       $2846 = $2834;
       $2849 = tempRet0;
      } else if (($and12 | 0) == 3) {
       $2836 = $s + ($and10 << 3) + 264 | 0;
       $2842 = _cvt_sf64_u64(HEAP32[$2836 >> 2] | 0, HEAP32[$2836 + 4 >> 2] | 0, $and1614, $fflags) | 0;
       $2846 = $2842;
       $2849 = tempRet0;
      } else {
       label = 478;
       break L4;
      }
      if (!$and8) {
       $3000 = $89;
       $3003 = $90;
       break L24;
      }
      $2844 = $s + ($and8 << 3) + 8 | 0;
      HEAP32[$2844 >> 2] = $2846;
      HEAP32[$2844 + 4 >> 2] = $2849;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 105:
     {
      if (!$and12) {
       $2901 = _cvt_i32_sf64(HEAP32[$s + ($and10 << 3) + 8 >> 2] | 0, $and1614, $fflags) | 0;
       $2903 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2903 >> 2] = $2901;
       HEAP32[$2903 + 4 >> 2] = tempRet0;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else if (($and12 | 0) == 1) {
       $2913 = _cvt_u32_sf64(HEAP32[$s + ($and10 << 3) + 8 >> 2] | 0, $and1614, $fflags) | 0;
       $2915 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2915 >> 2] = $2913;
       HEAP32[$2915 + 4 >> 2] = tempRet0;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else if (($and12 | 0) == 2) {
       $2919 = $s + ($and10 << 3) + 8 | 0;
       $2925 = _cvt_i64_sf64(HEAP32[$2919 >> 2] | 0, HEAP32[$2919 + 4 >> 2] | 0, $and1614, $fflags) | 0;
       $2927 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2927 >> 2] = $2925;
       HEAP32[$2927 + 4 >> 2] = tempRet0;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else if (($and12 | 0) == 3) {
       $2931 = $s + ($and10 << 3) + 8 | 0;
       $2937 = _cvt_u64_sf64(HEAP32[$2931 >> 2] | 0, HEAP32[$2931 + 4 >> 2] | 0, $and1614, $fflags) | 0;
       $2939 = $s + ($and8 << 3) + 264 | 0;
       HEAP32[$2939 >> 2] = $2937;
       HEAP32[$2939 + 4 >> 2] = tempRet0;
       $3000 = $89;
       $3003 = $90;
       break L24;
      } else {
       label = 478;
       break L4;
      }
      break;
     }
    case 121:
     {
      if ($and12 | $and1614) {
       label = 478;
       break L4;
      }
      $2976 = $s + ($and10 << 3) + 8 | 0;
      $2981 = HEAP32[$2976 + 4 >> 2] | 0;
      $2982 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2982 >> 2] = HEAP32[$2976 >> 2];
      HEAP32[$2982 + 4 >> 2] = $2981;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 65:
     {
      if ($and12) {
       label = 478;
       break L4;
      }
      $2951 = $s + ($and8 << 3) + 264 | 0;
      HEAP32[$2951 >> 2] = _cvt_sf32_sf64(HEAP32[$s + ($and10 << 3) + 264 >> 2] | 0, $fflags) | 0;
      HEAP32[$2951 + 4 >> 2] = tempRet0;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    case 113:
     {
      if ($and12) {
       label = 478;
       break L4;
      }
      if (!$and1614) {
       $2955 = $s + ($and10 << 3) + 264 | 0;
       $2970 = HEAP32[$2955 >> 2] | 0;
       $2973 = HEAP32[$2955 + 4 >> 2] | 0;
      } else if (($and1614 | 0) == 1) {
       $2961 = $s + ($and10 << 3) + 264 | 0;
       $2970 = _fclass_sf64(HEAP32[$2961 >> 2] | 0, HEAP32[$2961 + 4 >> 2] | 0) | 0;
       $2973 = 0;
      } else {
       label = 478;
       break L4;
      }
      if (!$and8) {
       $3000 = $89;
       $3003 = $90;
       break L24;
      }
      $2968 = $s + ($and8 << 3) + 8 | 0;
      HEAP32[$2968 >> 2] = $2970;
      HEAP32[$2968 + 4 >> 2] = $2973;
      $3000 = $89;
      $3003 = $90;
      break L24;
      break;
     }
    default:
     {
      label = 478;
      break L4;
     }
    } while (0);
    break;
   }
  case 35:
   {
    $and739 = $91 >>> 12 & 7;
    $shr744 = ($and8 | $shr11 & 4064) << 20 >> 20;
    $1071 = $s + ($and10 << 3) + 8 | 0;
    $1079 = _i64Add(HEAP32[$1071 >> 2] | 0, HEAP32[$1071 + 4 >> 2] | 0, $shr744 | 0, (($shr744 | 0) < 0) << 31 >> 31 | 0) | 0;
    $1080 = tempRet0;
    $1081 = $s + ($and12 << 3) + 8 | 0;
    $1083 = HEAP32[$1081 >> 2] | 0;
    $1086 = HEAP32[$1081 + 4 >> 2] | 0;
    if (($and739 | 0) == 1) {
     $1104 = _bitshift64Lshr($1079 | 0, $1080 | 0, 12) | 0;
     $conv$i1562 = $1104 & 255;
     $1106 = $s + ($conv$i1562 << 4) + 5496 | 0;
     if ((HEAP32[$1106 >> 2] | 0) == ($1079 & -4081 | 0) ? (HEAP32[$1106 + 4 >> 2] | 0) == ($1080 | 0) : 0) {
      HEAP16[(HEAP32[$s + ($conv$i1562 << 4) + 5504 >> 2] | 0) + $1079 >> 1] = $1083;
      $3000 = $89;
      $3003 = $90;
      break L24;
     } else if (!(_target_write_slow($s, $1079, $1080, $1083 & 65535, 0, 1) | 0)) {
      $3000 = $89;
      $3003 = $90;
      break L24;
     } else break L4;
    } else if (!$and739) {
     $1087 = _bitshift64Lshr($1079 | 0, $1080 | 0, 12) | 0;
     $conv$i1579 = $1087 & 255;
     $1089 = $s + ($conv$i1579 << 4) + 5496 | 0;
     if ((HEAP32[$1089 >> 2] | 0) == ($1079 & -4089 | 0) ? (HEAP32[$1089 + 4 >> 2] | 0) == ($1080 | 0) : 0) {
      HEAP8[(HEAP32[$s + ($conv$i1579 << 4) + 5504 >> 2] | 0) + $1079 >> 0] = $1083;
      $3000 = $89;
      $3003 = $90;
      break L24;
     } else if (!(_target_write_slow($s, $1079, $1080, $1083 & 255, 0, 0) | 0)) {
      $3000 = $89;
      $3003 = $90;
      break L24;
     } else break L4;
    } else if (($and739 | 0) == 3) {
     $1136 = _bitshift64Lshr($1079 | 0, $1080 | 0, 12) | 0;
     $conv$i1528 = $1136 & 255;
     $1138 = $s + ($conv$i1528 << 4) + 5496 | 0;
     if ((HEAP32[$1138 >> 2] | 0) == ($1079 & -4033 | 0) ? (HEAP32[$1138 + 4 >> 2] | 0) == ($1080 | 0) : 0) {
      $1150 = (HEAP32[$s + ($conv$i1528 << 4) + 5504 >> 2] | 0) + $1079 | 0;
      HEAP32[$1150 >> 2] = $1083;
      HEAP32[$1150 + 4 >> 2] = $1086;
      $3000 = $89;
      $3003 = $90;
      break L24;
     } else if (!(_target_write_slow($s, $1079, $1080, $1083, $1086, 3) | 0)) {
      $3000 = $89;
      $3003 = $90;
      break L24;
     } else break L4;
    } else if (($and739 | 0) == 2) {
     $1121 = _bitshift64Lshr($1079 | 0, $1080 | 0, 12) | 0;
     $conv$i1544 = $1121 & 255;
     $1123 = $s + ($conv$i1544 << 4) + 5496 | 0;
     if ((HEAP32[$1123 >> 2] | 0) == ($1079 & -4065 | 0) ? (HEAP32[$1123 + 4 >> 2] | 0) == ($1080 | 0) : 0) {
      HEAP32[(HEAP32[$s + ($conv$i1544 << 4) + 5504 >> 2] | 0) + $1079 >> 2] = $1083;
      $3000 = $89;
      $3003 = $90;
      break L24;
     } else if (!(_target_write_slow($s, $1079, $1080, $1083, 0, 2) | 0)) {
      $3000 = $89;
      $3003 = $90;
      break L24;
     } else break L4;
    } else {
     label = 478;
     break L4;
    }
    break;
   }
  case 19:
   {
    $shr779 = $91 >> 20;
    L546 : do switch ($91 >>> 12 & 7 | 0) {
    case 4:
     {
      $1201 = $s + ($and10 << 3) + 8 | 0;
      $1243 = HEAP32[$1201 >> 2] ^ $shr779;
      $1246 = HEAP32[$1201 + 4 >> 2] ^ (($shr779 | 0) < 0) << 31 >> 31;
      break;
     }
    case 5:
     {
      if ($shr779 & -1088) {
       label = 478;
       break L4;
      }
      $1211 = $s + ($and10 << 3) + 8 | 0;
      $1213 = HEAP32[$1211 >> 2] | 0;
      $1216 = HEAP32[$1211 + 4 >> 2] | 0;
      $and826 = $shr779 & 63;
      if (!($shr779 & 1024)) {
       $1219 = _bitshift64Lshr($1213 | 0, $1216 | 0, $and826 | 0) | 0;
       $1243 = $1219;
       $1246 = tempRet0;
       break L546;
      } else {
       $1217 = _bitshift64Ashr($1213 | 0, $1216 | 0, $and826 | 0) | 0;
       $1243 = $1217;
       $1246 = tempRet0;
       break L546;
      }
      break;
     }
    case 0:
     {
      $1155 = $s + ($and10 << 3) + 8 | 0;
      $1243 = _i64Add(HEAP32[$1155 >> 2] | 0, HEAP32[$1155 + 4 >> 2] | 0, $shr779 | 0, (($shr779 | 0) < 0) << 31 >> 31 | 0) | 0;
      $1246 = tempRet0;
      break;
     }
    case 1:
     {
      if ($shr779 >>> 0 > 63) {
       label = 478;
       break L4;
      }
      $1165 = $s + ($and10 << 3) + 8 | 0;
      $1243 = _bitshift64Shl(HEAP32[$1165 >> 2] | 0, HEAP32[$1165 + 4 >> 2] | 0, $shr779 & 63 | 0) | 0;
      $1246 = tempRet0;
      break;
     }
    case 6:
     {
      $1221 = $s + ($and10 << 3) + 8 | 0;
      $1243 = HEAP32[$1221 >> 2] | $shr779;
      $1246 = HEAP32[$1221 + 4 >> 2] | (($shr779 | 0) < 0) << 31 >> 31;
      break;
     }
    case 2:
     {
      $1173 = $s + ($and10 << 3) + 8 | 0;
      $1178 = HEAP32[$1173 + 4 >> 2] | 0;
      $1180 = (($shr779 | 0) < 0) << 31 >> 31;
      $1243 = (($1178 | 0) < ($1180 | 0) | (($1178 | 0) == ($1180 | 0) ? (HEAP32[$1173 >> 2] | 0) >>> 0 < $shr779 >>> 0 : 0)) & 1;
      $1246 = 0;
      break;
     }
    case 3:
     {
      $1187 = $s + ($and10 << 3) + 8 | 0;
      $1192 = HEAP32[$1187 + 4 >> 2] | 0;
      $1194 = (($shr779 | 0) < 0) << 31 >> 31;
      $1243 = ($1192 >>> 0 < $1194 >>> 0 | (($1192 | 0) == ($1194 | 0) ? (HEAP32[$1187 >> 2] | 0) >>> 0 < $shr779 >>> 0 : 0)) & 1;
      $1246 = 0;
      break;
     }
    default:
     {
      $1231 = $s + ($and10 << 3) + 8 | 0;
      $1243 = HEAP32[$1231 >> 2] & $shr779;
      $1246 = HEAP32[$1231 + 4 >> 2] & (($shr779 | 0) < 0) << 31 >> 31;
     }
    } while (0);
    if (!$and8) {
     $3000 = $89;
     $3003 = $90;
    } else {
     $1241 = $s + ($and8 << 3) + 8 | 0;
     HEAP32[$1241 >> 2] = $1243;
     HEAP32[$1241 + 4 >> 2] = $1246;
     $3000 = $89;
     $3003 = $90;
    }
    break;
   }
  default:
   {
    label = 478;
    break L4;
   }
  } while (0);
  $2998 = $s;
  HEAP32[$2998 >> 2] = $3000;
  HEAP32[$2998 + 4 >> 2] = $3003;
  $n_cycles$addr$02173 = $n_cycles$addr$02173 + -1 | 0;
  $3004 = $insn_counter2220;
  $3010 = _i64Add(HEAP32[$3004 >> 2] | 0, HEAP32[$3004 + 4 >> 2] | 0, 1, 0) | 0;
  $3012 = $insn_counter2220;
  HEAP32[$3012 >> 2] = $3010;
  HEAP32[$3012 + 4 >> 2] = tempRet0;
  if (!$n_cycles$addr$02173) {
   label = 481;
   break;
  }
 }
 if ((label | 0) == 97) _raise_exception2($s, 3, 0, 0); else if ((label | 0) == 264) {
  $1480 = $s;
  HEAP32[$1480 >> 2] = $89;
  HEAP32[$1480 + 4 >> 2] = $90;
 } else if ((label | 0) == 274) {
  $1509 = $s;
  HEAP32[$1509 >> 2] = $89;
  HEAP32[$1509 + 4 >> 2] = $90;
 } else if ((label | 0) == 276) if (!($91 & 1048448)) _raise_exception2($s, (HEAPU8[$priv1169 >> 0] | 0) + 8 | 0, 0, 0); else label = 478; else if ((label | 0) == 278) if (!($91 & 1048448)) _raise_exception2($s, 3, 0, 0); else label = 478; else if ((label | 0) == 280) if (!($91 & 1048448)) {
  $1514 = HEAP8[$priv1169 >> 0] | 0;
  if (!($1514 << 24 >> 24)) label = 478; else {
   $1515 = $mstatus$i$i;
   $1517 = HEAP32[$1515 >> 2] | 0;
   $1520 = HEAP32[$1515 + 4 >> 2] | 0;
   $1521 = _bitshift64Lshr($1517 | 0, $1520 | 0, 8) | 0;
   $conv$i1361 = $1521 & 1;
   $1523 = _bitshift64Lshr($1517 | 0, $1520 | 0, 5) | 0;
   $neg$i1366 = 1 << $conv$i1361 ^ -33;
   $shl8$i1369 = ($1523 & 1) << $conv$i1361;
   $1531 = $neg$i1366 & $1517 | $shl8$i1369;
   $1532 = (($neg$i1366 | 0) < 0) << 31 >> 31 & $1520 | (($shl8$i1369 | 0) < 0) << 31 >> 31;
   $1533 = _bitshift64Lshr($1531 | 0, $1532 | 0, 42) | 0;
   $conv18$i1374 = $1533 & 3;
   HEAP8[$s + 525 >> 0] = ($conv18$i1374 + -1 | 0) >>> 0 > 1 ? 64 : 1 << ($conv18$i1374 | 4) & 255;
   $1540 = $mstatus$i$i;
   HEAP32[$1540 >> 2] = $1531 & -289 | 32;
   HEAP32[$1540 + 4 >> 2] = $1532 & -1025;
   if (($1514 & 255 | 0) != ($conv$i1361 | 0)) {
    $i$07$i$i$i$i1385 = 0;
    do {
     $1544 = $s + ($i$07$i$i$i$i1385 << 4) + 1400 | 0;
     HEAP32[$1544 >> 2] = -1;
     HEAP32[$1544 + 4 >> 2] = -1;
     $1548 = $s + ($i$07$i$i$i$i1385 << 4) + 5496 | 0;
     HEAP32[$1548 >> 2] = -1;
     HEAP32[$1548 + 4 >> 2] = -1;
     $1552 = $s + ($i$07$i$i$i$i1385 << 4) + 9592 | 0;
     HEAP32[$1552 >> 2] = -1;
     HEAP32[$1552 + 4 >> 2] = -1;
     $i$07$i$i$i$i1385 = $i$07$i$i$i$i1385 + 1 | 0;
    } while (($i$07$i$i$i$i1385 | 0) != 256);
    HEAP8[$priv1169 >> 0] = $conv$i1361;
   }
   $1556 = $s + 664 | 0;
   $1561 = HEAP32[$1556 + 4 >> 2] | 0;
   $1562 = $s;
   HEAP32[$1562 >> 2] = HEAP32[$1556 >> 2];
   HEAP32[$1562 + 4 >> 2] = $1561;
  }
 } else label = 478; else if ((label | 0) == 286) if (!($91 & 1048448)) {
  $1566 = HEAP8[$priv1169 >> 0] | 0;
  if (($1566 & 255) < 3) label = 478; else {
   $1567 = $mstatus$i$i;
   $1569 = HEAP32[$1567 >> 2] | 0;
   $1572 = HEAP32[$1567 + 4 >> 2] | 0;
   $1573 = _bitshift64Lshr($1569 | 0, $1572 | 0, 11) | 0;
   $conv$i1352 = $1573 & 3;
   $1575 = _bitshift64Lshr($1569 | 0, $1572 | 0, 7) | 0;
   $neg$i = 1 << $conv$i1352 ^ -129;
   $shl8$i = ($1575 & 1) << $conv$i1352;
   $1583 = $neg$i & $1569 | $shl8$i;
   $1584 = (($neg$i | 0) < 0) << 31 >> 31 & $1572 | (($shl8$i | 0) < 0) << 31 >> 31;
   $1585 = _bitshift64Lshr($1583 | 0, $1584 | 0, 46) | 0;
   $conv18$i = $1585 & 3;
   HEAP8[$s + 525 >> 0] = ($conv18$i + -1 | 0) >>> 0 > 1 ? 64 : 1 << ($conv18$i | 4) & 255;
   $1592 = $mstatus$i$i;
   HEAP32[$1592 >> 2] = $1583 & -6273 | 128;
   HEAP32[$1592 + 4 >> 2] = $1584 & -16385;
   if (($1566 & 255 | 0) != ($conv$i1352 | 0)) {
    $i$07$i$i$i$i = 0;
    do {
     $1596 = $s + ($i$07$i$i$i$i << 4) + 1400 | 0;
     HEAP32[$1596 >> 2] = -1;
     HEAP32[$1596 + 4 >> 2] = -1;
     $1600 = $s + ($i$07$i$i$i$i << 4) + 5496 | 0;
     HEAP32[$1600 >> 2] = -1;
     HEAP32[$1600 + 4 >> 2] = -1;
     $1604 = $s + ($i$07$i$i$i$i << 4) + 9592 | 0;
     HEAP32[$1604 >> 2] = -1;
     HEAP32[$1604 + 4 >> 2] = -1;
     $i$07$i$i$i$i = $i$07$i$i$i$i + 1 | 0;
    } while (($i$07$i$i$i$i | 0) != 256);
    HEAP8[$priv1169 >> 0] = $conv$i1352;
   }
   $1608 = $s + 584 | 0;
   $1613 = HEAP32[$1608 + 4 >> 2] | 0;
   $1614 = $s;
   HEAP32[$1614 >> 2] = HEAP32[$1608 >> 2];
   HEAP32[$1614 + 4 >> 2] = $1613;
  }
 } else label = 478; else if ((label | 0) == 299) {
  HEAP32[$s + 544 >> 2] = 1;
  $1660 = $s;
  HEAP32[$1660 >> 2] = $89;
  HEAP32[$1660 + 4 >> 2] = $90;
 } else if ((label | 0) == 481) {
  STACKTOP = sp;
  return;
 }
 if ((label | 0) == 478) _raise_exception2($s, 2, 0, 0);
 $2986 = $insn_counter2220;
 $2992 = _i64Add(HEAP32[$2986 >> 2] | 0, HEAP32[$2986 + 4 >> 2] | 0, 1, 0) | 0;
 $2994 = $insn_counter2220;
 HEAP32[$2994 >> 2] = $2992;
 HEAP32[$2994 + 4 >> 2] = tempRet0;
 STACKTOP = sp;
 return;
}
function _riscv_cpu_interp32($s, $n_cycles) {
 $s = $s | 0;
 $n_cycles = $n_cycles | 0;
 var $0 = 0, $1009 = 0, $1011 = 0, $1014 = 0, $1015 = 0, $1023 = 0, $1024 = 0, $1027 = 0, $1031 = 0, $1033 = 0, $1048 = 0, $1050 = 0, $1065 = 0, $1067 = 0, $107 = 0, $1080 = 0, $1090 = 0, $1100 = 0, $1105 = 0, $1107 = 0, $111 = 0, $1114 = 0, $1119 = 0, $1121 = 0, $1128 = 0, $1140 = 0, $1148 = 0, $1158 = 0, $1168 = 0, $1170 = 0, $1173 = 0, $1174 = 0, $1176 = 0, $1179 = 0, $1180 = 0, $1182 = 0, $1185 = 0, $1186 = 0, $119 = 0, $1192 = 0, $1193 = 0, $12 = 0, $120 = 0, $123 = 0, $1236 = 0, $1238 = 0, $1241 = 0, $1242 = 0, $1254 = 0, $1255 = 0, $1256 = 0, $1260 = 0, $1261 = 0, $1262 = 0, $1263 = 0, $1267 = 0, $1277 = 0, $1278 = 0, $1279 = 0, $1289 = 0, $1290 = 0, $1291 = 0, $1292 = 0, $1296 = 0, $1301 = 0, $1302 = 0, $1304 = 0, $1307 = 0, $1308 = 0, $1310 = 0, $1318 = 0, $1319 = 0, $1320 = 0, $1327 = 0, $1331 = 0, $1335 = 0, $1339 = 0, $1343 = 0, $1348 = 0, $1349 = 0, $1353 = 0, $1354 = 0, $1356 = 0, $1359 = 0, $136 = 0, $1360 = 0, $1362 = 0, $1370 = 0, $1371 = 0, $1372 = 0, $1379 = 0, $1383 = 0, $1387 = 0, $1391 = 0, $1395 = 0, $1400 = 0, $1401 = 0, $1406 = 0, $141 = 0, $1410 = 0, $1414 = 0, $1418 = 0, $142 = 0, $1422 = 0, $1426 = 0, $1430 = 0, $1436 = 0, $1447 = 0, $1451 = 0, $1453 = 0, $1456 = 0, $1459 = 0, $146 = 0, $1481 = 0, $1485 = 0, $1496 = 0, $1500 = 0, $1502 = 0, $1517 = 0, $1523 = 0, $1538 = 0, $1539 = 0, $154 = 0, $1541 = 0, $1544 = 0, $1545 = 0, $155 = 0, $1551 = 0, $1552 = 0, $1553 = 0, $1558 = 0, $1559 = 0, $1560 = 0, $1565 = 0, $1566 = 0, $1567 = 0, $1572 = 0, $1573 = 0, $1574 = 0, $1578 = 0, $158 = 0, $1582 = 0, $1586 = 0, $1590 = 0, $1594 = 0, $1605 = 0, $1607 = 0, $1609 = 0, $1612 = 0, $1613 = 0, $1621 = 0, $1622 = 0, $1625 = 0, $1645 = 0, $1649 = 0, $1651 = 0, $1664 = 0, $1669 = 0, $1670 = 0, $1674 = 0, $1682 = 0, $1683 = 0, $1684 = 0, $1686 = 0, $1689 = 0, $1690 = 0, $1692 = 0, $1705 = 0, $1707 = 0, $1719 = 0, $1742 = 0, $1746 = 0, $1752 = 0, $1758 = 0, $1764 = 0, $1766 = 0, $1789 = 0, $1793 = 0, $1799 = 0, $180 = 0, $1805 = 0, $1812 = 0, $1814 = 0, $1837 = 0, $184 = 0, $1841 = 0, $1848 = 0, $1854 = 0, $1860 = 0, $1862 = 0, $1886 = 0, $1890 = 0, $1897 = 0, $1903 = 0, $1910 = 0, $1912 = 0, $192 = 0, $1928 = 0, $193 = 0, $1944 = 0, $196 = 0, $1960 = 0, $1976 = 0, $1986 = 0, $1997 = 0, $2002 = 0, $2005 = 0, $2016 = 0, $2025 = 0, $2026 = 0, $2030 = 0, $2036 = 0, $2044 = 0, $2045 = 0, $2061 = 0, $2077 = 0, $2095 = 0, $2137 = 0, $2147 = 0, $2157 = 0, $216 = 0, $2161 = 0, $2168 = 0, $2178 = 0, $2186 = 0, $2188 = 0, $2191 = 0, $220 = 0, $2200 = 0, $2204 = 0, $2210 = 0, $2218 = 0, $2222 = 0, $2228 = 0, $2236 = 0, $2240 = 0, $2246 = 0, $2254 = 0, $2258 = 0, $2264 = 0, $2272 = 0, $2276 = 0, $228 = 0, $2284 = 0, $2288 = 0, $229 = 0, $230 = 0, $2302 = 0, $2303 = 0, $2307 = 0, $232 = 0, $2322 = 0, $2323 = 0, $2327 = 0, $2340 = 0, $2341 = 0, $2345 = 0, $235 = 0, $2351 = 0, $2357 = 0, $2359 = 0, $2363 = 0, $2369 = 0, $2375 = 0, $2377 = 0, $238 = 0, $2381 = 0, $2388 = 0, $2397 = 0, $2401 = 0, $2407 = 0, $2414 = 0, $2420 = 0, $2427 = 0, $2433 = 0, $2442 = 0, $2452 = 0, $2454 = 0, $2464 = 0, $2466 = 0, $2478 = 0, $2482 = 0, $2488 = 0, $2489 = 0, $2493 = 0, $2499 = 0, $250 = 0, $2501 = 0, $2505 = 0, $2507 = 0, $2510 = 0, $2511 = 0, $2517 = 0, $2519 = 0, $2523 = 0, $255 = 0, $263 = 0, $264 = 0, $267 = 0, $273 = 0, $286 = 0, $294 = 0, $295 = 0, $298 = 0, $304 = 0, $319 = 0, $320 = 0, $321 = 0, $331 = 0, $335 = 0, $339 = 0, $346 = 0, $350 = 0, $360 = 0, $366 = 0, $372 = 0, $378 = 0, $384 = 0, $390 = 0, $397 = 0, $398 = 0, $402 = 0, $408 = 0, $414 = 0, $416 = 0, $418 = 0, $422 = 0, $428 = 0, $435 = 0, $436 = 0, $440 = 0, $446 = 0, $453 = 0, $454 = 0, $458 = 0, $464 = 0, $471 = 0, $472 = 0, $480 = 0, $493 = 0, $508 = 0, $509 = 0, $510 = 0, $520 = 0, $524 = 0, $53 = 0, $532 = 0, $533 = 0, $536 = 0, $549 = 0, $55 = 0, $554 = 0, $555 = 0, $559 = 0, $567 = 0, $568 = 0, $571 = 0, $58 = 0, $59 = 0, $593 = 0, $597 = 0, $6 = 0, $605 = 0, $606 = 0, $609 = 0, $61 = 0, $629 = 0, $633 = 0, $640 = 0, $645 = 0, $646 = 0, $650 = 0, $654 = 0, $661 = 0, $667 = 0, $673 = 0, $675 = 0, $677 = 0, $681 = 0, $689 = 0, $690 = 0, $691 = 0, $693 = 0, $696 = 0, $699 = 0, $711 = 0, $716 = 0, $724 = 0, $725 = 0, $728 = 0, $734 = 0, $747 = 0, $755 = 0, $756 = 0, $759 = 0, $765 = 0, $780 = 0, $784 = 0, $786 = 0, $788 = 0, $792 = 0, $796 = 0, $802 = 0, $803 = 0, $808 = 0, $81 = 0, $812 = 0, $822 = 0, $828 = 0, $837 = 0, $842 = 0, $843 = 0, $848 = 0, $854 = 0, $859 = 0, $860 = 0, $865 = 0, $87 = 0, $871 = 0, $873 = 0, $875 = 0, $88 = 0, $883 = 0, $884 = 0, $887 = 0, $90 = 0, $908 = 0, $91 = 0, $913 = 0, $92 = 0, $934 = 0, $939 = 0, $95 = 0, $96 = 0, $963 = 0, $97 = 0, $987 = 0, $add$i = 0, $and1024 = 0, $and11 = 0, $and1157 = 0, $and1281 = 0, $and13 = 0, $and1308 = 0, $and1335 = 0, $and1338 = 0, $and1373 = 0, $and1376 = 0, $and1414 = 0, $and1417 = 0, $and1455 = 0, $and1458 = 0, $and1499 = 0, $and20$i$i = 0, $and267 = 0, $and433 = 0, $and626 = 0, $and681 = 0, $and786 = 0, $and873 = 0, $and9 = 0, $arrayidx = 0, $arrayidx183 = 0, $arrayidx209 = 0, $arrayidx283 = 0, $arrayidx305 = 0, $arrayidx318 = 0, $arrayidx327 = 0, $arrayidx334 = 0, $arrayidx342 = 0, $arrayidx445 = 0, $arrayidx559 = 0, $cmp1049 = 0, $cmp520 = 0, $cmp523 = 0, $cond$0 = 0, $conv$i = 0, $conv$i1015 = 0, $conv$i1049 = 0, $conv$i1071 = 0, $conv$i1093 = 0, $conv$i1112 = 0, $conv$i1132 = 0, $conv$i1156 = 0, $conv$i1165 = 0, $conv$i1208 = 0, $conv$i1233 = 0, $conv$i1283 = 0, $conv$i1301 = 0, $conv$i1315 = 0, $conv$i1333 = 0, $conv$i1351 = 0, $conv$i1373 = 0, $conv$i1391 = 0, $conv$i1410 = 0, $conv$i1433 = 0, $conv$i1455 = 0, $conv$i1477 = 0, $conv$i1501 = 0, $conv$i1525 = 0, $conv$i1552 = 0, $conv$i1581 = 0, $conv$i1610 = 0, $conv$i968 = 0, $conv$i982 = 0, $conv$i998 = 0, $conv18$i = 0, $conv18$i1178 = 0, $conv2$i$i = 0, $enabled_ints$0$i$i = 0, $err$0 = 0, $fflags = 0, $i$05$i$i = 0, $i$07$i$i = 0, $i$07$i$i$i = 0, $i$07$i$i$i$i = 0, $i$07$i$i$i$i1189 = 0, $insn = 0, $insn_counter2038 = 0, $load_res = 0, $mideleg$i$i = 0, $mie = 0, $mip = 0, $mstatus$i$i = 0, $mul = 0, $n_cycles$addr$01901 = 0, $neg$i = 0, $neg$i1170 = 0, $or = 0, $or$i$i = 0, $or270 = 0, $or274 = 0, $or29 = 0, $or310 = 0, $or315 = 0, $priv1125 = 0, $retval$0$i1253 = 0, $retval$0$i1258 = 0, $retval$0$i1637 = 0, $retval$0$i1711 = 0, $retval$0$i5$i = 0, $shl8$i = 0, $shl8$i1173 = 0, $shr = 0, $shr$i1472 = 0, $shr$i1695 = 0, $shr$i1699 = 0, $shr$i1713 = 0, $shr$i1721 = 0, $shr$i1738 = 0, $shr1013 = 0, $shr1177 = 0, $shr12 = 0, $shr1282 = 0, $shr1313 = 0, $shr1336 = 0, $shr1374 = 0, $shr1415 = 0, $shr1456 = 0, $shr20 = 0, $shr266 = 0, $shr285 = 0, $shr293 = 0, $shr432 = 0, $shr684 = 0, $shr686 = 0, $shr736 = 0, $shr791 = 0, $shr821 = 0, $shr874 = 0, $shr881 = 0, $shr903 = 0, $shr991 = 0, $shr997 = 0, $storemerge$i10271753$ph = 0, $storemerge$i11251754$ph = 0, $storemerge$i11251758$ph = 0, $storemerge$i11451793$ph = 0, $storemerge$i12211790$ph = 0, $storemerge$i13641762$ph = 0, $storemerge$i13861766$ph = 0, $storemerge$i14231770$ph = 0, $storemerge$i14461774$ph = 0, $storemerge$i14681778$ph = 0, $storemerge$i15651781$ph = 0, $storemerge$i15941784$ph = 0, $storemerge$in$i = 0, $storemerge$in$i1060 = 0, $storemerge$in$i1621 = 0, $val$10$in = 0, $val$6$in = 0, $val$7$in = 0, $val$9$in = 0, $val$i = 0, $val$i1012 = 0, $val$i1046 = 0, $val$i1068 = 0, $val$i1109 = 0, $val$i1129 = 0, $val$i1205 = 0, $val$i1348 = 0, $val$i1370 = 0, $val$i1407 = 0, $val$i1430 = 0, $val$i1452 = 0, $val$i1549 = 0, $val$i1578 = 0, $val$i1607 = 0, $val2 = 0, label = 0, sp = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 144 | 0;
 $val$i1607 = sp + 120 | 0;
 $val$i1578 = sp + 112 | 0;
 $val$i1549 = sp + 104 | 0;
 $val$i1452 = sp + 96 | 0;
 $val$i1430 = sp + 88 | 0;
 $val$i1407 = sp + 80 | 0;
 $val$i1370 = sp + 72 | 0;
 $val$i1348 = sp + 64 | 0;
 $val$i1205 = sp + 56 | 0;
 $val$i1129 = sp + 48 | 0;
 $val$i1109 = sp + 40 | 0;
 $val$i1068 = sp + 32 | 0;
 $val$i1046 = sp + 24 | 0;
 $val$i1012 = sp + 16 | 0;
 $val$i = sp + 8 | 0;
 $insn = sp + 128 | 0;
 $val2 = sp;
 if (!$n_cycles) {
  STACKTOP = sp;
  return;
 }
 $mip = $s + 608 | 0;
 $mie = $s + 560 | 0;
 $arrayidx = $s + 24 | 0;
 $insn_counter2038 = $s + 528 | 0;
 $arrayidx209 = $s + 16 | 0;
 $priv1125 = $s + 526 | 0;
 $load_res = $s + 720 | 0;
 $fflags = $s + 520 | 0;
 $mstatus$i$i = $s + 552 | 0;
 $mideleg$i$i = $s + 640 | 0;
 $n_cycles$addr$01901 = $n_cycles;
 L4 : while (1) {
  $0 = $mip;
  $6 = $mie;
  $12 = HEAP32[$6 >> 2] & HEAP32[$0 >> 2];
  if (!(($12 | 0) == 0 ? (HEAP32[$6 + 4 >> 2] & HEAP32[$0 + 4 >> 2] | 0) == 0 : 0)) if ($12) {
   $conv2$i$i = HEAPU8[$priv1125 >> 0] | 0;
   if (($conv2$i$i | 0) == 1) $enabled_ints$0$i$i = (HEAP32[$mstatus$i$i >> 2] & 2 | 0) == 0 & 0 == 0 ? ~HEAP32[$mideleg$i$i >> 2] : -1; else if (($conv2$i$i | 0) == 3) if ((HEAP32[$mstatus$i$i >> 2] & 8 | 0) == 0 & 0 == 0) $enabled_ints$0$i$i = 0; else $enabled_ints$0$i$i = ~HEAP32[$mideleg$i$i >> 2]; else $enabled_ints$0$i$i = -1;
   $and20$i$i = $enabled_ints$0$i$i & $12;
   if ($and20$i$i) {
    $i$05$i$i = 0;
    while (1) {
     if (1 << $i$05$i$i & $and20$i$i) {
      $retval$0$i5$i = $i$05$i$i;
      break;
     }
     $i$05$i$i = $i$05$i$i + 1 | 0;
     if (($i$05$i$i | 0) >= 32) {
      $retval$0$i5$i = 32;
      break;
     }
    }
    _raise_exception2($s, $retval$0$i5$i | -2147483648, 0, 0);
   }
  }
  $53 = $s;
  $55 = HEAP32[$53 >> 2] | 0;
  $58 = HEAP32[$53 + 4 >> 2] | 0;
  $59 = _bitshift64Lshr($55 | 0, $58 | 0, 12) | 0;
  $conv$i = $59 & 255;
  $61 = $s + ($conv$i << 4) + 9592 | 0;
  if (((HEAP32[$61 >> 2] | 0) == ($55 & -4096 | 0) ? (HEAP32[$61 + 4 >> 2] | 0) == ($58 | 0) : 0) & (($55 & 4095 | 0) != 4094 | 0 != 0)) {
   $add$i = (HEAP32[$s + ($conv$i << 4) + 9600 >> 2] | 0) + $55 | 0;
   $or$i$i = HEAPU16[$add$i + 2 >> 1] << 16 | HEAPU16[$add$i >> 1];
   HEAP32[$insn >> 2] = $or$i$i;
   $339 = $58;
   $87 = $55;
   $92 = $or$i$i;
  } else {
   if (_target_read_insn_slow($s, $insn, $55, $58, 0) | 0) break;
   $81 = $s;
   $339 = HEAP32[$81 + 4 >> 2] | 0;
   $87 = HEAP32[$81 >> 2] | 0;
   $92 = HEAP32[$insn >> 2] | 0;
  }
  $88 = _i64Add(0, $87 | 0, 0, 4) | 0;
  $90 = _bitshift64Ashr($88 | 0, tempRet0 | 0, 32) | 0;
  $91 = tempRet0;
  $shr = $92 >>> 7;
  $and9 = $shr & 31;
  $and11 = $92 >>> 15 & 31;
  $shr12 = $92 >>> 20;
  $and13 = $shr12 & 31;
  L24 : do switch ($92 & 127 | 0) {
  case 125:
  case 121:
  case 117:
  case 113:
  case 109:
  case 105:
  case 101:
  case 97:
  case 93:
  case 89:
  case 85:
  case 81:
  case 77:
  case 73:
  case 69:
  case 65:
  case 61:
  case 57:
  case 53:
  case 49:
  case 45:
  case 41:
  case 37:
  case 33:
  case 29:
  case 25:
  case 21:
  case 17:
  case 13:
  case 9:
  case 5:
  case 1:
   {
    $319 = _bitshift64Ashr(_i64Add(0, $87 | 0, 0, 2) | 0, tempRet0 | 0, 32) | 0;
    $320 = tempRet0;
    switch ($92 >>> 13 & 7 | 0) {
    case 0:
     {
      if (!$and9) {
       $2507 = $319;
       $2510 = $320;
       break L24;
      }
      $arrayidx183 = $s + ($and9 << 3) + 8 | 0;
      $321 = $arrayidx183;
      $331 = $arrayidx183;
      HEAP32[$331 >> 2] = _bitshift64Ashr(0, _i64Add(HEAP32[$321 >> 2] | 0, HEAP32[$321 + 4 >> 2] | 0, ($shr & 32 | $92 >>> 2 & 31) << 26 >> 26 | 0, 0) | 0, 32) | 0;
      HEAP32[$331 + 4 >> 2] = tempRet0;
      $2507 = $319;
      $2510 = $320;
      break L24;
      break;
     }
    case 2:
     {
      if (!$and9) {
       $2507 = $319;
       $2510 = $320;
       break L24;
      }
      $shr$i1738 = ($shr & 32 | $92 >>> 2 & 31) << 26 >> 26;
      $346 = $s + ($and9 << 3) + 8 | 0;
      HEAP32[$346 >> 2] = $shr$i1738;
      HEAP32[$346 + 4 >> 2] = (($shr$i1738 | 0) < 0) << 31 >> 31;
      $2507 = $319;
      $2510 = $320;
      break L24;
      break;
     }
    case 1:
     {
      $shr$i1472 = $92 >>> 1;
      $335 = $arrayidx209;
      HEAP32[$335 >> 2] = $319;
      HEAP32[$335 + 4 >> 2] = $320;
      $2507 = _bitshift64Ashr(0, _i64Add($87 | 0, $339 | 0, ($shr$i1472 & 2048 | $shr & 16 | $shr$i1472 & 768 | $92 << 2 & 1024 | $shr$i1472 & 64 | $92 << 1 & 128 | $92 >>> 2 & 14 | $92 << 3 & 32) << 20 >> 20 | 0, 0) | 0, 32) | 0;
      $2510 = tempRet0;
      break L24;
      break;
     }
    case 3:
     {
      if (!$and9) {
       $2507 = $319;
       $2510 = $320;
       break L24;
      } else if (($and9 | 0) != 2) {
       $shr$i1713 = ($92 << 19 & -2147483648 | $92 << 24 & 2080374784) >> 14;
       $366 = $s + ($and9 << 3) + 8 | 0;
       HEAP32[$366 >> 2] = $shr$i1713;
       HEAP32[$366 + 4 >> 2] = (($shr$i1713 | 0) < 0) << 31 >> 31;
       $2507 = $319;
       $2510 = $320;
       break L24;
      }
      $shr$i1721 = ($92 >>> 3 & 512 | $92 >>> 2 & 16 | $92 << 1 & 64 | $92 << 4 & 384 | $92 << 3 & 32) << 22 >> 22;
      if (!$shr$i1721) {
       label = 392;
       break L4;
      }
      $350 = $arrayidx;
      $360 = $arrayidx;
      HEAP32[$360 >> 2] = _bitshift64Ashr(0, _i64Add(HEAP32[$350 >> 2] | 0, HEAP32[$350 + 4 >> 2] | 0, $shr$i1721 | 0, 0) | 0, 32) | 0;
      HEAP32[$360 + 4 >> 2] = tempRet0;
      $2507 = $319;
      $2510 = $320;
      break L24;
      break;
     }
    case 4:
     {
      $shr266 = $92 >>> 10;
      $and267 = $shr266 & 3;
      $or270 = $shr & 7 | 8;
      if (($and267 | 0) == 1 | ($and267 | 0) == 0) {
       $retval$0$i1711 = $shr & 32;
       $or274 = $retval$0$i1711 | $92 >>> 2 & 31;
       if ($retval$0$i1711) {
        label = 392;
        break L4;
       }
       $arrayidx283 = $s + ($or270 << 3) + 8 | 0;
       $372 = HEAP32[$arrayidx283 >> 2] | 0;
       if (!$and267) {
        $shr285 = $372 >>> $or274;
        $378 = $arrayidx283;
        HEAP32[$378 >> 2] = $shr285;
        HEAP32[$378 + 4 >> 2] = (($shr285 | 0) < 0) << 31 >> 31;
        $2507 = $319;
        $2510 = $320;
        break L24;
       } else {
        $shr293 = $372 >> $or274;
        $384 = $arrayidx283;
        HEAP32[$384 >> 2] = $shr293;
        HEAP32[$384 + 4 >> 2] = (($shr293 | 0) < 0) << 31 >> 31;
        $2507 = $319;
        $2510 = $320;
        break L24;
       }
      } else if (($and267 | 0) == 2) {
       $shr$i1699 = ($shr & 32 | $92 >>> 2 & 31) << 26 >> 26;
       $arrayidx305 = $s + ($or270 << 3) + 8 | 0;
       $390 = $arrayidx305;
       $397 = HEAP32[$390 + 4 >> 2] & (($shr$i1699 | 0) < 0) << 31 >> 31;
       $398 = $arrayidx305;
       HEAP32[$398 >> 2] = HEAP32[$390 >> 2] & $shr$i1699;
       HEAP32[$398 + 4 >> 2] = $397;
       $2507 = $319;
       $2510 = $320;
       break L24;
      } else if (($and267 | 0) == 3) {
       $or310 = $92 >>> 2 & 7 | 8;
       $or315 = $92 >>> 5 & 3 | $shr266 & 4;
       if (!$or315) {
        $arrayidx318 = $s + ($or270 << 3) + 8 | 0;
        $402 = $arrayidx318;
        $408 = $s + ($or310 << 3) + 8 | 0;
        $414 = _i64Subtract(HEAP32[$402 >> 2] | 0, HEAP32[$402 + 4 >> 2] | 0, HEAP32[$408 >> 2] | 0, HEAP32[$408 + 4 >> 2] | 0) | 0;
        $416 = _bitshift64Ashr(0, $414 | 0, 32) | 0;
        $418 = $arrayidx318;
        HEAP32[$418 >> 2] = $416;
        HEAP32[$418 + 4 >> 2] = tempRet0;
        $2507 = $319;
        $2510 = $320;
        break L24;
       } else if (($or315 | 0) == 1) {
        $arrayidx327 = $s + ($or270 << 3) + 8 | 0;
        $422 = $arrayidx327;
        $428 = $s + ($or310 << 3) + 8 | 0;
        $435 = HEAP32[$428 + 4 >> 2] ^ HEAP32[$422 + 4 >> 2];
        $436 = $arrayidx327;
        HEAP32[$436 >> 2] = HEAP32[$428 >> 2] ^ HEAP32[$422 >> 2];
        HEAP32[$436 + 4 >> 2] = $435;
        $2507 = $319;
        $2510 = $320;
        break L24;
       } else if (($or315 | 0) == 2) {
        $arrayidx334 = $s + ($or270 << 3) + 8 | 0;
        $440 = $arrayidx334;
        $446 = $s + ($or310 << 3) + 8 | 0;
        $453 = HEAP32[$446 + 4 >> 2] | HEAP32[$440 + 4 >> 2];
        $454 = $arrayidx334;
        HEAP32[$454 >> 2] = HEAP32[$446 >> 2] | HEAP32[$440 >> 2];
        HEAP32[$454 + 4 >> 2] = $453;
        $2507 = $319;
        $2510 = $320;
        break L24;
       } else if (($or315 | 0) == 3) {
        $arrayidx342 = $s + ($or270 << 3) + 8 | 0;
        $458 = $arrayidx342;
        $464 = $s + ($or310 << 3) + 8 | 0;
        $471 = HEAP32[$464 + 4 >> 2] & HEAP32[$458 + 4 >> 2];
        $472 = $arrayidx342;
        HEAP32[$472 >> 2] = HEAP32[$464 >> 2] & HEAP32[$458 >> 2];
        HEAP32[$472 + 4 >> 2] = $471;
        $2507 = $319;
        $2510 = $320;
        break L24;
       } else {
        label = 392;
        break L4;
       }
      } else {
       $2507 = $319;
       $2510 = $320;
       break L24;
      }
      break;
     }
    case 5:
     {
      $shr$i1695 = $92 >>> 1;
      $2507 = _bitshift64Ashr(0, _i64Add(($shr$i1695 & 2048 | $shr & 16 | $shr$i1695 & 768 | $92 << 2 & 1024 | $shr$i1695 & 64 | $92 << 1 & 128 | $92 >>> 2 & 14 | $92 << 3 & 32) << 20 >> 20 | 0, 0, $87 | 0, $339 | 0) | 0, 32) | 0;
      $2510 = tempRet0;
      break L24;
      break;
     }
    case 6:
     {
      $480 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      if (!((HEAP32[$480 >> 2] | 0) == 0 & (HEAP32[$480 + 4 >> 2] | 0) == 0)) {
       $2507 = $319;
       $2510 = $320;
       break L24;
      }
      $2507 = _bitshift64Ashr(0, _i64Add(($92 >>> 4 & 256 | $shr & 24 | $92 << 1 & 192 | $92 >>> 2 & 6 | $92 << 3 & 32) << 23 >> 23 | 0, 0, $87 | 0, $339 | 0) | 0, 32) | 0;
      $2510 = tempRet0;
      break L24;
      break;
     }
    case 7:
     {
      $493 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      if ((HEAP32[$493 >> 2] | 0) == 0 & (HEAP32[$493 + 4 >> 2] | 0) == 0) {
       $2507 = $319;
       $2510 = $320;
       break L24;
      }
      $2507 = _bitshift64Ashr(0, _i64Add(($92 >>> 4 & 256 | $shr & 24 | $92 << 1 & 192 | $92 >>> 2 & 6 | $92 << 3 & 32) << 23 >> 23 | 0, 0, $87 | 0, $339 | 0) | 0, 32) | 0;
      $2510 = tempRet0;
      break L24;
      break;
     }
    default:
     {
      label = 392;
      break L4;
     }
    }
    break;
   }
  case 124:
  case 120:
  case 116:
  case 112:
  case 108:
  case 104:
  case 100:
  case 96:
  case 92:
  case 88:
  case 84:
  case 80:
  case 76:
  case 72:
  case 68:
  case 64:
  case 60:
  case 56:
  case 52:
  case 48:
  case 44:
  case 40:
  case 36:
  case 32:
  case 28:
  case 24:
  case 20:
  case 16:
  case 12:
  case 8:
  case 4:
  case 0:
   {
    $95 = _bitshift64Ashr(_i64Add(0, $87 | 0, 0, 2) | 0, tempRet0 | 0, 32) | 0;
    $96 = tempRet0;
    $shr20 = $92 >>> 2;
    $or = $shr20 & 7 | 8;
    switch ($92 >>> 13 & 7 | 0) {
    case 1:
     {
      $111 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      $119 = _bitshift64Ashr(0, _i64Add(HEAP32[$111 >> 2] | 0, HEAP32[$111 + 4 >> 2] | 0, $shr & 56 | $92 << 1 & 192 | 0, 0) | 0, 32) | 0;
      $120 = tempRet0;
      $conv$i1049 = (_bitshift64Lshr($119 | 0, $120 | 0, 12) | 0) & 255;
      $123 = $s + ($conv$i1049 << 4) + 1400 | 0;
      if ((HEAP32[$123 >> 2] | 0) == ($119 & -4033 | 0) ? (HEAP32[$123 + 4 >> 2] | 0) == ($120 | 0) : 0) $storemerge$in$i1060 = (HEAP32[$s + ($conv$i1049 << 4) + 1408 >> 2] | 0) + $119 | 0; else if (!(_target_read_slow($s, $val$i1046, $119, $120, 3) | 0)) $storemerge$in$i1060 = $val$i1046; else break L4;
      $136 = $storemerge$in$i1060;
      $141 = HEAP32[$136 + 4 >> 2] | 0;
      $142 = $s + ($or << 3) + 264 | 0;
      HEAP32[$142 >> 2] = HEAP32[$136 >> 2];
      HEAP32[$142 + 4 >> 2] = $141;
      $2507 = $95;
      $2510 = $96;
      break L24;
      break;
     }
    case 2:
     {
      $146 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      $154 = _bitshift64Ashr(0, _i64Add(HEAP32[$146 >> 2] | 0, HEAP32[$146 + 4 >> 2] | 0, $shr & 56 | $92 >>> 4 & 4 | $92 << 1 & 64 | 0, 0) | 0, 32) | 0;
      $155 = tempRet0;
      $conv$i1132 = (_bitshift64Lshr($154 | 0, $155 | 0, 12) | 0) & 255;
      $158 = $s + ($conv$i1132 << 4) + 1400 | 0;
      if ((HEAP32[$158 >> 2] | 0) == ($154 & -4065 | 0) ? (HEAP32[$158 + 4 >> 2] | 0) == ($155 | 0) : 0) $storemerge$i11451793$ph = HEAP32[(HEAP32[$s + ($conv$i1132 << 4) + 1408 >> 2] | 0) + $154 >> 2] | 0; else {
       if (_target_read_slow($s, $val$i1129, $154, $155, 2) | 0) break L4;
       $storemerge$i11451793$ph = HEAP32[$val$i1129 >> 2] | 0;
      }
      $180 = $s + ($or << 3) + 8 | 0;
      HEAP32[$180 >> 2] = $storemerge$i11451793$ph;
      HEAP32[$180 + 4 >> 2] = (($storemerge$i11451793$ph | 0) < 0) << 31 >> 31;
      $2507 = $95;
      $2510 = $96;
      break L24;
      break;
     }
    case 7:
     {
      $286 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      $294 = _bitshift64Ashr(0, _i64Add(HEAP32[$286 >> 2] | 0, HEAP32[$286 + 4 >> 2] | 0, $shr & 56 | $92 >>> 4 & 4 | $92 << 1 & 64 | 0, 0) | 0, 32) | 0;
      $295 = tempRet0;
      $298 = HEAP32[$s + ($or << 3) + 264 >> 2] | 0;
      $conv$i1391 = (_bitshift64Lshr($294 | 0, $295 | 0, 12) | 0) & 255;
      $304 = $s + ($conv$i1391 << 4) + 5496 | 0;
      if ((HEAP32[$304 >> 2] | 0) == ($294 & -4065 | 0) ? (HEAP32[$304 + 4 >> 2] | 0) == ($295 | 0) : 0) {
       HEAP32[(HEAP32[$s + ($conv$i1391 << 4) + 5504 >> 2] | 0) + $294 >> 2] = $298;
       $2507 = $95;
       $2510 = $96;
       break L24;
      } else if (!(_target_write_slow($s, $294, $295, $298, 0, 2) | 0)) {
       $2507 = $95;
       $2510 = $96;
       break L24;
      } else break L4;
      break;
     }
    case 3:
     {
      $184 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      $192 = _bitshift64Ashr(0, _i64Add(HEAP32[$184 >> 2] | 0, HEAP32[$184 + 4 >> 2] | 0, $shr & 56 | $92 >>> 4 & 4 | $92 << 1 & 64 | 0, 0) | 0, 32) | 0;
      $193 = tempRet0;
      $conv$i1208 = (_bitshift64Lshr($192 | 0, $193 | 0, 12) | 0) & 255;
      $196 = $s + ($conv$i1208 << 4) + 1400 | 0;
      if ((HEAP32[$196 >> 2] | 0) == ($192 & -4065 | 0) ? (HEAP32[$196 + 4 >> 2] | 0) == ($193 | 0) : 0) $storemerge$i12211790$ph = HEAP32[(HEAP32[$s + ($conv$i1208 << 4) + 1408 >> 2] | 0) + $192 >> 2] | 0; else {
       if (_target_read_slow($s, $val$i1205, $192, $193, 2) | 0) break L4;
       $storemerge$i12211790$ph = HEAP32[$val$i1205 >> 2] | 0;
      }
      $216 = $s + ($or << 3) + 264 | 0;
      HEAP32[$216 >> 2] = $storemerge$i12211790$ph;
      HEAP32[$216 + 4 >> 2] = 0;
      $2507 = $95;
      $2510 = $96;
      break L24;
      break;
     }
    case 5:
     {
      $220 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      $228 = _bitshift64Ashr(0, _i64Add(HEAP32[$220 >> 2] | 0, HEAP32[$220 + 4 >> 2] | 0, $shr & 56 | $92 << 1 & 192 | 0, 0) | 0, 32) | 0;
      $229 = tempRet0;
      $230 = $s + ($or << 3) + 264 | 0;
      $232 = HEAP32[$230 >> 2] | 0;
      $235 = HEAP32[$230 + 4 >> 2] | 0;
      $conv$i1233 = (_bitshift64Lshr($228 | 0, $229 | 0, 12) | 0) & 255;
      $238 = $s + ($conv$i1233 << 4) + 5496 | 0;
      if ((HEAP32[$238 >> 2] | 0) == ($228 & -4033 | 0) ? (HEAP32[$238 + 4 >> 2] | 0) == ($229 | 0) : 0) {
       $250 = (HEAP32[$s + ($conv$i1233 << 4) + 5504 >> 2] | 0) + $228 | 0;
       HEAP32[$250 >> 2] = $232;
       HEAP32[$250 + 4 >> 2] = $235;
       $2507 = $95;
       $2510 = $96;
       break L24;
      } else if (!(_target_write_slow($s, $228, $229, $232, $235, 3) | 0)) {
       $2507 = $95;
       $2510 = $96;
       break L24;
      } else break L4;
      break;
     }
    case 6:
     {
      $255 = $s + (($shr & 7 | 8) << 3) + 8 | 0;
      $263 = _bitshift64Ashr(0, _i64Add(HEAP32[$255 >> 2] | 0, HEAP32[$255 + 4 >> 2] | 0, $shr & 56 | $92 >>> 4 & 4 | $92 << 1 & 64 | 0, 0) | 0, 32) | 0;
      $264 = tempRet0;
      $267 = HEAP32[$s + ($or << 3) + 8 >> 2] | 0;
      $conv$i1315 = (_bitshift64Lshr($263 | 0, $264 | 0, 12) | 0) & 255;
      $273 = $s + ($conv$i1315 << 4) + 5496 | 0;
      if ((HEAP32[$273 >> 2] | 0) == ($263 & -4065 | 0) ? (HEAP32[$273 + 4 >> 2] | 0) == ($264 | 0) : 0) {
       HEAP32[(HEAP32[$s + ($conv$i1315 << 4) + 5504 >> 2] | 0) + $263 >> 2] = $267;
       $2507 = $95;
       $2510 = $96;
       break L24;
      } else if (!(_target_write_slow($s, $263, $264, $267, 0, 2) | 0)) {
       $2507 = $95;
       $2510 = $96;
       break L24;
      } else break L4;
      break;
     }
    case 0:
     {
      $or29 = $shr & 48 | $92 >>> 1 & 960 | $92 >>> 4 & 4 | $shr20 & 8;
      if (!$or29) {
       label = 392;
       break L4;
      }
      $97 = $arrayidx;
      $107 = $s + ($or << 3) + 8 | 0;
      HEAP32[$107 >> 2] = _bitshift64Ashr(0, _i64Add(HEAP32[$97 >> 2] | 0, HEAP32[$97 + 4 >> 2] | 0, $or29 | 0, 0) | 0, 32) | 0;
      HEAP32[$107 + 4 >> 2] = tempRet0;
      $2507 = $95;
      $2510 = $96;
      break L24;
      break;
     }
    default:
     {
      label = 392;
      break L4;
     }
    }
    break;
   }
  case 126:
  case 122:
  case 118:
  case 114:
  case 110:
  case 106:
  case 102:
  case 98:
  case 94:
  case 90:
  case 86:
  case 82:
  case 78:
  case 74:
  case 70:
  case 66:
  case 62:
  case 58:
  case 54:
  case 50:
  case 46:
  case 42:
  case 38:
  case 34:
  case 30:
  case 26:
  case 22:
  case 18:
  case 14:
  case 10:
  case 6:
  case 2:
   {
    $508 = _bitshift64Ashr(_i64Add(0, $87 | 0, 0, 2) | 0, tempRet0 | 0, 32) | 0;
    $509 = tempRet0;
    $shr432 = $92 >>> 2;
    $and433 = $shr432 & 31;
    switch ($92 >>> 13 & 7 | 0) {
    case 0:
     {
      $retval$0$i1637 = $shr & 32;
      if ($retval$0$i1637) {
       label = 392;
       break L4;
      }
      if (!$and9) {
       $2507 = $508;
       $2510 = $509;
       break L24;
      }
      $arrayidx445 = $s + ($and9 << 3) + 8 | 0;
      $510 = $arrayidx445;
      $520 = $arrayidx445;
      HEAP32[$520 >> 2] = _bitshift64Ashr(0, _bitshift64Shl(HEAP32[$510 >> 2] | 0, HEAP32[$510 + 4 >> 2] | 0, $retval$0$i1637 | $and433 | 0) | 0, 32) | 0;
      HEAP32[$520 + 4 >> 2] = tempRet0;
      $2507 = $508;
      $2510 = $509;
      break L24;
      break;
     }
    case 1:
     {
      $524 = $arrayidx;
      $532 = _bitshift64Ashr(0, _i64Add(HEAP32[$524 >> 2] | 0, HEAP32[$524 + 4 >> 2] | 0, $shr & 32 | $shr432 & 24 | $92 << 4 & 448 | 0, 0) | 0, 32) | 0;
      $533 = tempRet0;
      $conv$i1610 = (_bitshift64Lshr($532 | 0, $533 | 0, 12) | 0) & 255;
      $536 = $s + ($conv$i1610 << 4) + 1400 | 0;
      if ((HEAP32[$536 >> 2] | 0) == ($532 & -4033 | 0) ? (HEAP32[$536 + 4 >> 2] | 0) == ($533 | 0) : 0) $storemerge$in$i1621 = (HEAP32[$s + ($conv$i1610 << 4) + 1408 >> 2] | 0) + $532 | 0; else if (!(_target_read_slow($s, $val$i1607, $532, $533, 3) | 0)) $storemerge$in$i1621 = $val$i1607; else break L4;
      $549 = $storemerge$in$i1621;
      $554 = HEAP32[$549 + 4 >> 2] | 0;
      $555 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$555 >> 2] = HEAP32[$549 >> 2];
      HEAP32[$555 + 4 >> 2] = $554;
      $2507 = $508;
      $2510 = $509;
      break L24;
      break;
     }
    case 2:
     {
      $559 = $arrayidx;
      $567 = _bitshift64Ashr(0, _i64Add(HEAP32[$559 >> 2] | 0, HEAP32[$559 + 4 >> 2] | 0, $shr & 32 | $shr432 & 28 | $92 << 4 & 192 | 0, 0) | 0, 32) | 0;
      $568 = tempRet0;
      $conv$i1581 = (_bitshift64Lshr($567 | 0, $568 | 0, 12) | 0) & 255;
      $571 = $s + ($conv$i1581 << 4) + 1400 | 0;
      if ((HEAP32[$571 >> 2] | 0) == ($567 & -4065 | 0) ? (HEAP32[$571 + 4 >> 2] | 0) == ($568 | 0) : 0) $storemerge$i15941784$ph = HEAP32[(HEAP32[$s + ($conv$i1581 << 4) + 1408 >> 2] | 0) + $567 >> 2] | 0; else {
       if (_target_read_slow($s, $val$i1578, $567, $568, 2) | 0) break L4;
       $storemerge$i15941784$ph = HEAP32[$val$i1578 >> 2] | 0;
      }
      if (!$and9) {
       $2507 = $508;
       $2510 = $509;
       break L24;
      }
      $593 = $s + ($and9 << 3) + 8 | 0;
      HEAP32[$593 >> 2] = $storemerge$i15941784$ph;
      HEAP32[$593 + 4 >> 2] = (($storemerge$i15941784$ph | 0) < 0) << 31 >> 31;
      $2507 = $508;
      $2510 = $509;
      break L24;
      break;
     }
    case 4:
     {
      $cmp520 = ($and433 | 0) == 0;
      $cmp523 = ($and9 | 0) == 0;
      if (!($92 & 4096)) if ($cmp520) {
       if ($cmp523) {
        label = 392;
        break L4;
       }
       $633 = $s + ($and9 << 3) + 8 | 0;
       $2507 = HEAP32[$633 >> 2] & -2;
       $2510 = HEAP32[$633 + 4 >> 2] | 0;
       break L24;
      } else {
       if ($cmp523) {
        $2507 = $508;
        $2510 = $509;
        break L24;
       }
       $640 = $s + ($and433 << 3) + 8 | 0;
       $645 = HEAP32[$640 + 4 >> 2] | 0;
       $646 = $s + ($and9 << 3) + 8 | 0;
       HEAP32[$646 >> 2] = HEAP32[$640 >> 2];
       HEAP32[$646 + 4 >> 2] = $645;
       $2507 = $508;
       $2510 = $509;
       break L24;
      } else if ($cmp520) {
       if ($cmp523) {
        label = 97;
        break L4;
       }
       $650 = $arrayidx209;
       HEAP32[$650 >> 2] = $508;
       HEAP32[$650 + 4 >> 2] = $509;
       $654 = $s + ($and9 << 3) + 8 | 0;
       $2507 = HEAP32[$654 >> 2] & -2;
       $2510 = HEAP32[$654 + 4 >> 2] | 0;
       break L24;
      } else {
       if ($cmp523) {
        $2507 = $508;
        $2510 = $509;
        break L24;
       }
       $arrayidx559 = $s + ($and9 << 3) + 8 | 0;
       $661 = $arrayidx559;
       $667 = $s + ($and433 << 3) + 8 | 0;
       $673 = _i64Add(HEAP32[$667 >> 2] | 0, HEAP32[$667 + 4 >> 2] | 0, HEAP32[$661 >> 2] | 0, HEAP32[$661 + 4 >> 2] | 0) | 0;
       $675 = _bitshift64Ashr(0, $673 | 0, 32) | 0;
       $677 = $arrayidx559;
       HEAP32[$677 >> 2] = $675;
       HEAP32[$677 + 4 >> 2] = tempRet0;
       $2507 = $508;
       $2510 = $509;
       break L24;
      }
      break;
     }
    case 3:
     {
      $597 = $arrayidx;
      $605 = _bitshift64Ashr(0, _i64Add(HEAP32[$597 >> 2] | 0, HEAP32[$597 + 4 >> 2] | 0, $shr & 32 | $shr432 & 28 | $92 << 4 & 192 | 0, 0) | 0, 32) | 0;
      $606 = tempRet0;
      $conv$i1552 = (_bitshift64Lshr($605 | 0, $606 | 0, 12) | 0) & 255;
      $609 = $s + ($conv$i1552 << 4) + 1400 | 0;
      if ((HEAP32[$609 >> 2] | 0) == ($605 & -4065 | 0) ? (HEAP32[$609 + 4 >> 2] | 0) == ($606 | 0) : 0) $storemerge$i15651781$ph = HEAP32[(HEAP32[$s + ($conv$i1552 << 4) + 1408 >> 2] | 0) + $605 >> 2] | 0; else {
       if (_target_read_slow($s, $val$i1549, $605, $606, 2) | 0) break L4;
       $storemerge$i15651781$ph = HEAP32[$val$i1549 >> 2] | 0;
      }
      $629 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$629 >> 2] = $storemerge$i15651781$ph;
      HEAP32[$629 + 4 >> 2] = 0;
      $2507 = $508;
      $2510 = $509;
      break L24;
      break;
     }
    case 5:
     {
      $681 = $arrayidx;
      $689 = _bitshift64Ashr(0, _i64Add(HEAP32[$681 >> 2] | 0, HEAP32[$681 + 4 >> 2] | 0, $shr & 56 | $92 >>> 1 & 448 | 0, 0) | 0, 32) | 0;
      $690 = tempRet0;
      $691 = $s + ($and433 << 3) + 264 | 0;
      $693 = HEAP32[$691 >> 2] | 0;
      $696 = HEAP32[$691 + 4 >> 2] | 0;
      $conv$i1525 = (_bitshift64Lshr($689 | 0, $690 | 0, 12) | 0) & 255;
      $699 = $s + ($conv$i1525 << 4) + 5496 | 0;
      if ((HEAP32[$699 >> 2] | 0) == ($689 & -4033 | 0) ? (HEAP32[$699 + 4 >> 2] | 0) == ($690 | 0) : 0) {
       $711 = (HEAP32[$s + ($conv$i1525 << 4) + 5504 >> 2] | 0) + $689 | 0;
       HEAP32[$711 >> 2] = $693;
       HEAP32[$711 + 4 >> 2] = $696;
       $2507 = $508;
       $2510 = $509;
       break L24;
      } else if (!(_target_write_slow($s, $689, $690, $693, $696, 3) | 0)) {
       $2507 = $508;
       $2510 = $509;
       break L24;
      } else break L4;
      break;
     }
    case 6:
     {
      $716 = $arrayidx;
      $724 = _bitshift64Ashr(0, _i64Add(HEAP32[$716 >> 2] | 0, HEAP32[$716 + 4 >> 2] | 0, $shr & 60 | $92 >>> 1 & 192 | 0, 0) | 0, 32) | 0;
      $725 = tempRet0;
      $728 = HEAP32[$s + ($and433 << 3) + 8 >> 2] | 0;
      $conv$i1501 = (_bitshift64Lshr($724 | 0, $725 | 0, 12) | 0) & 255;
      $734 = $s + ($conv$i1501 << 4) + 5496 | 0;
      if ((HEAP32[$734 >> 2] | 0) == ($724 & -4065 | 0) ? (HEAP32[$734 + 4 >> 2] | 0) == ($725 | 0) : 0) {
       HEAP32[(HEAP32[$s + ($conv$i1501 << 4) + 5504 >> 2] | 0) + $724 >> 2] = $728;
       $2507 = $508;
       $2510 = $509;
       break L24;
      } else if (!(_target_write_slow($s, $724, $725, $728, 0, 2) | 0)) {
       $2507 = $508;
       $2510 = $509;
       break L24;
      } else break L4;
      break;
     }
    case 7:
     {
      $747 = $arrayidx;
      $755 = _bitshift64Ashr(0, _i64Add(HEAP32[$747 >> 2] | 0, HEAP32[$747 + 4 >> 2] | 0, $shr & 60 | $92 >>> 1 & 192 | 0, 0) | 0, 32) | 0;
      $756 = tempRet0;
      $759 = HEAP32[$s + ($and433 << 3) + 264 >> 2] | 0;
      $conv$i1477 = (_bitshift64Lshr($755 | 0, $756 | 0, 12) | 0) & 255;
      $765 = $s + ($conv$i1477 << 4) + 5496 | 0;
      if ((HEAP32[$765 >> 2] | 0) == ($755 & -4065 | 0) ? (HEAP32[$765 + 4 >> 2] | 0) == ($756 | 0) : 0) {
       HEAP32[(HEAP32[$s + ($conv$i1477 << 4) + 5504 >> 2] | 0) + $755 >> 2] = $759;
       $2507 = $508;
       $2510 = $509;
       break L24;
      } else if (!(_target_write_slow($s, $755, $756, $759, 0, 2) | 0)) {
       $2507 = $508;
       $2510 = $509;
       break L24;
      } else break L4;
      break;
     }
    default:
     {
      label = 392;
      break L4;
     }
    }
    break;
   }
  case 55:
   {
    if (!$and9) {
     $2507 = $90;
     $2510 = $91;
    } else {
     $and626 = $92 & -4096;
     $780 = $s + ($and9 << 3) + 8 | 0;
     HEAP32[$780 >> 2] = $and626;
     HEAP32[$780 + 4 >> 2] = (($and626 | 0) < 0) << 31 >> 31;
     $2507 = $90;
     $2510 = $91;
    }
    break;
   }
  case 23:
   {
    if (!$and9) {
     $2507 = $90;
     $2510 = $91;
    } else {
     $784 = _i64Add($92 & -4096 | 0, 0, $87 | 0, $339 | 0) | 0;
     $786 = _bitshift64Ashr(0, $784 | 0, 32) | 0;
     $788 = $s + ($and9 << 3) + 8 | 0;
     HEAP32[$788 >> 2] = $786;
     HEAP32[$788 + 4 >> 2] = tempRet0;
     $2507 = $90;
     $2510 = $91;
    }
    break;
   }
  case 103:
   {
    if ($and9) {
     $808 = $s + ($and9 << 3) + 8 | 0;
     HEAP32[$808 >> 2] = $90;
     HEAP32[$808 + 4 >> 2] = $91;
    }
    $812 = $s + ($and11 << 3) + 8 | 0;
    $and681 = (_i64Add(HEAP32[$812 >> 2] | 0, HEAP32[$812 + 4 >> 2] | 0, $92 >> 20 | 0, 0) | 0) & -2;
    $2507 = $and681;
    $2510 = (($and681 | 0) < 0) << 31 >> 31;
    break;
   }
  case 99:
   {
    $shr684 = $92 >>> 12;
    $shr686 = $92 >>> 13 & 3;
    if (!$shr686) {
     $822 = $s + ($and11 << 3) + 8 | 0;
     $828 = $s + ($and13 << 3) + 8 | 0;
     $cond$0 = ((HEAP32[$822 >> 2] | 0) == (HEAP32[$828 >> 2] | 0) ? (HEAP32[$822 + 4 >> 2] | 0) == (HEAP32[$828 + 4 >> 2] | 0) : 0) & 1;
    } else if (($shr686 | 0) == 2) {
     $837 = $s + ($and11 << 3) + 8 | 0;
     $842 = HEAP32[$837 + 4 >> 2] | 0;
     $843 = $s + ($and13 << 3) + 8 | 0;
     $848 = HEAP32[$843 + 4 >> 2] | 0;
     $cond$0 = (($842 | 0) < ($848 | 0) | (($842 | 0) == ($848 | 0) ? (HEAP32[$837 >> 2] | 0) >>> 0 < (HEAP32[$843 >> 2] | 0) >>> 0 : 0)) & 1;
    } else if (($shr686 | 0) == 3) {
     $854 = $s + ($and11 << 3) + 8 | 0;
     $859 = HEAP32[$854 + 4 >> 2] | 0;
     $860 = $s + ($and13 << 3) + 8 | 0;
     $865 = HEAP32[$860 + 4 >> 2] | 0;
     $cond$0 = ($859 >>> 0 < $865 >>> 0 | (($859 | 0) == ($865 | 0) ? (HEAP32[$854 >> 2] | 0) >>> 0 < (HEAP32[$860 >> 2] | 0) >>> 0 : 0)) & 1;
    } else {
     label = 392;
     break L4;
    }
    if (($cond$0 | 0) == ($shr684 & 1 | 0)) {
     $2507 = $90;
     $2510 = $91;
    } else {
     $871 = _i64Add(($92 >>> 19 & 4096 | $shr12 & 2016 | $shr & 30 | $92 << 4 & 2048) << 19 >> 19 | 0, 0, $87 | 0, $339 | 0) | 0;
     $873 = _bitshift64Ashr(0, $871 | 0, 32) | 0;
     $2507 = $873;
     $2510 = tempRet0;
    }
    break;
   }
  case 111:
   {
    if (!$and9) {
     $802 = $87;
     $803 = $339;
    } else {
     $792 = $s + ($and9 << 3) + 8 | 0;
     HEAP32[$792 >> 2] = $90;
     HEAP32[$792 + 4 >> 2] = $91;
     $796 = $s;
     $802 = HEAP32[$796 >> 2] | 0;
     $803 = HEAP32[$796 + 4 >> 2] | 0;
    }
    $2507 = _bitshift64Ashr(0, _i64Add($802 | 0, $803 | 0, ($shr12 & 2046 | $92 & 1044480 | $92 >>> 11 & 1048576 | $92 >>> 9 & 2048) << 11 >> 11 | 0, 0) | 0, 32) | 0;
    $2510 = tempRet0;
    break;
   }
  case 3:
   {
    $shr736 = $92 >> 20;
    $875 = $s + ($and11 << 3) + 8 | 0;
    $883 = _i64Add(HEAP32[$875 >> 2] | 0, HEAP32[$875 + 4 >> 2] | 0, $shr736 | 0, (($shr736 | 0) < 0) << 31 >> 31 | 0) | 0;
    $884 = tempRet0;
    switch ($92 >>> 12 & 7 | 0) {
    case 1:
     {
      $conv$i1433 = (_bitshift64Lshr($883 | 0, $884 | 0, 12) | 0) & 255;
      $913 = $s + ($conv$i1433 << 4) + 1400 | 0;
      if ((HEAP32[$913 >> 2] | 0) == ($883 & -4081 | 0) ? (HEAP32[$913 + 4 >> 2] | 0) == ($884 | 0) : 0) $storemerge$i14461774$ph = HEAP16[(HEAP32[$s + ($conv$i1433 << 4) + 1408 >> 2] | 0) + $883 >> 1] | 0; else {
       if (_target_read_slow($s, $val$i1430, $883, $884, 1) | 0) break L4;
       $storemerge$i14461774$ph = HEAP32[$val$i1430 >> 2] & 65535;
      }
      $934 = $storemerge$i14461774$ph << 16 >> 16;
      $1011 = $934;
      $1014 = (($934 | 0) < 0) << 31 >> 31;
      break;
     }
    case 0:
     {
      $conv$i1455 = (_bitshift64Lshr($883 | 0, $884 | 0, 12) | 0) & 255;
      $887 = $s + ($conv$i1455 << 4) + 1400 | 0;
      if ((HEAP32[$887 >> 2] | 0) == ($883 & -4089 | 0) ? (HEAP32[$887 + 4 >> 2] | 0) == ($884 | 0) : 0) $storemerge$i14681778$ph = HEAP8[(HEAP32[$s + ($conv$i1455 << 4) + 1408 >> 2] | 0) + $883 >> 0] | 0; else {
       if (_target_read_slow($s, $val$i1452, $883, $884, 0) | 0) break L4;
       $storemerge$i14681778$ph = HEAP32[$val$i1452 >> 2] & 255;
      }
      $908 = $storemerge$i14681778$ph << 24 >> 24;
      $1011 = $908;
      $1014 = (($908 | 0) < 0) << 31 >> 31;
      break;
     }
    case 2:
     {
      $conv$i1410 = (_bitshift64Lshr($883 | 0, $884 | 0, 12) | 0) & 255;
      $939 = $s + ($conv$i1410 << 4) + 1400 | 0;
      if ((HEAP32[$939 >> 2] | 0) == ($883 & -4065 | 0) ? (HEAP32[$939 + 4 >> 2] | 0) == ($884 | 0) : 0) $storemerge$i14231770$ph = HEAP32[(HEAP32[$s + ($conv$i1410 << 4) + 1408 >> 2] | 0) + $883 >> 2] | 0; else {
       if (_target_read_slow($s, $val$i1407, $883, $884, 2) | 0) break L4;
       $storemerge$i14231770$ph = HEAP32[$val$i1407 >> 2] | 0;
      }
      $1011 = $storemerge$i14231770$ph;
      $1014 = (($storemerge$i14231770$ph | 0) < 0) << 31 >> 31;
      break;
     }
    case 4:
     {
      $conv$i1373 = (_bitshift64Lshr($883 | 0, $884 | 0, 12) | 0) & 255;
      $963 = $s + ($conv$i1373 << 4) + 1400 | 0;
      if ((HEAP32[$963 >> 2] | 0) == ($883 & -4089 | 0) ? (HEAP32[$963 + 4 >> 2] | 0) == ($884 | 0) : 0) $storemerge$i13861766$ph = HEAP8[(HEAP32[$s + ($conv$i1373 << 4) + 1408 >> 2] | 0) + $883 >> 0] | 0; else {
       if (_target_read_slow($s, $val$i1370, $883, $884, 0) | 0) break L4;
       $storemerge$i13861766$ph = HEAP32[$val$i1370 >> 2] & 255;
      }
      $1011 = $storemerge$i13861766$ph & 255;
      $1014 = 0;
      break;
     }
    case 5:
     {
      $conv$i1351 = (_bitshift64Lshr($883 | 0, $884 | 0, 12) | 0) & 255;
      $987 = $s + ($conv$i1351 << 4) + 1400 | 0;
      if ((HEAP32[$987 >> 2] | 0) == ($883 & -4081 | 0) ? (HEAP32[$987 + 4 >> 2] | 0) == ($884 | 0) : 0) $storemerge$i13641762$ph = HEAP16[(HEAP32[$s + ($conv$i1351 << 4) + 1408 >> 2] | 0) + $883 >> 1] | 0; else {
       if (_target_read_slow($s, $val$i1348, $883, $884, 1) | 0) break L4;
       $storemerge$i13641762$ph = HEAP32[$val$i1348 >> 2] & 65535;
      }
      $1011 = $storemerge$i13641762$ph & 65535;
      $1014 = 0;
      break;
     }
    default:
     {
      label = 392;
      break L4;
     }
    }
    if (!$and9) {
     $2507 = $90;
     $2510 = $91;
    } else {
     $1009 = $s + ($and9 << 3) + 8 | 0;
     HEAP32[$1009 >> 2] = $1011;
     HEAP32[$1009 + 4 >> 2] = $1014;
     $2507 = $90;
     $2510 = $91;
    }
    break;
   }
  case 35:
   {
    $and786 = $92 >>> 12 & 7;
    $shr791 = ($and9 | $shr12 & 4064) << 20 >> 20;
    $1015 = $s + ($and11 << 3) + 8 | 0;
    $1023 = _i64Add(HEAP32[$1015 >> 2] | 0, HEAP32[$1015 + 4 >> 2] | 0, $shr791 | 0, (($shr791 | 0) < 0) << 31 >> 31 | 0) | 0;
    $1024 = tempRet0;
    $1027 = HEAP32[$s + ($and13 << 3) + 8 >> 2] | 0;
    if (($and786 | 0) == 1) {
     $1048 = _bitshift64Lshr($1023 | 0, $1024 | 0, 12) | 0;
     $conv$i1301 = $1048 & 255;
     $1050 = $s + ($conv$i1301 << 4) + 5496 | 0;
     if ((HEAP32[$1050 >> 2] | 0) == ($1023 & -4081 | 0) ? (HEAP32[$1050 + 4 >> 2] | 0) == ($1024 | 0) : 0) {
      HEAP16[(HEAP32[$s + ($conv$i1301 << 4) + 5504 >> 2] | 0) + $1023 >> 1] = $1027;
      $2507 = $90;
      $2510 = $91;
      break L24;
     } else if (!(_target_write_slow($s, $1023, $1024, $1027 & 65535, 0, 1) | 0)) {
      $2507 = $90;
      $2510 = $91;
      break L24;
     } else break L4;
    } else if (!$and786) {
     $1031 = _bitshift64Lshr($1023 | 0, $1024 | 0, 12) | 0;
     $conv$i1333 = $1031 & 255;
     $1033 = $s + ($conv$i1333 << 4) + 5496 | 0;
     if ((HEAP32[$1033 >> 2] | 0) == ($1023 & -4089 | 0) ? (HEAP32[$1033 + 4 >> 2] | 0) == ($1024 | 0) : 0) {
      HEAP8[(HEAP32[$s + ($conv$i1333 << 4) + 5504 >> 2] | 0) + $1023 >> 0] = $1027;
      $2507 = $90;
      $2510 = $91;
      break L24;
     } else if (!(_target_write_slow($s, $1023, $1024, $1027 & 255, 0, 0) | 0)) {
      $2507 = $90;
      $2510 = $91;
      break L24;
     } else break L4;
    } else if (($and786 | 0) == 2) {
     $1065 = _bitshift64Lshr($1023 | 0, $1024 | 0, 12) | 0;
     $conv$i1283 = $1065 & 255;
     $1067 = $s + ($conv$i1283 << 4) + 5496 | 0;
     if ((HEAP32[$1067 >> 2] | 0) == ($1023 & -4065 | 0) ? (HEAP32[$1067 + 4 >> 2] | 0) == ($1024 | 0) : 0) {
      HEAP32[(HEAP32[$s + ($conv$i1283 << 4) + 5504 >> 2] | 0) + $1023 >> 2] = $1027;
      $2507 = $90;
      $2510 = $91;
      break L24;
     } else if (!(_target_write_slow($s, $1023, $1024, $1027, 0, 2) | 0)) {
      $2507 = $90;
      $2510 = $91;
      break L24;
     } else break L4;
    } else {
     label = 392;
     break L4;
    }
    break;
   }
  case 19:
   {
    $shr821 = $92 >> 20;
    L206 : do switch ($92 >>> 12 & 7 | 0) {
    case 0:
     {
      $1080 = $s + ($and11 << 3) + 8 | 0;
      $1170 = _bitshift64Ashr(0, _i64Add(HEAP32[$1080 >> 2] | 0, HEAP32[$1080 + 4 >> 2] | 0, $shr821 | 0, 0) | 0, 32) | 0;
      $1173 = tempRet0;
      break;
     }
    case 1:
     {
      if ($shr821 >>> 0 > 31) {
       label = 392;
       break L4;
      }
      $1090 = $s + ($and11 << 3) + 8 | 0;
      $1170 = _bitshift64Ashr(0, _bitshift64Shl(HEAP32[$1090 >> 2] | 0, HEAP32[$1090 + 4 >> 2] | 0, $shr821 & 31 | 0) | 0, 32) | 0;
      $1173 = tempRet0;
      break;
     }
    case 6:
     {
      $1148 = $s + ($and11 << 3) + 8 | 0;
      $1170 = HEAP32[$1148 >> 2] | $shr821;
      $1173 = HEAP32[$1148 + 4 >> 2] | (($shr821 | 0) < 0) << 31 >> 31;
      break;
     }
    case 2:
     {
      $1100 = $s + ($and11 << 3) + 8 | 0;
      $1105 = HEAP32[$1100 + 4 >> 2] | 0;
      $1107 = (($shr821 | 0) < 0) << 31 >> 31;
      $1170 = (($1105 | 0) < ($1107 | 0) | (($1105 | 0) == ($1107 | 0) ? (HEAP32[$1100 >> 2] | 0) >>> 0 < $shr821 >>> 0 : 0)) & 1;
      $1173 = 0;
      break;
     }
    case 3:
     {
      $1114 = $s + ($and11 << 3) + 8 | 0;
      $1119 = HEAP32[$1114 + 4 >> 2] | 0;
      $1121 = (($shr821 | 0) < 0) << 31 >> 31;
      $1170 = ($1119 >>> 0 < $1121 >>> 0 | (($1119 | 0) == ($1121 | 0) ? (HEAP32[$1114 >> 2] | 0) >>> 0 < $shr821 >>> 0 : 0)) & 1;
      $1173 = 0;
      break;
     }
    case 4:
     {
      $1128 = $s + ($and11 << 3) + 8 | 0;
      $1170 = HEAP32[$1128 >> 2] ^ $shr821;
      $1173 = HEAP32[$1128 + 4 >> 2] ^ (($shr821 | 0) < 0) << 31 >> 31;
      break;
     }
    case 5:
     {
      if ($shr821 & -1056) {
       label = 392;
       break L4;
      }
      $1140 = HEAP32[$s + ($and11 << 3) + 8 >> 2] | 0;
      $and873 = $shr821 & 31;
      if (!($shr821 & 1024)) {
       $shr881 = $1140 >>> $and873;
       $1170 = $shr881;
       $1173 = (($shr881 | 0) < 0) << 31 >> 31;
       break L206;
      } else {
       $shr874 = $1140 >> $and873;
       $1170 = $shr874;
       $1173 = (($shr874 | 0) < 0) << 31 >> 31;
       break L206;
      }
      break;
     }
    default:
     {
      $1158 = $s + ($and11 << 3) + 8 | 0;
      $1170 = HEAP32[$1158 >> 2] & $shr821;
      $1173 = HEAP32[$1158 + 4 >> 2] & (($shr821 | 0) < 0) << 31 >> 31;
     }
    } while (0);
    if (!$and9) {
     $2507 = $90;
     $2510 = $91;
    } else {
     $1168 = $s + ($and9 << 3) + 8 | 0;
     HEAP32[$1168 >> 2] = $1170;
     HEAP32[$1168 + 4 >> 2] = $1173;
     $2507 = $90;
     $2510 = $91;
    }
    break;
   }
  case 51:
   {
    $shr903 = $92 >>> 25;
    $1174 = $s + ($and11 << 3) + 8 | 0;
    $1176 = HEAP32[$1174 >> 2] | 0;
    $1179 = HEAP32[$1174 + 4 >> 2] | 0;
    $1180 = $s + ($and13 << 3) + 8 | 0;
    $1182 = HEAP32[$1180 >> 2] | 0;
    $1185 = HEAP32[$1180 + 4 >> 2] | 0;
    $1186 = $val2;
    HEAP32[$1186 >> 2] = $1182;
    HEAP32[$1186 + 4 >> 2] = $1185;
    L223 : do if (($shr903 | 0) == 1) switch ($92 >>> 12 & 7 | 0) {
    case 1:
     {
      $1192 = _bitshift64Ashr(0, $1176 | 0, 32) | 0;
      $1193 = tempRet0;
      ___muldi3(_bitshift64Ashr(0, $1182 | 0, 32) | 0, tempRet0 | 0, $1192 | 0, $1193 | 0) | 0;
      $1238 = tempRet0;
      $1241 = 0;
      break L223;
      break;
     }
    case 2:
     {
      ___muldi3($1182 | 0, 0, _bitshift64Ashr(0, $1176 | 0, 32) | 0, tempRet0 | 0) | 0;
      $1238 = tempRet0;
      $1241 = 0;
      break L223;
      break;
     }
    case 3:
     {
      ___muldi3($1182 | 0, 0, $1176 | 0, 0) | 0;
      $1238 = tempRet0;
      $1241 = 0;
      break L223;
      break;
     }
    case 4:
     {
      if (!$1182) {
       $1238 = -1;
       $1241 = 0;
       break L223;
      }
      if (($1176 | 0) == -2147483648 & ($1182 | 0) == -1) {
       $1238 = -2147483648;
       $1241 = 0;
       break L223;
      }
      $1238 = ($1176 | 0) / ($1182 | 0) | 0;
      $1241 = 0;
      break L223;
      break;
     }
    case 5:
     {
      if (!$1182) {
       $1238 = -1;
       $1241 = 0;
       break L223;
      }
      $1238 = ($1176 >>> 0) / ($1182 >>> 0) | 0;
      $1241 = 0;
      break L223;
      break;
     }
    case 6:
     {
      if (!$1182) $retval$0$i1258 = $1176; else if (($1176 | 0) == -2147483648 & ($1182 | 0) == -1) $retval$0$i1258 = 0; else $retval$0$i1258 = ($1176 | 0) % ($1182 | 0) | 0;
      $1238 = $retval$0$i1258;
      $1241 = 0;
      break L223;
      break;
     }
    case 0:
     {
      $mul = Math_imul($1182, $1176) | 0;
      $1238 = $mul;
      $1241 = (($mul | 0) < 0) << 31 >> 31;
      break L223;
      break;
     }
    case 7:
     {
      if (!$1182) $retval$0$i1253 = $1176; else $retval$0$i1253 = ($1176 >>> 0) % ($1182 >>> 0) | 0;
      $1238 = $retval$0$i1253;
      $1241 = 0;
      break L223;
      break;
     }
    default:
     {
      label = 392;
      break L4;
     }
    } else {
     if ($shr903 & 95) {
      label = 392;
      break L4;
     }
     do switch ($92 >>> 12 & 7 | $92 >>> 27 & 8 | 0) {
     case 0:
      {
       $1238 = _bitshift64Ashr(0, _i64Add($1182 | 0, $1185 | 0, $1176 | 0, $1179 | 0) | 0, 32) | 0;
       $1241 = tempRet0;
       break L223;
       break;
      }
     case 2:
      {
       $1238 = (($1179 | 0) < ($1185 | 0) | ($1179 | 0) == ($1185 | 0) & $1176 >>> 0 < $1182 >>> 0) & 1;
       $1241 = 0;
       break L223;
       break;
      }
     case 3:
      {
       $1238 = ($1179 >>> 0 < $1185 >>> 0 | ($1179 | 0) == ($1185 | 0) & $1176 >>> 0 < $1182 >>> 0) & 1;
       $1241 = 0;
       break L223;
       break;
      }
     case 4:
      {
       $1238 = $1182 ^ $1176;
       $1241 = $1185 ^ $1179;
       break L223;
       break;
      }
     case 5:
      {
       $shr991 = $1176 >>> ($1182 & 31);
       $1238 = $shr991;
       $1241 = (($shr991 | 0) < 0) << 31 >> 31;
       break L223;
       break;
      }
     case 13:
      {
       $shr997 = $1176 >> ($1182 & 31);
       $1238 = $shr997;
       $1241 = (($shr997 | 0) < 0) << 31 >> 31;
       break L223;
       break;
      }
     case 6:
      {
       $1238 = $1182 | $1176;
       $1241 = $1185 | $1179;
       break L223;
       break;
      }
     case 8:
      {
       $1238 = _bitshift64Ashr(0, _i64Subtract($1176 | 0, $1179 | 0, $1182 | 0, $1185 | 0) | 0, 32) | 0;
       $1241 = tempRet0;
       break L223;
       break;
      }
     case 1:
      {
       $1238 = _bitshift64Ashr(0, _bitshift64Shl($1176 | 0, $1179 | 0, $1182 & 31 | 0) | 0, 32) | 0;
       $1241 = tempRet0;
       break L223;
       break;
      }
     case 7:
      {
       $1238 = $1182 & $1176;
       $1241 = $1185 & $1179;
       break L223;
       break;
      }
     default:
      {
       label = 392;
       break L4;
      }
     } while (0);
    } while (0);
    if (!$and9) {
     $2507 = $90;
     $2510 = $91;
    } else {
     $1236 = $s + ($and9 << 3) + 8 | 0;
     HEAP32[$1236 >> 2] = $1238;
     HEAP32[$1236 + 4 >> 2] = $1241;
     $2507 = $90;
     $2510 = $91;
    }
    break;
   }
  case 115:
   {
    $shr1013 = $92 >>> 12;
    if (!($shr1013 & 4)) {
     $1242 = $s + ($and11 << 3) + 8 | 0;
     $1260 = HEAP32[$1242 >> 2] | 0;
     $1261 = HEAP32[$1242 + 4 >> 2] | 0;
    } else {
     $1260 = $and11;
     $1261 = 0;
    }
    $and1024 = $shr1013 & 3;
    if (($and1024 | 0) == 1) {
     if (_csr_read($s, $val2, $shr12, 1) | 0) {
      label = 392;
      break L4;
     }
     $1254 = _bitshift64Ashr(0, HEAP32[$val2 >> 2] | 0, 32) | 0;
     $1255 = tempRet0;
     $1256 = $val2;
     HEAP32[$1256 >> 2] = $1254;
     HEAP32[$1256 + 4 >> 2] = $1255;
     $1262 = _csr_write($s, $shr12, $1260, $1261) | 0;
     if (($1262 | 0) < 0) {
      label = 392;
      break L4;
     }
     if ($and9) {
      $1263 = $s + ($and9 << 3) + 8 | 0;
      HEAP32[$1263 >> 2] = $1254;
      HEAP32[$1263 + 4 >> 2] = $1255;
     }
     if (($1262 | 0) > 0) {
      label = 220;
      break L4;
     } else {
      $2507 = $90;
      $2510 = $91;
      break L24;
     }
    } else if (!$and1024) {
     switch ($shr12 | 0) {
     case 0:
      {
       label = 232;
       break L4;
       break;
      }
     case 258:
      {
       label = 236;
       break L4;
       break;
      }
     case 1:
      {
       label = 234;
       break L4;
       break;
      }
     case 770:
      {
       label = 242;
       break L4;
       break;
      }
     case 260:
      break;
     case 261:
      {
       if ($92 & 32640) {
        label = 392;
        break L4;
       }
       $1430 = $mip;
       $1436 = $mie;
       if ((HEAP32[$1436 >> 2] & HEAP32[$1430 >> 2] | 0) == 0 ? (HEAP32[$1436 + 4 >> 2] & HEAP32[$1430 + 4 >> 2] | 0) == 0 : 0) {
        label = 255;
        break L4;
       } else {
        $2507 = $90;
        $2510 = $91;
        break L24;
       }
       break;
      }
     default:
      {
       label = 392;
       break L4;
      }
     }
     if ($92 & 32640) {
      label = 392;
      break L4;
     }
     if (!(HEAP8[$priv1125 >> 0] | 0)) {
      label = 392;
      break L4;
     }
     if (!$and11) {
      $i$07$i$i = 0;
      do {
       $1406 = $s + ($i$07$i$i << 4) + 1400 | 0;
       HEAP32[$1406 >> 2] = -1;
       HEAP32[$1406 + 4 >> 2] = -1;
       $1410 = $s + ($i$07$i$i << 4) + 5496 | 0;
       HEAP32[$1410 >> 2] = -1;
       HEAP32[$1410 + 4 >> 2] = -1;
       $1414 = $s + ($i$07$i$i << 4) + 9592 | 0;
       HEAP32[$1414 >> 2] = -1;
       HEAP32[$1414 + 4 >> 2] = -1;
       $i$07$i$i = $i$07$i$i + 1 | 0;
      } while (($i$07$i$i | 0) != 256);
      $2507 = $90;
      $2510 = $91;
     } else {
      $i$07$i$i$i = 0;
      do {
       $1418 = $s + ($i$07$i$i$i << 4) + 1400 | 0;
       HEAP32[$1418 >> 2] = -1;
       HEAP32[$1418 + 4 >> 2] = -1;
       $1422 = $s + ($i$07$i$i$i << 4) + 5496 | 0;
       HEAP32[$1422 >> 2] = -1;
       HEAP32[$1422 + 4 >> 2] = -1;
       $1426 = $s + ($i$07$i$i$i << 4) + 9592 | 0;
       HEAP32[$1426 >> 2] = -1;
       HEAP32[$1426 + 4 >> 2] = -1;
       $i$07$i$i$i = $i$07$i$i$i + 1 | 0;
      } while (($i$07$i$i$i | 0) != 256);
      $2507 = $90;
      $2510 = $91;
     }
    } else if (($and1024 | 0) == 3 | ($and1024 | 0) == 2) {
     $cmp1049 = ($and11 | 0) != 0;
     if (_csr_read($s, $val2, $shr12, $cmp1049 & 1) | 0) {
      label = 392;
      break L4;
     }
     $1277 = _bitshift64Ashr(0, HEAP32[$val2 >> 2] | 0, 32) | 0;
     $1278 = tempRet0;
     $1279 = $val2;
     HEAP32[$1279 >> 2] = $1277;
     HEAP32[$1279 + 4 >> 2] = $1278;
     if ($cmp1049) {
      if (($and1024 | 0) == 2) {
       $1289 = $1277 | $1260;
       $1290 = $1278 | $1261;
      } else {
       $1289 = $1277 & ~$1260;
       $1290 = $1278 & ~$1261;
      }
      $1291 = _csr_write($s, $shr12, $1289, $1290) | 0;
      if (($1291 | 0) < 0) {
       label = 392;
       break L4;
      } else $err$0 = $1291;
     } else $err$0 = 0;
     if ($and9) {
      $1292 = $s + ($and9 << 3) + 8 | 0;
      HEAP32[$1292 >> 2] = $1277;
      HEAP32[$1292 + 4 >> 2] = $1278;
     }
     if (($err$0 | 0) > 0) {
      label = 230;
      break L4;
     } else {
      $2507 = $90;
      $2510 = $91;
      break L24;
     }
    } else {
     label = 392;
     break L4;
    }
    break;
   }
  case 15:
   {
    $and1157 = $92 >>> 12 & 7;
    if (!$and1157) if (!($92 & -267387008)) {
     $2507 = $90;
     $2510 = $91;
     break L24;
    } else {
     label = 392;
     break L4;
    } else if (($and1157 | 0) == 1) if (($92 | 0) == 4111) {
     $2507 = $90;
     $2510 = $91;
     break L24;
    } else {
     label = 392;
     break L4;
    } else {
     label = 392;
     break L4;
    }
    break;
   }
  case 47:
   {
    if (($92 & 28672 | 0) != 8192) {
     label = 392;
     break L4;
    }
    $1451 = $s + ($and11 << 3) + 8 | 0;
    $1453 = HEAP32[$1451 >> 2] | 0;
    $1456 = HEAP32[$1451 + 4 >> 2] | 0;
    $shr1177 = $92 >>> 27;
    L301 : do switch ($shr1177 | 0) {
    case 2:
     {
      if ($and13) {
       label = 392;
       break L4;
      }
      $conv$i1112 = (_bitshift64Lshr($1453 | 0, $1456 | 0, 12) | 0) & 255;
      $1459 = $s + ($conv$i1112 << 4) + 1400 | 0;
      if ((HEAP32[$1459 >> 2] | 0) == ($1453 & -4065 | 0) ? (HEAP32[$1459 + 4 >> 2] | 0) == ($1456 | 0) : 0) $storemerge$i11251754$ph = HEAP32[(HEAP32[$s + ($conv$i1112 << 4) + 1408 >> 2] | 0) + $1453 >> 2] | 0; else {
       if (_target_read_slow($s, $val$i1109, $1453, $1456, 2) | 0) break L4;
       $storemerge$i11251754$ph = HEAP32[$val$i1109 >> 2] | 0;
      }
      $1481 = $load_res;
      HEAP32[$1481 >> 2] = $1453;
      HEAP32[$1481 + 4 >> 2] = $1456;
      $1609 = $storemerge$i11251754$ph;
      $1612 = (($storemerge$i11251754$ph | 0) < 0) << 31 >> 31;
      break;
     }
    case 3:
     {
      $1485 = $load_res;
      if ((HEAP32[$1485 >> 2] | 0) == ($1453 | 0) ? (HEAP32[$1485 + 4 >> 2] | 0) == ($1456 | 0) : 0) {
       $1496 = HEAP32[$s + ($and13 << 3) + 8 >> 2] | 0;
       $1500 = _bitshift64Lshr($1453 | 0, $1456 | 0, 12) | 0;
       $conv$i1093 = $1500 & 255;
       $1502 = $s + ($conv$i1093 << 4) + 5496 | 0;
       if ((HEAP32[$1502 >> 2] | 0) == ($1453 & -4065 | 0) ? (HEAP32[$1502 + 4 >> 2] | 0) == ($1456 | 0) : 0) {
        HEAP32[(HEAP32[$s + ($conv$i1093 << 4) + 5504 >> 2] | 0) + $1453 >> 2] = $1496;
        $1609 = 0;
        $1612 = 0;
        break L301;
       } else if (!(_target_write_slow($s, $1453, $1456, $1496, 0, 2) | 0)) {
        $1609 = 0;
        $1612 = 0;
        break L301;
       } else break L4;
      } else {
       $1609 = 1;
       $1612 = 0;
      }
      break;
     }
    case 28:
    case 24:
    case 20:
    case 16:
    case 8:
    case 12:
    case 4:
    case 0:
    case 1:
     {
      $conv$i1071 = (_bitshift64Lshr($1453 | 0, $1456 | 0, 12) | 0) & 255;
      $1517 = $s + ($conv$i1071 << 4) + 1400 | 0;
      $1523 = $1453 & -4065;
      if ((HEAP32[$1517 >> 2] | 0) == ($1523 | 0) ? (HEAP32[$1517 + 4 >> 2] | 0) == ($1456 | 0) : 0) $storemerge$i11251758$ph = HEAP32[(HEAP32[$s + ($conv$i1071 << 4) + 1408 >> 2] | 0) + $1453 >> 2] | 0; else {
       if (_target_read_slow($s, $val$i1068, $1453, $1456, 2) | 0) break L4;
       $storemerge$i11251758$ph = HEAP32[$val$i1068 >> 2] | 0;
      }
      $1538 = (($storemerge$i11251758$ph | 0) < 0) << 31 >> 31;
      $1539 = $s + ($and13 << 3) + 8 | 0;
      $1541 = HEAP32[$1539 >> 2] | 0;
      $1544 = HEAP32[$1539 + 4 >> 2] | 0;
      $1545 = $val2;
      HEAP32[$1545 >> 2] = $1541;
      HEAP32[$1545 + 4 >> 2] = $1544;
      switch ($shr1177 | 0) {
      case 0:
       {
        $1551 = _bitshift64Ashr(0, _i64Add($1541 | 0, $1544 | 0, $storemerge$i11251758$ph | 0, $1538 | 0) | 0, 32) | 0;
        $1552 = tempRet0;
        $1553 = $val2;
        HEAP32[$1553 >> 2] = $1551;
        HEAP32[$1553 + 4 >> 2] = $1552;
        $1605 = $1551;
        $2523 = $1552;
        break;
       }
      case 24:
       {
        if ($storemerge$i11251758$ph >>> 0 < $1541 >>> 0) {
         $1586 = $val2;
         HEAP32[$1586 >> 2] = $storemerge$i11251758$ph;
         HEAP32[$1586 + 4 >> 2] = $1538;
         $1605 = $storemerge$i11251758$ph;
         $2523 = $1538;
        } else {
         $1605 = $1541;
         $2523 = $1544;
        }
        break;
       }
      case 28:
       {
        if ($storemerge$i11251758$ph >>> 0 > $1541 >>> 0) {
         $1590 = $val2;
         HEAP32[$1590 >> 2] = $storemerge$i11251758$ph;
         HEAP32[$1590 + 4 >> 2] = $1538;
         $1605 = $storemerge$i11251758$ph;
         $2523 = $1538;
        } else {
         $1605 = $1541;
         $2523 = $1544;
        }
        break;
       }
      case 4:
       {
        $1544 ^ $1538;
        $1558 = _bitshift64Ashr(0, $1541 ^ $storemerge$i11251758$ph | 0, 32) | 0;
        $1559 = tempRet0;
        $1560 = $val2;
        HEAP32[$1560 >> 2] = $1558;
        HEAP32[$1560 + 4 >> 2] = $1559;
        $1605 = $1558;
        $2523 = $1559;
        break;
       }
      case 12:
       {
        $1544 & $1538;
        $1565 = _bitshift64Ashr(0, $1541 & $storemerge$i11251758$ph | 0, 32) | 0;
        $1566 = tempRet0;
        $1567 = $val2;
        HEAP32[$1567 >> 2] = $1565;
        HEAP32[$1567 + 4 >> 2] = $1566;
        $1605 = $1565;
        $2523 = $1566;
        break;
       }
      case 8:
       {
        $1544 | $1538;
        $1572 = _bitshift64Ashr(0, $1541 | $storemerge$i11251758$ph | 0, 32) | 0;
        $1573 = tempRet0;
        $1574 = $val2;
        HEAP32[$1574 >> 2] = $1572;
        HEAP32[$1574 + 4 >> 2] = $1573;
        $1605 = $1572;
        $2523 = $1573;
        break;
       }
      case 16:
       {
        if (($storemerge$i11251758$ph | 0) < ($1541 | 0)) {
         $1578 = $val2;
         HEAP32[$1578 >> 2] = $storemerge$i11251758$ph;
         HEAP32[$1578 + 4 >> 2] = $1538;
         $1605 = $storemerge$i11251758$ph;
         $2523 = $1538;
        } else {
         $1605 = $1541;
         $2523 = $1544;
        }
        break;
       }
      case 20:
       {
        if (($storemerge$i11251758$ph | 0) > ($1541 | 0)) {
         $1582 = $val2;
         HEAP32[$1582 >> 2] = $storemerge$i11251758$ph;
         HEAP32[$1582 + 4 >> 2] = $1538;
         $1605 = $storemerge$i11251758$ph;
         $2523 = $1538;
        } else {
         $1605 = $1541;
         $2523 = $1544;
        }
        break;
       }
      case 1:
       {
        $1605 = $1541;
        $2523 = $1544;
        break;
       }
      default:
       {
        label = 392;
        break L4;
       }
      }
      $1594 = $s + ($conv$i1071 << 4) + 5496 | 0;
      if ((HEAP32[$1594 >> 2] | 0) == ($1523 | 0) ? (HEAP32[$1594 + 4 >> 2] | 0) == ($1456 | 0) : 0) {
       HEAP32[(HEAP32[$s + ($conv$i1071 << 4) + 5504 >> 2] | 0) + $1453 >> 2] = $1605;
       $1609 = $storemerge$i11251758$ph;
       $1612 = $1538;
       break L301;
      } else if (!(_target_write_slow($s, $1453, $1456, $1605, 0, 2) | 0)) {
       $1609 = $storemerge$i11251758$ph;
       $1612 = $1538;
       break L301;
      } else break L4;
      break;
     }
    default:
     {
      label = 392;
      break L4;
     }
    } while (0);
    if (!$and9) {
     $2507 = $90;
     $2510 = $91;
    } else {
     $1607 = $s + ($and9 << 3) + 8 | 0;
     HEAP32[$1607 >> 2] = $1609;
     HEAP32[$1607 + 4 >> 2] = $1612;
     $2507 = $90;
     $2510 = $91;
    }
    break;
   }
  case 7:
   {
    $and1281 = $92 >>> 12 & 7;
    $shr1282 = $92 >> 20;
    $1613 = $s + ($and11 << 3) + 8 | 0;
    $1621 = _i64Add(HEAP32[$1613 >> 2] | 0, HEAP32[$1613 + 4 >> 2] | 0, $shr1282 | 0, (($shr1282 | 0) < 0) << 31 >> 31 | 0) | 0;
    $1622 = tempRet0;
    if (($and1281 | 0) == 3) {
     $1649 = _bitshift64Lshr($1621 | 0, $1622 | 0, 12) | 0;
     $conv$i998 = $1649 & 255;
     $1651 = $s + ($conv$i998 << 4) + 1400 | 0;
     if ((HEAP32[$1651 >> 2] | 0) == ($1621 & -4033 | 0) ? (HEAP32[$1651 + 4 >> 2] | 0) == ($1622 | 0) : 0) $storemerge$in$i = (HEAP32[$s + ($conv$i998 << 4) + 1408 >> 2] | 0) + $1621 | 0; else if (!(_target_read_slow($s, $val$i, $1621, $1622, 3) | 0)) $storemerge$in$i = $val$i; else break L4;
     $1664 = $storemerge$in$i;
     $1669 = HEAP32[$1664 + 4 >> 2] | 0;
     $1670 = $s + ($and9 << 3) + 264 | 0;
     HEAP32[$1670 >> 2] = HEAP32[$1664 >> 2];
     HEAP32[$1670 + 4 >> 2] = $1669;
     $2507 = $90;
     $2510 = $91;
     break L24;
    } else if (($and1281 | 0) != 2) {
     label = 392;
     break L4;
    }
    $conv$i1015 = (_bitshift64Lshr($1621 | 0, $1622 | 0, 12) | 0) & 255;
    $1625 = $s + ($conv$i1015 << 4) + 1400 | 0;
    if ((HEAP32[$1625 >> 2] | 0) == ($1621 & -4065 | 0) ? (HEAP32[$1625 + 4 >> 2] | 0) == ($1622 | 0) : 0) $storemerge$i10271753$ph = HEAP32[(HEAP32[$s + ($conv$i1015 << 4) + 1408 >> 2] | 0) + $1621 >> 2] | 0; else {
     if (_target_read_slow($s, $val$i1012, $1621, $1622, 2) | 0) break L4;
     $storemerge$i10271753$ph = HEAP32[$val$i1012 >> 2] | 0;
    }
    $1645 = $s + ($and9 << 3) + 264 | 0;
    HEAP32[$1645 >> 2] = $storemerge$i10271753$ph;
    HEAP32[$1645 + 4 >> 2] = 0;
    $2507 = $90;
    $2510 = $91;
    break;
   }
  case 39:
   {
    $and1308 = $92 >>> 12 & 7;
    $shr1313 = ($and9 | $shr12 & 4064) << 20 >> 20;
    $1674 = $s + ($and11 << 3) + 8 | 0;
    $1682 = _i64Add(HEAP32[$1674 >> 2] | 0, HEAP32[$1674 + 4 >> 2] | 0, $shr1313 | 0, (($shr1313 | 0) < 0) << 31 >> 31 | 0) | 0;
    $1683 = tempRet0;
    $1684 = $s + ($and13 << 3) + 264 | 0;
    $1686 = HEAP32[$1684 >> 2] | 0;
    $1689 = HEAP32[$1684 + 4 >> 2] | 0;
    if (($and1308 | 0) == 3) {
     $1705 = _bitshift64Lshr($1682 | 0, $1683 | 0, 12) | 0;
     $conv$i968 = $1705 & 255;
     $1707 = $s + ($conv$i968 << 4) + 5496 | 0;
     if ((HEAP32[$1707 >> 2] | 0) == ($1682 & -4033 | 0) ? (HEAP32[$1707 + 4 >> 2] | 0) == ($1683 | 0) : 0) {
      $1719 = (HEAP32[$s + ($conv$i968 << 4) + 5504 >> 2] | 0) + $1682 | 0;
      HEAP32[$1719 >> 2] = $1686;
      HEAP32[$1719 + 4 >> 2] = $1689;
      $2507 = $90;
      $2510 = $91;
      break L24;
     } else if (!(_target_write_slow($s, $1682, $1683, $1686, $1689, 3) | 0)) {
      $2507 = $90;
      $2510 = $91;
      break L24;
     } else break L4;
    } else if (($and1308 | 0) == 2) {
     $1690 = _bitshift64Lshr($1682 | 0, $1683 | 0, 12) | 0;
     $conv$i982 = $1690 & 255;
     $1692 = $s + ($conv$i982 << 4) + 5496 | 0;
     if ((HEAP32[$1692 >> 2] | 0) == ($1682 & -4065 | 0) ? (HEAP32[$1692 + 4 >> 2] | 0) == ($1683 | 0) : 0) {
      HEAP32[(HEAP32[$s + ($conv$i982 << 4) + 5504 >> 2] | 0) + $1682 >> 2] = $1686;
      $2507 = $90;
      $2510 = $91;
      break L24;
     } else if (!(_target_write_slow($s, $1682, $1683, $1686, 0, 2) | 0)) {
      $2507 = $90;
      $2510 = $91;
      break L24;
     } else break L4;
    } else {
     label = 392;
     break L4;
    }
    break;
   }
  case 67:
   {
    $shr1336 = $92 >>> 27;
    $and1338 = $92 >>> 12 & 3;
    $and1335 = $92 >>> 25 & 3;
    if (!$and1335) {
     $1742 = $s + ($and9 << 3) + 264 | 0;
     HEAP32[$1742 >> 2] = _fma_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, HEAP32[$s + ($shr1336 << 3) + 264 >> 2] | 0, $and1338, $fflags) | 0;
     HEAP32[$1742 + 4 >> 2] = 0;
     $2507 = $90;
     $2510 = $91;
     break L24;
    } else if (($and1335 | 0) == 1) {
     $1746 = $s + ($and11 << 3) + 264 | 0;
     $1752 = $s + ($and13 << 3) + 264 | 0;
     $1758 = $s + ($shr1336 << 3) + 264 | 0;
     $1764 = _fma_sf64(HEAP32[$1746 >> 2] | 0, HEAP32[$1746 + 4 >> 2] | 0, HEAP32[$1752 >> 2] | 0, HEAP32[$1752 + 4 >> 2] | 0, HEAP32[$1758 >> 2] | 0, HEAP32[$1758 + 4 >> 2] | 0, $and1338, $fflags) | 0;
     $1766 = $s + ($and9 << 3) + 264 | 0;
     HEAP32[$1766 >> 2] = $1764;
     HEAP32[$1766 + 4 >> 2] = tempRet0;
     $2507 = $90;
     $2510 = $91;
     break L24;
    } else {
     label = 392;
     break L4;
    }
    break;
   }
  case 71:
   {
    $shr1374 = $92 >>> 27;
    $and1376 = $92 >>> 12 & 3;
    $and1373 = $92 >>> 25 & 3;
    if (!$and1373) {
     $1789 = $s + ($and9 << 3) + 264 | 0;
     HEAP32[$1789 >> 2] = _fma_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, HEAP32[$s + ($shr1374 << 3) + 264 >> 2] ^ -2147483648, $and1376, $fflags) | 0;
     HEAP32[$1789 + 4 >> 2] = 0;
     $2507 = $90;
     $2510 = $91;
     break L24;
    } else if (($and1373 | 0) == 1) {
     $1793 = $s + ($and11 << 3) + 264 | 0;
     $1799 = $s + ($and13 << 3) + 264 | 0;
     $1805 = $s + ($shr1374 << 3) + 264 | 0;
     $1812 = _fma_sf64(HEAP32[$1793 >> 2] | 0, HEAP32[$1793 + 4 >> 2] | 0, HEAP32[$1799 >> 2] | 0, HEAP32[$1799 + 4 >> 2] | 0, HEAP32[$1805 >> 2] | 0, HEAP32[$1805 + 4 >> 2] ^ -2147483648, $and1376, $fflags) | 0;
     $1814 = $s + ($and9 << 3) + 264 | 0;
     HEAP32[$1814 >> 2] = $1812;
     HEAP32[$1814 + 4 >> 2] = tempRet0;
     $2507 = $90;
     $2510 = $91;
     break L24;
    } else {
     label = 392;
     break L4;
    }
    break;
   }
  case 75:
   {
    $shr1415 = $92 >>> 27;
    $and1417 = $92 >>> 12 & 3;
    $and1414 = $92 >>> 25 & 3;
    if (!$and1414) {
     $1837 = $s + ($and9 << 3) + 264 | 0;
     HEAP32[$1837 >> 2] = _fma_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] ^ -2147483648, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, HEAP32[$s + ($shr1415 << 3) + 264 >> 2] | 0, $and1417, $fflags) | 0;
     HEAP32[$1837 + 4 >> 2] = 0;
     $2507 = $90;
     $2510 = $91;
     break L24;
    } else if (($and1414 | 0) == 1) {
     $1841 = $s + ($and11 << 3) + 264 | 0;
     $1848 = $s + ($and13 << 3) + 264 | 0;
     $1854 = $s + ($shr1415 << 3) + 264 | 0;
     $1860 = _fma_sf64(HEAP32[$1841 >> 2] | 0, HEAP32[$1841 + 4 >> 2] ^ -2147483648, HEAP32[$1848 >> 2] | 0, HEAP32[$1848 + 4 >> 2] | 0, HEAP32[$1854 >> 2] | 0, HEAP32[$1854 + 4 >> 2] | 0, $and1417, $fflags) | 0;
     $1862 = $s + ($and9 << 3) + 264 | 0;
     HEAP32[$1862 >> 2] = $1860;
     HEAP32[$1862 + 4 >> 2] = tempRet0;
     $2507 = $90;
     $2510 = $91;
     break L24;
    } else {
     label = 392;
     break L4;
    }
    break;
   }
  case 79:
   {
    $shr1456 = $92 >>> 27;
    $and1458 = $92 >>> 12 & 3;
    $and1455 = $92 >>> 25 & 3;
    if (!$and1455) {
     $1886 = $s + ($and9 << 3) + 264 | 0;
     HEAP32[$1886 >> 2] = _fma_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] ^ -2147483648, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, HEAP32[$s + ($shr1456 << 3) + 264 >> 2] ^ -2147483648, $and1458, $fflags) | 0;
     HEAP32[$1886 + 4 >> 2] = 0;
     $2507 = $90;
     $2510 = $91;
     break L24;
    } else if (($and1455 | 0) == 1) {
     $1890 = $s + ($and11 << 3) + 264 | 0;
     $1897 = $s + ($and13 << 3) + 264 | 0;
     $1903 = $s + ($shr1456 << 3) + 264 | 0;
     $1910 = _fma_sf64(HEAP32[$1890 >> 2] | 0, HEAP32[$1890 + 4 >> 2] ^ -2147483648, HEAP32[$1897 >> 2] | 0, HEAP32[$1897 + 4 >> 2] | 0, HEAP32[$1903 >> 2] | 0, HEAP32[$1903 + 4 >> 2] ^ -2147483648, $and1458, $fflags) | 0;
     $1912 = $s + ($and9 << 3) + 264 | 0;
     HEAP32[$1912 >> 2] = $1910;
     HEAP32[$1912 + 4 >> 2] = tempRet0;
     $2507 = $90;
     $2510 = $91;
     break L24;
    } else {
     label = 392;
     break L4;
    }
    break;
   }
  case 83:
   {
    $and1499 = $92 >>> 12 & 3;
    do switch ($92 >>> 25 | 0) {
    case 0:
     {
      $1928 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$1928 >> 2] = _add_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, $and1499, $fflags) | 0;
      HEAP32[$1928 + 4 >> 2] = 0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 80:
     {
      if (!$and1499) $val$7$in = _le_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, $fflags) | 0; else if (($and1499 | 0) == 1) $val$7$in = _lt_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, $fflags) | 0; else if (($and1499 | 0) == 2) $val$7$in = _eq_quiet_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, $fflags) | 0; else {
       label = 392;
       break L4;
      }
      if (!$and9) {
       $2507 = $90;
       $2510 = $91;
       break L24;
      }
      $2137 = $s + ($and9 << 3) + 8 | 0;
      HEAP32[$2137 >> 2] = $val$7$in;
      HEAP32[$2137 + 4 >> 2] = (($val$7$in | 0) < 0) << 31 >> 31;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 4:
     {
      $1944 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$1944 >> 2] = _sub_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, $and1499, $fflags) | 0;
      HEAP32[$1944 + 4 >> 2] = 0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 8:
     {
      $1960 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$1960 >> 2] = _mul_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, $and1499, $fflags) | 0;
      HEAP32[$1960 + 4 >> 2] = 0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 44:
     {
      if ($and13) {
       label = 392;
       break L4;
      }
      $1986 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$1986 >> 2] = _sqrt_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, $and1499, $fflags) | 0;
      HEAP32[$1986 + 4 >> 2] = 0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 12:
     {
      $1976 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$1976 >> 2] = _div_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, $and1499, $fflags) | 0;
      HEAP32[$1976 + 4 >> 2] = 0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 16:
     {
      if (!$and1499) {
       $1997 = $s + ($and13 << 3) + 264 | 0;
       $2002 = HEAP32[$1997 + 4 >> 2] | 0;
       $2005 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2005 >> 2] = HEAP32[$1997 >> 2] & -2147483648 | HEAP32[$s + ($and11 << 3) + 264 >> 2] & 2147483647;
       HEAP32[$2005 + 4 >> 2] = $2002;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else if (($and1499 | 0) == 1) {
       $2016 = $s + ($and13 << 3) + 264 | 0;
       $2025 = ~HEAP32[$2016 + 4 >> 2];
       $2026 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2026 >> 2] = (HEAP32[$2016 >> 2] & -2147483648 | HEAP32[$s + ($and11 << 3) + 264 >> 2] & 2147483647) ^ -2147483648;
       HEAP32[$2026 + 4 >> 2] = $2025;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else if (($and1499 | 0) == 2) {
       $2030 = $s + ($and11 << 3) + 264 | 0;
       $2036 = $s + ($and13 << 3) + 264 | 0;
       $2044 = HEAP32[$2036 + 4 >> 2] ^ HEAP32[$2030 + 4 >> 2];
       $2045 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2045 >> 2] = HEAP32[$2036 >> 2] & -2147483648 ^ HEAP32[$2030 >> 2];
       HEAP32[$2045 + 4 >> 2] = $2044;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else {
       label = 392;
       break L4;
      }
      break;
     }
    case 20:
     {
      if (!$and1499) {
       $2061 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2061 >> 2] = _min_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, $fflags) | 0;
       HEAP32[$2061 + 4 >> 2] = 0;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else if (($and1499 | 0) == 1) {
       $2077 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2077 >> 2] = _max_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, HEAP32[$s + ($and13 << 3) + 264 >> 2] | 0, $fflags) | 0;
       HEAP32[$2077 + 4 >> 2] = 0;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else {
       label = 392;
       break L4;
      }
      break;
     }
    case 96:
     {
      if (!$and13) $val$6$in = _cvt_sf32_i32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, $and1499, $fflags) | 0; else if (($and13 | 0) == 1) $val$6$in = _cvt_sf32_u32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, $and1499, $fflags) | 0; else {
       label = 392;
       break L4;
      }
      if (!$and9) {
       $2507 = $90;
       $2510 = $91;
       break L24;
      }
      $2095 = $s + ($and9 << 3) + 8 | 0;
      HEAP32[$2095 >> 2] = $val$6$in;
      HEAP32[$2095 + 4 >> 2] = (($val$6$in | 0) < 0) << 31 >> 31;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 104:
     {
      if (!$and13) {
       $2147 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2147 >> 2] = _cvt_i32_sf32(HEAP32[$s + ($and11 << 3) + 8 >> 2] | 0, $and1499, $fflags) | 0;
       HEAP32[$2147 + 4 >> 2] = 0;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else if (($and13 | 0) == 1) {
       $2157 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2157 >> 2] = _cvt_u32_sf32(HEAP32[$s + ($and11 << 3) + 8 >> 2] | 0, $and1499, $fflags) | 0;
       HEAP32[$2157 + 4 >> 2] = 0;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else {
       label = 392;
       break L4;
      }
      break;
     }
    case 64:
     {
      if (($and13 | 0) != 1) {
       label = 392;
       break L4;
      }
      $2161 = $s + ($and11 << 3) + 264 | 0;
      $2168 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$2168 >> 2] = _cvt_sf64_sf32(HEAP32[$2161 >> 2] | 0, HEAP32[$2161 + 4 >> 2] | 0, $and1499, $fflags) | 0;
      HEAP32[$2168 + 4 >> 2] = 0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 112:
     {
      if ($and13) {
       label = 392;
       break L4;
      }
      if (!$and1499) {
       $2178 = _bitshift64Ashr(0, HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, 32) | 0;
       $2188 = $2178;
       $2191 = tempRet0;
      } else if (($and1499 | 0) == 1) {
       $2188 = _fclass_sf32(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0) | 0;
       $2191 = 0;
      } else {
       label = 392;
       break L4;
      }
      if (!$and9) {
       $2507 = $90;
       $2510 = $91;
       break L24;
      }
      $2186 = $s + ($and9 << 3) + 8 | 0;
      HEAP32[$2186 >> 2] = $2188;
      HEAP32[$2186 + 4 >> 2] = $2191;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 120:
     {
      if ($and13 | $and1499) {
       label = 392;
       break L4;
      }
      $2200 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$2200 >> 2] = HEAP32[$s + ($and11 << 3) + 8 >> 2];
      HEAP32[$2200 + 4 >> 2] = 0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 81:
     {
      if (!$and1499) {
       $2401 = $s + ($and11 << 3) + 264 | 0;
       $2407 = $s + ($and13 << 3) + 264 | 0;
       $val$10$in = _le_sf64(HEAP32[$2401 >> 2] | 0, HEAP32[$2401 + 4 >> 2] | 0, HEAP32[$2407 >> 2] | 0, HEAP32[$2407 + 4 >> 2] | 0, $fflags) | 0;
      } else if (($and1499 | 0) == 2) {
       $2427 = $s + ($and11 << 3) + 264 | 0;
       $2433 = $s + ($and13 << 3) + 264 | 0;
       $val$10$in = _eq_quiet_sf64(HEAP32[$2427 >> 2] | 0, HEAP32[$2427 + 4 >> 2] | 0, HEAP32[$2433 >> 2] | 0, HEAP32[$2433 + 4 >> 2] | 0, $fflags) | 0;
      } else if (($and1499 | 0) == 1) {
       $2414 = $s + ($and11 << 3) + 264 | 0;
       $2420 = $s + ($and13 << 3) + 264 | 0;
       $val$10$in = _lt_sf64(HEAP32[$2414 >> 2] | 0, HEAP32[$2414 + 4 >> 2] | 0, HEAP32[$2420 >> 2] | 0, HEAP32[$2420 + 4 >> 2] | 0, $fflags) | 0;
      } else {
       label = 392;
       break L4;
      }
      if (!$and9) {
       $2507 = $90;
       $2510 = $91;
       break L24;
      }
      $2442 = $s + ($and9 << 3) + 8 | 0;
      HEAP32[$2442 >> 2] = $val$10$in;
      HEAP32[$2442 + 4 >> 2] = (($val$10$in | 0) < 0) << 31 >> 31;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 1:
     {
      $2204 = $s + ($and11 << 3) + 264 | 0;
      $2210 = $s + ($and13 << 3) + 264 | 0;
      $2218 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$2218 >> 2] = _add_sf64(HEAP32[$2204 >> 2] | 0, HEAP32[$2204 + 4 >> 2] | 0, HEAP32[$2210 >> 2] | 0, HEAP32[$2210 + 4 >> 2] | 0, $and1499, $fflags) | 0;
      HEAP32[$2218 + 4 >> 2] = tempRet0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 5:
     {
      $2222 = $s + ($and11 << 3) + 264 | 0;
      $2228 = $s + ($and13 << 3) + 264 | 0;
      $2236 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$2236 >> 2] = _sub_sf64(HEAP32[$2222 >> 2] | 0, HEAP32[$2222 + 4 >> 2] | 0, HEAP32[$2228 >> 2] | 0, HEAP32[$2228 + 4 >> 2] | 0, $and1499, $fflags) | 0;
      HEAP32[$2236 + 4 >> 2] = tempRet0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 9:
     {
      $2240 = $s + ($and11 << 3) + 264 | 0;
      $2246 = $s + ($and13 << 3) + 264 | 0;
      $2254 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$2254 >> 2] = _mul_sf64(HEAP32[$2240 >> 2] | 0, HEAP32[$2240 + 4 >> 2] | 0, HEAP32[$2246 >> 2] | 0, HEAP32[$2246 + 4 >> 2] | 0, $and1499, $fflags) | 0;
      HEAP32[$2254 + 4 >> 2] = tempRet0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 45:
     {
      if ($and13) {
       label = 392;
       break L4;
      }
      $2276 = $s + ($and11 << 3) + 264 | 0;
      $2284 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$2284 >> 2] = _sqrt_sf64(HEAP32[$2276 >> 2] | 0, HEAP32[$2276 + 4 >> 2] | 0, $and1499, $fflags) | 0;
      HEAP32[$2284 + 4 >> 2] = tempRet0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 13:
     {
      $2258 = $s + ($and11 << 3) + 264 | 0;
      $2264 = $s + ($and13 << 3) + 264 | 0;
      $2272 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$2272 >> 2] = _div_sf64(HEAP32[$2258 >> 2] | 0, HEAP32[$2258 + 4 >> 2] | 0, HEAP32[$2264 >> 2] | 0, HEAP32[$2264 + 4 >> 2] | 0, $and1499, $fflags) | 0;
      HEAP32[$2272 + 4 >> 2] = tempRet0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 17:
     {
      if (!$and1499) {
       $2288 = $s + ($and11 << 3) + 264 | 0;
       $2302 = HEAP32[$s + ($and13 << 3) + 268 >> 2] & -2147483648 | HEAP32[$2288 + 4 >> 2] & 2147483647;
       $2303 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2303 >> 2] = HEAP32[$2288 >> 2];
       HEAP32[$2303 + 4 >> 2] = $2302;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else if (($and1499 | 0) == 1) {
       $2307 = $s + ($and11 << 3) + 264 | 0;
       $2322 = (HEAP32[$s + ($and13 << 3) + 268 >> 2] & -2147483648 | HEAP32[$2307 + 4 >> 2] & 2147483647) ^ -2147483648;
       $2323 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2323 >> 2] = HEAP32[$2307 >> 2];
       HEAP32[$2323 + 4 >> 2] = $2322;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else if (($and1499 | 0) == 2) {
       $2327 = $s + ($and11 << 3) + 264 | 0;
       $2340 = HEAP32[$s + ($and13 << 3) + 268 >> 2] & -2147483648 ^ HEAP32[$2327 + 4 >> 2];
       $2341 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2341 >> 2] = HEAP32[$2327 >> 2];
       HEAP32[$2341 + 4 >> 2] = $2340;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else {
       label = 392;
       break L4;
      }
      break;
     }
    case 21:
     {
      if (!$and1499) {
       $2345 = $s + ($and11 << 3) + 264 | 0;
       $2351 = $s + ($and13 << 3) + 264 | 0;
       $2357 = _min_sf64(HEAP32[$2345 >> 2] | 0, HEAP32[$2345 + 4 >> 2] | 0, HEAP32[$2351 >> 2] | 0, HEAP32[$2351 + 4 >> 2] | 0, $fflags) | 0;
       $2359 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2359 >> 2] = $2357;
       HEAP32[$2359 + 4 >> 2] = tempRet0;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else if (($and1499 | 0) == 1) {
       $2363 = $s + ($and11 << 3) + 264 | 0;
       $2369 = $s + ($and13 << 3) + 264 | 0;
       $2375 = _max_sf64(HEAP32[$2363 >> 2] | 0, HEAP32[$2363 + 4 >> 2] | 0, HEAP32[$2369 >> 2] | 0, HEAP32[$2369 + 4 >> 2] | 0, $fflags) | 0;
       $2377 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2377 >> 2] = $2375;
       HEAP32[$2377 + 4 >> 2] = tempRet0;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else {
       label = 392;
       break L4;
      }
      break;
     }
    case 97:
     {
      if (!$and13) {
       $2381 = $s + ($and11 << 3) + 264 | 0;
       $val$9$in = _cvt_sf64_i32(HEAP32[$2381 >> 2] | 0, HEAP32[$2381 + 4 >> 2] | 0, $and1499, $fflags) | 0;
      } else if (($and13 | 0) == 1) {
       $2388 = $s + ($and11 << 3) + 264 | 0;
       $val$9$in = _cvt_sf64_u32(HEAP32[$2388 >> 2] | 0, HEAP32[$2388 + 4 >> 2] | 0, $and1499, $fflags) | 0;
      } else {
       label = 392;
       break L4;
      }
      if (!$and9) {
       $2507 = $90;
       $2510 = $91;
       break L24;
      }
      $2397 = $s + ($and9 << 3) + 8 | 0;
      HEAP32[$2397 >> 2] = $val$9$in;
      HEAP32[$2397 + 4 >> 2] = (($val$9$in | 0) < 0) << 31 >> 31;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 105:
     {
      if (!$and13) {
       $2452 = _cvt_i32_sf64(HEAP32[$s + ($and11 << 3) + 8 >> 2] | 0, $and1499, $fflags) | 0;
       $2454 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2454 >> 2] = $2452;
       HEAP32[$2454 + 4 >> 2] = tempRet0;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else if (($and13 | 0) == 1) {
       $2464 = _cvt_u32_sf64(HEAP32[$s + ($and11 << 3) + 8 >> 2] | 0, $and1499, $fflags) | 0;
       $2466 = $s + ($and9 << 3) + 264 | 0;
       HEAP32[$2466 >> 2] = $2464;
       HEAP32[$2466 + 4 >> 2] = tempRet0;
       $2507 = $90;
       $2510 = $91;
       break L24;
      } else {
       label = 392;
       break L4;
      }
      break;
     }
    case 65:
     {
      if ($and13) {
       label = 392;
       break L4;
      }
      $2478 = $s + ($and9 << 3) + 264 | 0;
      HEAP32[$2478 >> 2] = _cvt_sf32_sf64(HEAP32[$s + ($and11 << 3) + 264 >> 2] | 0, $fflags) | 0;
      HEAP32[$2478 + 4 >> 2] = tempRet0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    case 113:
     {
      if (!(($and13 | 0) == 0 & ($and1499 | 0) == 1)) {
       label = 392;
       break L4;
      }
      $2482 = $s + ($and11 << 3) + 264 | 0;
      $2488 = _fclass_sf64(HEAP32[$2482 >> 2] | 0, HEAP32[$2482 + 4 >> 2] | 0) | 0;
      if (!$and9) {
       $2507 = $90;
       $2510 = $91;
       break L24;
      }
      $2489 = $s + ($and9 << 3) + 8 | 0;
      HEAP32[$2489 >> 2] = $2488;
      HEAP32[$2489 + 4 >> 2] = 0;
      $2507 = $90;
      $2510 = $91;
      break L24;
      break;
     }
    default:
     {
      label = 392;
      break L4;
     }
    } while (0);
    break;
   }
  default:
   {
    label = 392;
    break L4;
   }
  } while (0);
  $2505 = $s;
  HEAP32[$2505 >> 2] = $2507;
  HEAP32[$2505 + 4 >> 2] = $2510;
  $n_cycles$addr$01901 = $n_cycles$addr$01901 + -1 | 0;
  $2511 = $insn_counter2038;
  $2517 = _i64Add(HEAP32[$2511 >> 2] | 0, HEAP32[$2511 + 4 >> 2] | 0, 1, 0) | 0;
  $2519 = $insn_counter2038;
  HEAP32[$2519 >> 2] = $2517;
  HEAP32[$2519 + 4 >> 2] = tempRet0;
  if (!$n_cycles$addr$01901) {
   label = 395;
   break;
  }
 }
 if ((label | 0) == 97) _raise_exception2($s, 3, 0, 0); else if ((label | 0) == 220) {
  $1267 = $s;
  HEAP32[$1267 >> 2] = $90;
  HEAP32[$1267 + 4 >> 2] = $91;
 } else if ((label | 0) == 230) {
  $1296 = $s;
  HEAP32[$1296 >> 2] = $90;
  HEAP32[$1296 + 4 >> 2] = $91;
 } else if ((label | 0) == 232) if (!($92 & 1048448)) _raise_exception2($s, (HEAPU8[$priv1125 >> 0] | 0) + 8 | 0, 0, 0); else label = 392; else if ((label | 0) == 234) if (!($92 & 1048448)) _raise_exception2($s, 3, 0, 0); else label = 392; else if ((label | 0) == 236) if (!($92 & 1048448)) {
  $1301 = HEAP8[$priv1125 >> 0] | 0;
  if (!($1301 << 24 >> 24)) label = 392; else {
   $1302 = $mstatus$i$i;
   $1304 = HEAP32[$1302 >> 2] | 0;
   $1307 = HEAP32[$1302 + 4 >> 2] | 0;
   $1308 = _bitshift64Lshr($1304 | 0, $1307 | 0, 8) | 0;
   $conv$i1165 = $1308 & 1;
   $1310 = _bitshift64Lshr($1304 | 0, $1307 | 0, 5) | 0;
   $neg$i1170 = 1 << $conv$i1165 ^ -33;
   $shl8$i1173 = ($1310 & 1) << $conv$i1165;
   $1318 = $neg$i1170 & $1304 | $shl8$i1173;
   $1319 = (($neg$i1170 | 0) < 0) << 31 >> 31 & $1307 | (($shl8$i1173 | 0) < 0) << 31 >> 31;
   $1320 = _bitshift64Lshr($1318 | 0, $1319 | 0, 42) | 0;
   $conv18$i1178 = $1320 & 3;
   HEAP8[$s + 525 >> 0] = ($conv18$i1178 + -1 | 0) >>> 0 > 1 ? 64 : 1 << ($conv18$i1178 | 4) & 255;
   $1327 = $mstatus$i$i;
   HEAP32[$1327 >> 2] = $1318 & -289 | 32;
   HEAP32[$1327 + 4 >> 2] = $1319 & -1025;
   if (($1301 & 255 | 0) != ($conv$i1165 | 0)) {
    $i$07$i$i$i$i1189 = 0;
    do {
     $1331 = $s + ($i$07$i$i$i$i1189 << 4) + 1400 | 0;
     HEAP32[$1331 >> 2] = -1;
     HEAP32[$1331 + 4 >> 2] = -1;
     $1335 = $s + ($i$07$i$i$i$i1189 << 4) + 5496 | 0;
     HEAP32[$1335 >> 2] = -1;
     HEAP32[$1335 + 4 >> 2] = -1;
     $1339 = $s + ($i$07$i$i$i$i1189 << 4) + 9592 | 0;
     HEAP32[$1339 >> 2] = -1;
     HEAP32[$1339 + 4 >> 2] = -1;
     $i$07$i$i$i$i1189 = $i$07$i$i$i$i1189 + 1 | 0;
    } while (($i$07$i$i$i$i1189 | 0) != 256);
    HEAP8[$priv1125 >> 0] = $conv$i1165;
   }
   $1343 = $s + 664 | 0;
   $1348 = HEAP32[$1343 + 4 >> 2] | 0;
   $1349 = $s;
   HEAP32[$1349 >> 2] = HEAP32[$1343 >> 2];
   HEAP32[$1349 + 4 >> 2] = $1348;
  }
 } else label = 392; else if ((label | 0) == 242) if (!($92 & 1048448)) {
  $1353 = HEAP8[$priv1125 >> 0] | 0;
  if (($1353 & 255) < 3) label = 392; else {
   $1354 = $mstatus$i$i;
   $1356 = HEAP32[$1354 >> 2] | 0;
   $1359 = HEAP32[$1354 + 4 >> 2] | 0;
   $1360 = _bitshift64Lshr($1356 | 0, $1359 | 0, 11) | 0;
   $conv$i1156 = $1360 & 3;
   $1362 = _bitshift64Lshr($1356 | 0, $1359 | 0, 7) | 0;
   $neg$i = 1 << $conv$i1156 ^ -129;
   $shl8$i = ($1362 & 1) << $conv$i1156;
   $1370 = $neg$i & $1356 | $shl8$i;
   $1371 = (($neg$i | 0) < 0) << 31 >> 31 & $1359 | (($shl8$i | 0) < 0) << 31 >> 31;
   $1372 = _bitshift64Lshr($1370 | 0, $1371 | 0, 46) | 0;
   $conv18$i = $1372 & 3;
   HEAP8[$s + 525 >> 0] = ($conv18$i + -1 | 0) >>> 0 > 1 ? 64 : 1 << ($conv18$i | 4) & 255;
   $1379 = $mstatus$i$i;
   HEAP32[$1379 >> 2] = $1370 & -6273 | 128;
   HEAP32[$1379 + 4 >> 2] = $1371 & -16385;
   if (($1353 & 255 | 0) != ($conv$i1156 | 0)) {
    $i$07$i$i$i$i = 0;
    do {
     $1383 = $s + ($i$07$i$i$i$i << 4) + 1400 | 0;
     HEAP32[$1383 >> 2] = -1;
     HEAP32[$1383 + 4 >> 2] = -1;
     $1387 = $s + ($i$07$i$i$i$i << 4) + 5496 | 0;
     HEAP32[$1387 >> 2] = -1;
     HEAP32[$1387 + 4 >> 2] = -1;
     $1391 = $s + ($i$07$i$i$i$i << 4) + 9592 | 0;
     HEAP32[$1391 >> 2] = -1;
     HEAP32[$1391 + 4 >> 2] = -1;
     $i$07$i$i$i$i = $i$07$i$i$i$i + 1 | 0;
    } while (($i$07$i$i$i$i | 0) != 256);
    HEAP8[$priv1125 >> 0] = $conv$i1156;
   }
   $1395 = $s + 584 | 0;
   $1400 = HEAP32[$1395 + 4 >> 2] | 0;
   $1401 = $s;
   HEAP32[$1401 >> 2] = HEAP32[$1395 >> 2];
   HEAP32[$1401 + 4 >> 2] = $1400;
  }
 } else label = 392; else if ((label | 0) == 255) {
  HEAP32[$s + 544 >> 2] = 1;
  $1447 = $s;
  HEAP32[$1447 >> 2] = $90;
  HEAP32[$1447 + 4 >> 2] = $91;
 } else if ((label | 0) == 395) {
  STACKTOP = sp;
  return;
 }
 if ((label | 0) == 392) _raise_exception2($s, 2, 0, 0);
 $2493 = $insn_counter2038;
 $2499 = _i64Add(HEAP32[$2493 >> 2] | 0, HEAP32[$2493 + 4 >> 2] | 0, 1, 0) | 0;
 $2501 = $insn_counter2038;
 HEAP32[$2501 >> 2] = $2499;
 HEAP32[$2501 + 4 >> 2] = tempRet0;
 STACKTOP = sp;
 return;
}
function _printf_core($f, $fmt, $ap, $nl_arg, $nl_type) {
 $f = $f | 0;
 $fmt = $fmt | 0;
 $ap = $ap | 0;
 $nl_arg = $nl_arg | 0;
 $nl_type = $nl_type | 0;
 var $$365$i = 0.0, $$p$i = 0, $$pr$i = 0, $$pr637$i = 0, $$sub264$i = 0, $$sub264$us$i = 0, $$sub514$i = 0, $$sub562$i = 0, $0 = 0, $101 = 0, $107 = 0, $110 = 0, $112 = 0, $115 = 0, $124 = 0, $127 = 0, $128 = 0, $134 = 0, $135 = 0, $136 = 0, $148 = 0, $152 = 0, $156 = 0, $157 = 0, $159 = 0.0, $163 = 0, $172 = 0, $175 = 0, $176 = 0, $177 = 0, $18 = 0, $19 = 0, $198 = 0, $199 = 0, $201 = 0, $203 = 0, $204 = 0, $205 = 0, $211 = 0, $215 = 0, $216 = 0, $218 = 0, $22 = 0, $221 = 0, $223 = 0, $226 = 0, $228 = 0, $230 = 0, $233 = 0, $234 = 0, $235 = 0, $250 = 0, $252 = 0, $254 = 0, $256 = 0, $257 = 0, $258 = 0, $261 = 0, $265 = 0, $266 = 0, $270 = 0, $272 = 0, $275 = 0, $276 = 0, $280 = 0, $281 = 0, $284 = 0, $288 = 0, $289 = 0, $293 = 0, $294 = 0, $297 = 0, $3 = 0, $301 = 0, $302 = 0, $306 = 0.0, $307 = 0.0, $309 = 0, $310 = 0, $311 = 0, $312 = 0, $313 = 0, $314 = 0, $315 = 0, $316 = 0, $317 = 0, $32 = 0, $33 = 0, $35 = 0, $36 = 0, $38 = 0, $45 = 0, $46 = 0, $5 = 0, $50 = 0, $52 = 0, $54 = 0, $57 = 0, $59 = 0, $6 = 0, $64 = 0, $66 = 0, $7 = 0, $71 = 0, $73 = 0.0, $77 = 0.0, $8 = 0, $81 = 0, $82 = 0, $85 = 0, $91 = 0, $95 = 0, $99 = 0, $a$0 = 0, $a$1 = 0, $a$1$lcssa$i = 0, $a$1735$i = 0, $a$2 = 0, $a$2$ph$i = 0, $a$3$lcssa$i = 0, $a$3725$i = 0, $a$3725$us$i = 0, $a$5$lcssa$i = 0, $a$5707$i = 0, $a$6$i = 0, $a$7$i = 0, $a$8$ph$i = 0, $add$i189 = 0, $add$i341 = 0, $add$ptr = 0, $add$ptr205 = 0, $add$ptr213$i = 0, $add$ptr311$us$i = 0, $add$ptr311$us$z$4$us$i = 0, $add$ptr333 = 0, $add$ptr358$i = 0, $add$ptr43 = 0, $add$ptr442$i = 0, $add$ptr466 = 0, $add$ptr671$i = 0, $add165$i = 0, $add275$i = 0, $add315 = 0, $add355$i = 0, $add388 = 0, $add414$i = 0, $add434 = 0, $add653$i = 0, $add67362$i = 0, $and$i297 = 0, $and$i352 = 0, $and$i415$i = 0, $and$i517$i = 0, $and12$i = 0, $and219 = 0, $and249 = 0, $and287 = 0, $and302$fl$4 = 0, $and62$i = 0, $arg$sroa$0$sroa$1$4$extract$trunc531552 = 0, $arg$sroa$0$sroa$1$4$extract$trunc531553 = 0, $arg$sroa$0$sroa$1$4$extract$trunc531554 = 0, $arg$sroa$0$sroa$1$4$extract$trunc531555 = 0, $arg$sroa$0$sroa$1$4$extract$trunc531556 = 0, $arg$sroa$0$sroa$1$4$extract$trunc531556568 = 0, $arg$sroa$0$sroa$1$4$extract$trunc531556656 = 0, $arglist_current = 0, $arglist_current11 = 0, $arglist_current14 = 0, $arglist_current17 = 0, $arglist_current2 = 0, $arglist_current20 = 0, $arglist_current23 = 0, $arglist_current26 = 0, $arglist_current29 = 0, $arglist_current32 = 0, $arglist_current35 = 0, $arglist_current38 = 0, $arglist_current41 = 0, $arglist_current44 = 0, $arglist_current47 = 0, $arglist_current5 = 0, $arglist_current50 = 0, $arglist_current53 = 0, $arglist_current56 = 0, $arglist_current59 = 0, $arglist_current62 = 0, $arglist_current8 = 0, $argpos$0 = 0, $arraydecay208$add$ptr213$i = 0, $arrayidx$i335 = 0, $arrayidx114 = 0, $arrayidx119 = 0, $arrayidx251$i = 0, $arrayidx31 = 0, $arrayidx363 = 0, $arrayidx453$i = 0, $arrayidx68 = 0, $big$i = 0, $buf = 0, $buf$i = 0, $call349 = 0, $call377 = 0, $call404 = 0, $carry$0730$i = 0, $carry262$0721$i = 0, $carry262$0721$us$i = 0, $cmp$i299 = 0, $cmp$i354 = 0, $cmp$i375$i = 0, $cmp$i417$i = 0, $cmp$i519$i = 0, $cmp184 = 0, $cmp338$i = 0, $cmp450$lcssa$i = 0, $cmp614$i = 0, $cnt$0 = 0, $cnt$1 = 0, $cond100$i = 0, $cond233$i = 0, $cond629$i = 0, $conv116$i = 0, $conv116$us$i = 0, $conv116$us$us$i = 0, $conv116$us646$i = 0, $conv174 = 0, $conv207 = 0, $conv216$i = 0, $conv3$i = 0, $conv3$i182 = 0, $conv48588 = 0, $conv48593 = 0, $conv7$i = 0, $conv7$i185 = 0, $d$0728$i = 0, $d$0731$i = 0, $d$1720$i = 0, $d$1720$us$i = 0, $d$2$lcssa$i = 0, $d$2706$i = 0, $d$3$i = 0, $d$4680$i = 0, $d$5674$i = 0, $d$6687$i = 0, $div356$i = 0, $div384$i = 0, $e$0717$i = 0, $e$1$i = 0, $e$2703$i = 0, $e$3$i = 0, $e$4$ph$i = 0, $e2$i = 0, $ebuf0$i = 0, $estr$0$i = 0, $estr$1$lcssa$i = 0, $estr$1$ph$i = 0, $estr$1693$i = 0, $estr$2$i = 0, $fl$0586 = 0, $fl$0592 = 0, $fl$1 = 0, $fl$1$and219 = 0, $fl$3 = 0, $fl$4 = 0, $fl$6 = 0, $i$0$lcssa = 0, $i$06$i = 0, $i$06$i186 = 0, $i$0609 = 0, $i$0612 = 0, $i$0716$i = 0, $i$1$lcssa$i = 0, $i$1617 = 0, $i$1712$i = 0, $i$2577 = 0, $i$2702$i = 0, $i$3575 = 0, $i$3698$i = 0, $inc$i = 0, $inc425$i = 0, $inc438$i = 0, $inc468$$p$i = 0, $inc500$i = 0, $incdec$ptr = 0, $incdec$ptr$i190 = 0, $incdec$ptr$i190557 = 0, $incdec$ptr$i190558 = 0, $incdec$ptr$i190559 = 0, $incdec$ptr$i190562 = 0, $incdec$ptr$i190563 = 0, $incdec$ptr$i190564$lcssa = 0, $incdec$ptr$i190564579 = 0, $incdec$ptr$i265 = 0, $incdec$ptr106$i = 0, $incdec$ptr115$i = 0, $incdec$ptr122$i = 0, $incdec$ptr122$us$i = 0, $incdec$ptr122$us$us$i = 0, $incdec$ptr122$us651$i = 0, $incdec$ptr169 = 0, $incdec$ptr23 = 0, $incdec$ptr246$i = 0, $incdec$ptr292$a$3$i = 0, $incdec$ptr292$a$3$us$i = 0, $incdec$ptr292$a$3$us748$i = 0, $incdec$ptr292$a$3753$i = 0, $incdec$ptr419$i = 0, $incdec$ptr423$i = 0, $incdec$ptr62 = 0, $incdec$ptr639$i = 0, $incdec$ptr647$i = 0, $incdec$ptr681$i = 0, $incdec$ptr689$i = 0, $incdec$ptr7$i = 0, $incdec$ptr7$i$i = 0, $incdec$ptr7$i511$i = 0, $incdec$ptr7$i565$i = 0, $incdec$ptr725$i = 0, $incdec$ptr773$i = 0, $incdec$ptr776$i = 0, $isdigittmp = 0, $isdigittmp167 = 0, $isdigittmp169 = 0, $j$0710$i = 0, $j$0713$i = 0, $j$1699$i = 0, $j$2$i = 0, $l$0 = 0, $l$0$i = 0, $l$1$lcssa = 0, $l$1611 = 0, $l$addr$0$lcssa$i = 0, $l$addr$0$lcssa$i$i = 0, $l$addr$0$lcssa$i258 = 0, $l$addr$0$lcssa$i292 = 0, $l$addr$0$lcssa$i311 = 0, $l$addr$0$lcssa$i331 = 0, $l$addr$0$lcssa$i366 = 0, $l$addr$0$lcssa$i387$i = 0, $l$addr$0$lcssa$i407$i = 0, $l$addr$0$lcssa$i429$i = 0, $l$addr$0$lcssa$i449$i = 0, $l$addr$0$lcssa$i465$i = 0, $l$addr$0$lcssa$i485$i = 0, $l$addr$0$lcssa$i531$i = 0, $l$addr$0$lcssa$i551$i = 0, $l$addr$0$lcssa$i599$i = 0, $l$addr$0$lcssa$i632$i = 0, $l$addr$010$i = 0, $l$addr$010$i$i = 0, $l$addr$010$i253 = 0, $l$addr$010$i287 = 0, $l$addr$010$i306 = 0, $l$addr$010$i326 = 0, $l$addr$010$i361 = 0, $l$addr$010$i382$i = 0, $l$addr$010$i402$i = 0, $l$addr$010$i424$i = 0, $l$addr$010$i444$i = 0, $l$addr$010$i460$i = 0, $l$addr$010$i480$i = 0, $l$addr$010$i526$i = 0, $l$addr$010$i546$i = 0, $l$addr$010$i594$i = 0, $l$addr$010$i627$i = 0, $l10n$0 = 0, $l10n$1 = 0, $l10n$2 = 0, $l10n$3 = 0, $lor$ext$i = 0, $mb = 0, $mul$i343 = 0.0, $mul322$i = 0, $mul367$i = 0, $mul431$i = 0, $mul513$i = 0, $or = 0, $or$i344 = 0, $p$0 = 0, $p$1 = 0, $p$2 = 0, $p$4658 = 0, $p$5 = 0, $p$addr$2$i = 0, $p$addr$3$i = 0, $p$addr$4$lcssa$i = 0, $p$addr$4675$i = 0, $p$addr$5688$i = 0, $pad$i = 0, $pl$0 = 0, $pl$0$i = 0, $pl$1 = 0, $pl$1$i = 0, $pl$2 = 0, $prefix$0 = 0, $prefix$0$add$ptr65$i = 0, $prefix$0$i = 0, $prefix$1 = 0, $prefix$2 = 0, $r$0$a$8$i = 0, $re$0$i = 0, $re$1667$i = 0, $rem370$i = 0, $retval$0 = 0, $round$0666$i = 0.0, $round377$1$i = 0.0, $s$0$i = 0, $s$0$us$i = 0, $s$0$us$us$i = 0, $s$0$us644$i = 0, $s$1$i = 0, $s$1$lcssa$i = 0, $s$1$us$i = 0, $s$1$us$us$i = 0, $s$1$us663$i = 0, $s$addr$0$lcssa$i$i = 0, $s$addr$0$lcssa$i269 = 0, $s$addr$0$lcssa$i275 = 0, $s$addr$0$lcssa$i502$i = 0, $s$addr$014$i = 0, $s$addr$014$i$i = 0, $s$addr$014$i491$i = 0, $s$addr$06$i = 0, $s$addr$07$i = 0, $s$addr$1$lcssa$i$i = 0, $s$addr$1$lcssa$i568$i = 0, $s$addr$110$i = 0, $s$addr$110$i$i = 0, $s$addr$110$i507$i = 0, $s$addr$110$i561$i = 0, $s$addr$110$i578$i = 0, $s$addr$110$i609$i = 0, $s35$0$i = 0, $s668$0678$i = 0, $s668$1$i = 0, $s715$0$lcssa$i = 0, $s715$0669$i = 0, $s753$0$i = 0, $s753$1682$i = 0, $s753$2$i = 0, $shr285$i = 0, $shr285$us$i = 0, $small$0$i = 0.0, $small$1$i = 0.0, $st$0 = 0, $storemerge = 0, $storemerge166584 = 0, $storemerge166591 = 0, $storemerge171 = 0, $sub$i$i = 0, $sub$i179 = 0, $sub$i248 = 0, $sub$i282 = 0, $sub$i301 = 0, $sub$i321 = 0, $sub$i356 = 0, $sub$i377$i = 0, $sub$i397$i = 0, $sub$i419$i = 0, $sub$i439$i = 0, $sub$i475$i = 0, $sub$i521$i = 0, $sub$i541$i = 0, $sub$ptr$lhs$cast157$pre$i = 0, $sub$ptr$lhs$cast160$i = 0, $sub$ptr$lhs$cast310 = 0, $sub$ptr$lhs$cast318$i = 0, $sub$ptr$lhs$cast694$i = 0, $sub$ptr$rhs$cast$i = 0, $sub$ptr$rhs$cast306$us$i = 0, $sub$ptr$sub = 0, $sub$ptr$sub145$i = 0, $sub$ptr$sub153$i = 0, $sub$ptr$sub162$i = 0, $sub$ptr$sub172$i = 0, $sub$ptr$sub175$i = 0, $sub$ptr$sub426 = 0, $sub$ptr$sub426$p$5 = 0, $sub$ptr$sub650$pn$i = 0, $sub$ptr$sub789$i = 0, $sub164 = 0, $sub181$i = 0, $sub203$i = 0, $sub256$i = 0, $sub264$i = 0, $sub264$us$i = 0, $sub281$i = 0, $sub281$us$i = 0, $sub343$i = 0, $sub409$i = 0, $sub5$i = 0, $sub5$i$i = 0, $sub5$i255 = 0, $sub5$i289 = 0, $sub5$i308 = 0, $sub5$i328 = 0, $sub5$i363 = 0, $sub5$i384$i = 0, $sub5$i404$i = 0, $sub5$i426$i = 0, $sub5$i446$i = 0, $sub5$i462$i = 0, $sub5$i482$i = 0, $sub5$i528$i = 0, $sub5$i548$i = 0, $sub5$i596$i = 0, $sub5$i629$i = 0, $sub514$i = 0, $sub562$i = 0, $sub626$i = 0, $sub735$i = 0, $t$0 = 0, $t$1 = 0, $t$addr$0$i = 0, $t$addr$1$i = 0, $tobool129$us$i = 0, $tobool135$i = 0, $tobool25 = 0, $tobool37$i = 0, $tobool56$i = 0, $tobool609$i = 0, $tobool781$not$i = 0, $w$0 = 0, $w$1 = 0, $w$2 = 0, $wc = 0, $ws$0613 = 0, $ws$1618 = 0, $x$addr$0$lcssa$off0$i = 0, $x$addr$0$lcssa$off0$i$i = 0, $x$addr$0$lcssa$off0$i503$i = 0, $y$011$i = 0, $y$011$i$i = 0, $y$011$i506$i = 0, $y$011$i560$i = 0, $y$011$i577$i = 0, $y$011$i608$i = 0, $y$addr$0$i = 0.0, $y$addr$1$i = 0.0, $y$addr$2$i = 0.0, $y$addr$2$us$i = 0.0, $y$addr$2$us$us$i = 0.0, $y$addr$2$us645$i = 0.0, $y$addr$3$i = 0.0, $y$addr$4$i = 0.0, $z$0$i = 0, $z$0$lcssa = 0, $z$0580 = 0, $z$1$lcssa$i = 0, $z$1734$i = 0, $z$2 = 0, $z$2$i = 0, $z$3$lcssa$i = 0, $z$3724$i = 0, $z$3724$us$i = 0, $z$4$i = 0, $z$4$us$i = 0, $z$5$i = 0, $z$6$add$ptr742$i = 0, $z$6$i = 0, $z$6$ph$i = 0, label = 0, sp = 0, $175$looptemp = 0, $233$looptemp = 0, $134$looptemp = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 864 | 0;
 $big$i = sp + 16 | 0;
 $e2$i = sp + 8 | 0;
 $buf$i = sp + 836 | 0;
 $sub$ptr$rhs$cast$i = $buf$i;
 $ebuf0$i = sp + 824 | 0;
 $pad$i = sp + 568 | 0;
 $buf = sp + 528 | 0;
 $wc = sp;
 $mb = sp + 520 | 0;
 $tobool25 = ($f | 0) != 0;
 $add$ptr205 = $buf + 40 | 0;
 $sub$ptr$lhs$cast310 = $add$ptr205;
 $add$ptr333 = $buf + 39 | 0;
 $arrayidx363 = $wc + 4 | 0;
 $arrayidx$i335 = $ebuf0$i + 12 | 0;
 $incdec$ptr106$i = $ebuf0$i + 11 | 0;
 $sub$ptr$lhs$cast160$i = $arrayidx$i335;
 $sub$ptr$sub162$i = $sub$ptr$lhs$cast160$i - $sub$ptr$rhs$cast$i | 0;
 $sub$ptr$sub145$i = -2 - $sub$ptr$rhs$cast$i | 0;
 $sub$ptr$sub153$i = $sub$ptr$lhs$cast160$i + 2 | 0;
 $add$ptr213$i = $big$i + 288 | 0;
 $add$ptr671$i = $buf$i + 9 | 0;
 $sub$ptr$lhs$cast694$i = $add$ptr671$i;
 $incdec$ptr689$i = $buf$i + 8 | 0;
 $309 = 0;
 $arg$sroa$0$sroa$1$4$extract$trunc531552 = 0;
 $cnt$0 = 0;
 $incdec$ptr$i190563 = $fmt;
 $l$0 = 0;
 $l10n$0 = 0;
 L1 : while (1) {
  do if (($cnt$0 | 0) > -1) if (($l$0 | 0) > (2147483647 - $cnt$0 | 0)) {
   HEAP32[(___errno_location() | 0) >> 2] = 75;
   $cnt$1 = -1;
   break;
  } else {
   $cnt$1 = $l$0 + $cnt$0 | 0;
   break;
  } else $cnt$1 = $cnt$0; while (0);
  $0 = HEAP8[$incdec$ptr$i190563 >> 0] | 0;
  if (!($0 << 24 >> 24)) {
   label = 344;
   break;
  } else {
   $310 = $0;
   $incdec$ptr$i190562 = $incdec$ptr$i190563;
  }
  while (1) {
   if ($310 << 24 >> 24 == 37) {
    $incdec$ptr$i190564579 = $incdec$ptr$i190562;
    $z$0580 = $incdec$ptr$i190562;
    label = 9;
    break;
   } else if (!($310 << 24 >> 24)) {
    $incdec$ptr$i190564$lcssa = $incdec$ptr$i190562;
    $z$0$lcssa = $incdec$ptr$i190562;
    break;
   }
   $incdec$ptr = $incdec$ptr$i190562 + 1 | 0;
   $310 = HEAP8[$incdec$ptr >> 0] | 0;
   $incdec$ptr$i190562 = $incdec$ptr;
  }
  L12 : do if ((label | 0) == 9) while (1) {
   label = 0;
   if ((HEAP8[$incdec$ptr$i190564579 + 1 >> 0] | 0) != 37) {
    $incdec$ptr$i190564$lcssa = $incdec$ptr$i190564579;
    $z$0$lcssa = $z$0580;
    break L12;
   }
   $incdec$ptr23 = $z$0580 + 1 | 0;
   $add$ptr = $incdec$ptr$i190564579 + 2 | 0;
   if ((HEAP8[$add$ptr >> 0] | 0) == 37) {
    $incdec$ptr$i190564579 = $add$ptr;
    $z$0580 = $incdec$ptr23;
    label = 9;
   } else {
    $incdec$ptr$i190564$lcssa = $add$ptr;
    $z$0$lcssa = $incdec$ptr23;
    break;
   }
  } while (0);
  $sub$ptr$sub = $z$0$lcssa - $incdec$ptr$i190563 | 0;
  if ($tobool25) ___fwritex($incdec$ptr$i190563, $sub$ptr$sub, $f) | 0;
  if (($z$0$lcssa | 0) != ($incdec$ptr$i190563 | 0)) {
   $cnt$0 = $cnt$1;
   $incdec$ptr$i190563 = $incdec$ptr$i190564$lcssa;
   $l$0 = $sub$ptr$sub;
   continue;
  }
  $arrayidx31 = $incdec$ptr$i190564$lcssa + 1 | 0;
  $3 = HEAP8[$arrayidx31 >> 0] | 0;
  $isdigittmp = ($3 << 24 >> 24) + -48 | 0;
  if ($isdigittmp >>> 0 < 10) if ((HEAP8[$incdec$ptr$i190564$lcssa + 2 >> 0] | 0) == 36) {
   $add$ptr43 = $incdec$ptr$i190564$lcssa + 3 | 0;
   $5 = HEAP8[$add$ptr43 >> 0] | 0;
   $argpos$0 = $isdigittmp;
   $l10n$1 = 1;
   $storemerge = $add$ptr43;
  } else {
   $5 = $3;
   $argpos$0 = -1;
   $l10n$1 = $l10n$0;
   $storemerge = $arrayidx31;
  } else {
   $5 = $3;
   $argpos$0 = -1;
   $l10n$1 = $l10n$0;
   $storemerge = $arrayidx31;
  }
  $conv48588 = $5 << 24 >> 24;
  L25 : do if (($conv48588 + -32 | 0) >>> 0 < 32) {
   $6 = $5;
   $conv48593 = $conv48588;
   $fl$0592 = 0;
   $storemerge166591 = $storemerge;
   while (1) {
    if (!(1 << $conv48593 + -32 & 75913)) {
     $8 = $6;
     $fl$0586 = $fl$0592;
     $storemerge166584 = $storemerge166591;
     break L25;
    }
    $or = 1 << ($6 << 24 >> 24) + -32 | $fl$0592;
    $incdec$ptr62 = $storemerge166591 + 1 | 0;
    $7 = HEAP8[$incdec$ptr62 >> 0] | 0;
    $conv48593 = $7 << 24 >> 24;
    if (($conv48593 + -32 | 0) >>> 0 >= 32) {
     $8 = $7;
     $fl$0586 = $or;
     $storemerge166584 = $incdec$ptr62;
     break;
    } else {
     $6 = $7;
     $fl$0592 = $or;
     $storemerge166591 = $incdec$ptr62;
    }
   }
  } else {
   $8 = $5;
   $fl$0586 = 0;
   $storemerge166584 = $storemerge;
  } while (0);
  do if ($8 << 24 >> 24 == 42) {
   $arrayidx68 = $storemerge166584 + 1 | 0;
   $isdigittmp169 = (HEAP8[$arrayidx68 >> 0] | 0) + -48 | 0;
   if ($isdigittmp169 >>> 0 < 10) if ((HEAP8[$storemerge166584 + 2 >> 0] | 0) == 36) {
    HEAP32[$nl_type + ($isdigittmp169 << 2) >> 2] = 10;
    $l10n$2 = 1;
    $storemerge171 = $storemerge166584 + 3 | 0;
    $w$0 = HEAP32[$nl_arg + ((HEAP8[$arrayidx68 >> 0] | 0) + -48 << 3) >> 2] | 0;
   } else label = 24; else label = 24;
   if ((label | 0) == 24) {
    label = 0;
    if ($l10n$1) {
     $retval$0 = -1;
     label = 362;
     break L1;
    }
    if (!$tobool25) {
     $fl$1 = $fl$0586;
     $incdec$ptr$i190559 = $arrayidx68;
     $l10n$3 = 0;
     $w$1 = 0;
     break;
    }
    $arglist_current = HEAP32[$ap >> 2] | 0;
    $18 = HEAP32[$arglist_current >> 2] | 0;
    HEAP32[$ap >> 2] = $arglist_current + 4;
    $l10n$2 = 0;
    $storemerge171 = $arrayidx68;
    $w$0 = $18;
   }
   if (($w$0 | 0) < 0) {
    $fl$1 = $fl$0586 | 8192;
    $incdec$ptr$i190559 = $storemerge171;
    $l10n$3 = $l10n$2;
    $w$1 = 0 - $w$0 | 0;
   } else {
    $fl$1 = $fl$0586;
    $incdec$ptr$i190559 = $storemerge171;
    $l10n$3 = $l10n$2;
    $w$1 = $w$0;
   }
  } else {
   $conv3$i = $8 << 24 >> 24;
   if (($conv3$i + -48 | 0) >>> 0 < 10) {
    $19 = $storemerge166584;
    $conv7$i = $conv3$i;
    $i$06$i = 0;
    do {
     $i$06$i = $conv7$i + -48 + ($i$06$i * 10 | 0) | 0;
     $19 = $19 + 1 | 0;
     $conv7$i = HEAP8[$19 >> 0] | 0;
    } while (($conv7$i + -48 | 0) >>> 0 < 10);
    if (($i$06$i | 0) < 0) {
     $retval$0 = -1;
     label = 362;
     break L1;
    } else {
     $fl$1 = $fl$0586;
     $incdec$ptr$i190559 = $19;
     $l10n$3 = $l10n$1;
     $w$1 = $i$06$i;
    }
   } else {
    $fl$1 = $fl$0586;
    $incdec$ptr$i190559 = $storemerge166584;
    $l10n$3 = $l10n$1;
    $w$1 = 0;
   }
  } while (0);
  L46 : do if ((HEAP8[$incdec$ptr$i190559 >> 0] | 0) == 46) {
   $arrayidx114 = $incdec$ptr$i190559 + 1 | 0;
   $22 = HEAP8[$arrayidx114 >> 0] | 0;
   if ($22 << 24 >> 24 != 42) {
    $conv3$i182 = $22 << 24 >> 24;
    if (($conv3$i182 + -48 | 0) >>> 0 < 10) {
     $33 = $arrayidx114;
     $conv7$i185 = $conv3$i182;
     $i$06$i186 = 0;
    } else {
     $incdec$ptr$i190558 = $arrayidx114;
     $p$0 = 0;
     break;
    }
    while (1) {
     $add$i189 = $conv7$i185 + -48 + ($i$06$i186 * 10 | 0) | 0;
     $incdec$ptr$i190 = $33 + 1 | 0;
     $conv7$i185 = HEAP8[$incdec$ptr$i190 >> 0] | 0;
     if (($conv7$i185 + -48 | 0) >>> 0 >= 10) {
      $incdec$ptr$i190558 = $incdec$ptr$i190;
      $p$0 = $add$i189;
      break L46;
     } else {
      $33 = $incdec$ptr$i190;
      $i$06$i186 = $add$i189;
     }
    }
   }
   $arrayidx119 = $incdec$ptr$i190559 + 2 | 0;
   $isdigittmp167 = (HEAP8[$arrayidx119 >> 0] | 0) + -48 | 0;
   if ($isdigittmp167 >>> 0 < 10) if ((HEAP8[$incdec$ptr$i190559 + 3 >> 0] | 0) == 36) {
    HEAP32[$nl_type + ($isdigittmp167 << 2) >> 2] = 10;
    $incdec$ptr$i190558 = $incdec$ptr$i190559 + 4 | 0;
    $p$0 = HEAP32[$nl_arg + ((HEAP8[$arrayidx119 >> 0] | 0) + -48 << 3) >> 2] | 0;
    break;
   }
   if ($l10n$3) {
    $retval$0 = -1;
    label = 362;
    break L1;
   }
   if ($tobool25) {
    $arglist_current2 = HEAP32[$ap >> 2] | 0;
    $32 = HEAP32[$arglist_current2 >> 2] | 0;
    HEAP32[$ap >> 2] = $arglist_current2 + 4;
    $incdec$ptr$i190558 = $arrayidx119;
    $p$0 = $32;
   } else {
    $incdec$ptr$i190558 = $arrayidx119;
    $p$0 = 0;
   }
  } else {
   $incdec$ptr$i190558 = $incdec$ptr$i190559;
   $p$0 = -1;
  } while (0);
  $incdec$ptr$i190557 = $incdec$ptr$i190558;
  $st$0 = 0;
  while (1) {
   $35 = HEAP8[$incdec$ptr$i190557 >> 0] | 0;
   $sub164 = ($35 << 24 >> 24) + -65 | 0;
   if ($sub164 >>> 0 > 57) {
    $retval$0 = -1;
    label = 362;
    break L1;
   }
   $incdec$ptr169 = $incdec$ptr$i190557 + 1 | 0;
   $36 = HEAP8[1704 + ($st$0 * 58 | 0) + $sub164 >> 0] | 0;
   $conv174 = $36 & 255;
   if (($conv174 + -1 | 0) >>> 0 < 8) {
    $incdec$ptr$i190557 = $incdec$ptr169;
    $st$0 = $conv174;
   } else break;
  }
  if (!($36 << 24 >> 24)) {
   $retval$0 = -1;
   label = 362;
   break;
  }
  $cmp184 = ($argpos$0 | 0) > -1;
  L65 : do if ($36 << 24 >> 24 == 19) if ($cmp184) {
   $retval$0 = -1;
   label = 362;
   break L1;
  } else {
   $311 = $309;
   $arg$sroa$0$sroa$1$4$extract$trunc531556 = $arg$sroa$0$sroa$1$4$extract$trunc531552;
   label = 63;
  } else {
   if ($cmp184) {
    HEAP32[$nl_type + ($argpos$0 << 2) >> 2] = $conv174;
    $38 = $nl_arg + ($argpos$0 << 3) | 0;
    $311 = HEAP32[$38 >> 2] | 0;
    $arg$sroa$0$sroa$1$4$extract$trunc531556 = HEAP32[$38 + 4 >> 2] | 0;
    label = 63;
    break;
   }
   if (!$tobool25) {
    $retval$0 = 0;
    label = 362;
    break L1;
   }
   if (($36 & 255) > 20) {
    $81 = $35;
    $82 = $309;
    $arg$sroa$0$sroa$1$4$extract$trunc531556568 = $arg$sroa$0$sroa$1$4$extract$trunc531552;
   } else do switch ($conv174 | 0) {
   case 11:
    {
     $arglist_current11 = HEAP32[$ap >> 2] | 0;
     $50 = HEAP32[$arglist_current11 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current11 + 4;
     $312 = $50;
     $arg$sroa$0$sroa$1$4$extract$trunc531556656 = 0;
     label = 64;
     break L65;
     break;
    }
   case 12:
    {
     $arglist_current14 = HEAP32[$ap >> 2] | 0;
     $52 = $arglist_current14;
     $54 = HEAP32[$52 >> 2] | 0;
     $57 = HEAP32[$52 + 4 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current14 + 8;
     $312 = $54;
     $arg$sroa$0$sroa$1$4$extract$trunc531556656 = $57;
     label = 64;
     break L65;
     break;
    }
   case 14:
    {
     $arglist_current20 = HEAP32[$ap >> 2] | 0;
     $64 = HEAP32[$arglist_current20 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current20 + 4;
     $312 = $64 & 65535;
     $arg$sroa$0$sroa$1$4$extract$trunc531556656 = 0;
     label = 64;
     break L65;
     break;
    }
   case 15:
    {
     $arglist_current23 = HEAP32[$ap >> 2] | 0;
     $66 = HEAP32[$arglist_current23 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current23 + 4;
     $312 = $66 << 24 >> 24;
     $arg$sroa$0$sroa$1$4$extract$trunc531556656 = ((($66 & 255) << 24 >> 24 | 0) < 0) << 31 >> 31;
     label = 64;
     break L65;
     break;
    }
   case 10:
    {
     $arglist_current8 = HEAP32[$ap >> 2] | 0;
     $46 = HEAP32[$arglist_current8 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current8 + 4;
     $312 = $46;
     $arg$sroa$0$sroa$1$4$extract$trunc531556656 = (($46 | 0) < 0) << 31 >> 31;
     label = 64;
     break L65;
     break;
    }
   case 17:
    {
     $arglist_current29 = HEAP32[$ap >> 2] | 0;
     HEAP32[tempDoublePtr >> 2] = HEAP32[$arglist_current29 >> 2];
     HEAP32[tempDoublePtr + 4 >> 2] = HEAP32[$arglist_current29 + 4 >> 2];
     $73 = +HEAPF64[tempDoublePtr >> 3];
     HEAP32[$ap >> 2] = $arglist_current29 + 8;
     HEAPF64[tempDoublePtr >> 3] = $73;
     $312 = HEAP32[tempDoublePtr >> 2] | 0;
     $arg$sroa$0$sroa$1$4$extract$trunc531556656 = HEAP32[tempDoublePtr + 4 >> 2] | 0;
     label = 64;
     break L65;
     break;
    }
   case 13:
    {
     $arglist_current17 = HEAP32[$ap >> 2] | 0;
     $59 = HEAP32[$arglist_current17 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current17 + 4;
     $312 = $59 << 16 >> 16;
     $arg$sroa$0$sroa$1$4$extract$trunc531556656 = ((($59 & 65535) << 16 >> 16 | 0) < 0) << 31 >> 31;
     label = 64;
     break L65;
     break;
    }
   case 16:
    {
     $arglist_current26 = HEAP32[$ap >> 2] | 0;
     $71 = HEAP32[$arglist_current26 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current26 + 4;
     $312 = $71 & 255;
     $arg$sroa$0$sroa$1$4$extract$trunc531556656 = 0;
     label = 64;
     break L65;
     break;
    }
   case 18:
    {
     $arglist_current32 = HEAP32[$ap >> 2] | 0;
     HEAP32[tempDoublePtr >> 2] = HEAP32[$arglist_current32 >> 2];
     HEAP32[tempDoublePtr + 4 >> 2] = HEAP32[$arglist_current32 + 4 >> 2];
     $77 = +HEAPF64[tempDoublePtr >> 3];
     HEAP32[$ap >> 2] = $arglist_current32 + 8;
     HEAPF64[tempDoublePtr >> 3] = $77;
     $311 = HEAP32[tempDoublePtr >> 2] | 0;
     $arg$sroa$0$sroa$1$4$extract$trunc531556 = HEAP32[tempDoublePtr + 4 >> 2] | 0;
     label = 63;
     break L65;
     break;
    }
   case 9:
    {
     $arglist_current5 = HEAP32[$ap >> 2] | 0;
     $45 = HEAP32[$arglist_current5 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current5 + 4;
     $312 = $45;
     $arg$sroa$0$sroa$1$4$extract$trunc531556656 = $arg$sroa$0$sroa$1$4$extract$trunc531552;
     label = 64;
     break L65;
     break;
    }
   default:
    {
     $312 = $309;
     $arg$sroa$0$sroa$1$4$extract$trunc531556656 = $arg$sroa$0$sroa$1$4$extract$trunc531552;
     label = 64;
     break L65;
    }
   } while (0);
  } while (0);
  if ((label | 0) == 63) {
   label = 0;
   if ($tobool25) {
    $312 = $311;
    $arg$sroa$0$sroa$1$4$extract$trunc531556656 = $arg$sroa$0$sroa$1$4$extract$trunc531556;
    label = 64;
   } else {
    $309 = $311;
    $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556;
    $cnt$0 = $cnt$1;
    $incdec$ptr$i190563 = $incdec$ptr169;
    $l$0 = $sub$ptr$sub;
    $l10n$0 = $l10n$3;
    continue;
   }
  }
  if ((label | 0) == 64) {
   label = 0;
   $81 = HEAP8[$incdec$ptr$i190557 >> 0] | 0;
   $82 = $312;
   $arg$sroa$0$sroa$1$4$extract$trunc531556568 = $arg$sroa$0$sroa$1$4$extract$trunc531556656;
  }
  $conv207 = $81 << 24 >> 24;
  if (!$st$0) $t$0 = $conv207; else $t$0 = ($conv207 & 15 | 0) == 3 ? $conv207 & -33 : $conv207;
  $and219 = $fl$1 & -65537;
  $fl$1$and219 = ($fl$1 & 8192 | 0) == 0 ? $fl$1 : $and219;
  L92 : do switch ($t$0 | 0) {
  case 67:
   {
    HEAP32[$wc >> 2] = $82;
    HEAP32[$arrayidx363 >> 2] = 0;
    $314 = $wc;
    $315 = $wc;
    $p$4658 = -1;
    label = 104;
    break;
   }
  case 83:
   {
    if (!$p$0) {
     $316 = $82;
     $317 = $82;
     $i$0609 = 0;
     label = 110;
    } else {
     $314 = $82;
     $315 = $82;
     $p$4658 = $p$0;
     label = 104;
    }
    break;
   }
  case 99:
   {
    HEAP8[$add$ptr333 >> 0] = $82;
    $313 = $82;
    $a$2 = $add$ptr333;
    $arg$sroa$0$sroa$1$4$extract$trunc531555 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
    $fl$6 = $and219;
    $p$5 = 1;
    $pl$2 = 0;
    $prefix$2 = 2168;
    $z$2 = $add$ptr205;
    break;
   }
  case 110:
   {
    switch ($st$0 | 0) {
    case 7:
     {
      $91 = $82;
      HEAP32[$91 >> 2] = $cnt$1;
      HEAP32[$91 + 4 >> 2] = (($cnt$1 | 0) < 0) << 31 >> 31;
      $309 = $82;
      $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
      $cnt$0 = $cnt$1;
      $incdec$ptr$i190563 = $incdec$ptr169;
      $l$0 = $sub$ptr$sub;
      $l10n$0 = $l10n$3;
      continue L1;
      break;
     }
    case 2:
     {
      $85 = $82;
      HEAP32[$85 >> 2] = $cnt$1;
      HEAP32[$85 + 4 >> 2] = (($cnt$1 | 0) < 0) << 31 >> 31;
      $309 = $82;
      $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
      $cnt$0 = $cnt$1;
      $incdec$ptr$i190563 = $incdec$ptr169;
      $l$0 = $sub$ptr$sub;
      $l10n$0 = $l10n$3;
      continue L1;
      break;
     }
    case 4:
     {
      HEAP8[$82 >> 0] = $cnt$1;
      $309 = $82;
      $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
      $cnt$0 = $cnt$1;
      $incdec$ptr$i190563 = $incdec$ptr169;
      $l$0 = $sub$ptr$sub;
      $l10n$0 = $l10n$3;
      continue L1;
      break;
     }
    case 6:
     {
      HEAP32[$82 >> 2] = $cnt$1;
      $309 = $82;
      $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
      $cnt$0 = $cnt$1;
      $incdec$ptr$i190563 = $incdec$ptr169;
      $l$0 = $sub$ptr$sub;
      $l10n$0 = $l10n$3;
      continue L1;
      break;
     }
    case 3:
     {
      HEAP16[$82 >> 1] = $cnt$1;
      $309 = $82;
      $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
      $cnt$0 = $cnt$1;
      $incdec$ptr$i190563 = $incdec$ptr169;
      $l$0 = $sub$ptr$sub;
      $l10n$0 = $l10n$3;
      continue L1;
      break;
     }
    case 0:
     {
      HEAP32[$82 >> 2] = $cnt$1;
      $309 = $82;
      $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
      $cnt$0 = $cnt$1;
      $incdec$ptr$i190563 = $incdec$ptr169;
      $l$0 = $sub$ptr$sub;
      $l10n$0 = $l10n$3;
      continue L1;
      break;
     }
    case 1:
     {
      HEAP32[$82 >> 2] = $cnt$1;
      $309 = $82;
      $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
      $cnt$0 = $cnt$1;
      $incdec$ptr$i190563 = $incdec$ptr169;
      $l$0 = $sub$ptr$sub;
      $l10n$0 = $l10n$3;
      continue L1;
      break;
     }
    default:
     {
      $309 = $82;
      $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
      $cnt$0 = $cnt$1;
      $incdec$ptr$i190563 = $incdec$ptr169;
      $l$0 = $sub$ptr$sub;
      $l10n$0 = $l10n$3;
      continue L1;
     }
    }
    break;
   }
  case 117:
   {
    $127 = $82;
    $arg$sroa$0$sroa$1$4$extract$trunc531554 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
    $pl$0 = 0;
    $prefix$0 = 2168;
    label = 89;
    break;
   }
  case 65:
  case 71:
  case 70:
  case 69:
  case 97:
  case 103:
  case 102:
  case 101:
   {
    HEAP32[tempDoublePtr >> 2] = $82;
    HEAP32[tempDoublePtr + 4 >> 2] = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
    $159 = +HEAPF64[tempDoublePtr >> 3];
    HEAP32[$e2$i >> 2] = 0;
    if (($arg$sroa$0$sroa$1$4$extract$trunc531556568 | 0) < 0) {
     $pl$0$i = 1;
     $prefix$0$i = 2192;
     $y$addr$0$i = -$159;
    } else if (!($fl$1$and219 & 2048)) {
     $and12$i = $fl$1$and219 & 1;
     $pl$0$i = $and12$i;
     $prefix$0$i = ($and12$i | 0) == 0 ? 2193 : 2198;
     $y$addr$0$i = $159;
    } else {
     $pl$0$i = 1;
     $prefix$0$i = 2195;
     $y$addr$0$i = $159;
    }
    HEAPF64[tempDoublePtr >> 3] = $y$addr$0$i;
    $163 = HEAP32[tempDoublePtr + 4 >> 2] & 2146435072;
    if (!($163 >>> 0 < 2146435072 | ($163 | 0) == 2146435072 & 0 < 0)) {
     $tobool37$i = ($t$0 & 32 | 0) != 0;
     if ($y$addr$0$i != $y$addr$0$i | 0.0 != 0.0) {
      $pl$1$i = 0;
      $s35$0$i = $tobool37$i ? 2232 : 2240;
     } else {
      $pl$1$i = $pl$0$i;
      $s35$0$i = $tobool37$i ? 2216 : 2224;
     }
     $add$i341 = $pl$1$i + 3 | 0;
     $cmp$i375$i = ($add$i341 | 0) < ($w$1 | 0);
     if (($fl$1$and219 & 8192 | 0) == 0 & $cmp$i375$i) {
      $sub$i377$i = $w$1 - $add$i341 | 0;
      _memset($pad$i | 0, 32, ($sub$i377$i >>> 0 > 256 ? 256 : $sub$i377$i) | 0) | 0;
      if ($sub$i377$i >>> 0 > 255) {
       $l$addr$010$i382$i = $sub$i377$i;
       while (1) {
        ___fwritex($pad$i, 256, $f) | 0;
        $sub5$i384$i = $l$addr$010$i382$i + -256 | 0;
        if ($sub5$i384$i >>> 0 > 255) $l$addr$010$i382$i = $sub5$i384$i; else {
         $l$addr$0$lcssa$i387$i = $sub5$i384$i;
         break;
        }
       }
      } else $l$addr$0$lcssa$i387$i = $sub$i377$i;
      ___fwritex($pad$i, $l$addr$0$lcssa$i387$i, $f) | 0;
     }
     ___fwritex($prefix$0$i, $pl$1$i, $f) | 0;
     ___fwritex($s35$0$i, 3, $f) | 0;
     if (($fl$1$and219 & 73728 | 0) == 8192 & $cmp$i375$i) {
      $sub$i397$i = $w$1 - $add$i341 | 0;
      _memset($pad$i | 0, 32, ($sub$i397$i >>> 0 > 256 ? 256 : $sub$i397$i) | 0) | 0;
      if ($sub$i397$i >>> 0 > 255) {
       $l$addr$010$i402$i = $sub$i397$i;
       while (1) {
        ___fwritex($pad$i, 256, $f) | 0;
        $sub5$i404$i = $l$addr$010$i402$i + -256 | 0;
        if ($sub5$i404$i >>> 0 > 255) $l$addr$010$i402$i = $sub5$i404$i; else {
         $l$addr$0$lcssa$i407$i = $sub5$i404$i;
         break;
        }
       }
      } else $l$addr$0$lcssa$i407$i = $sub$i397$i;
      ___fwritex($pad$i, $l$addr$0$lcssa$i407$i, $f) | 0;
     }
     $309 = $82;
     $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
     $cnt$0 = $cnt$1;
     $incdec$ptr$i190563 = $incdec$ptr169;
     $l$0 = $cmp$i375$i ? $w$1 : $add$i341;
     $l10n$0 = $l10n$3;
     continue L1;
    }
    $mul$i343 = +_frexpl($y$addr$0$i, $e2$i) * 2.0;
    $tobool56$i = $mul$i343 != 0.0;
    if ($tobool56$i) HEAP32[$e2$i >> 2] = (HEAP32[$e2$i >> 2] | 0) + -1;
    $or$i344 = $t$0 | 32;
    if (($or$i344 | 0) == 97) {
     $and62$i = $t$0 & 32;
     $prefix$0$add$ptr65$i = ($and62$i | 0) == 0 ? $prefix$0$i : $prefix$0$i + 9 | 0;
     $add67362$i = $pl$0$i | 2;
     $re$0$i = $p$0 >>> 0 > 11 ? 0 : 12 - $p$0 | 0;
     do if (!$re$0$i) $y$addr$1$i = $mul$i343; else {
      $re$1667$i = $re$0$i;
      $round$0666$i = 8.0;
      do {
       $re$1667$i = $re$1667$i + -1 | 0;
       $round$0666$i = $round$0666$i * 16.0;
      } while (($re$1667$i | 0) != 0);
      if ((HEAP8[$prefix$0$add$ptr65$i >> 0] | 0) == 45) {
       $y$addr$1$i = -($round$0666$i + (-$mul$i343 - $round$0666$i));
       break;
      } else {
       $y$addr$1$i = $mul$i343 + $round$0666$i - $round$0666$i;
       break;
      }
     } while (0);
     $172 = HEAP32[$e2$i >> 2] | 0;
     $cond100$i = ($172 | 0) < 0 ? 0 - $172 | 0 : $172;
     if (($cond100$i | 0) < 0) {
      $175 = $cond100$i;
      $176 = (($cond100$i | 0) < 0) << 31 >> 31;
      $s$addr$014$i$i = $arrayidx$i335;
      while (1) {
       $177 = ___uremdi3($175 | 0, $176 | 0, 10, 0) | 0;
       $s$addr$014$i$i = $s$addr$014$i$i + -1 | 0;
       HEAP8[$s$addr$014$i$i >> 0] = $177 | 48;
       $175$looptemp = $175;
       $175 = ___udivdi3($175 | 0, $176 | 0, 10, 0) | 0;
       if (!($176 >>> 0 > 9 | ($176 | 0) == 9 & $175$looptemp >>> 0 > 4294967295)) break; else $176 = tempRet0;
      }
      $s$addr$0$lcssa$i$i = $s$addr$014$i$i;
      $x$addr$0$lcssa$off0$i$i = $175;
     } else {
      $s$addr$0$lcssa$i$i = $arrayidx$i335;
      $x$addr$0$lcssa$off0$i$i = $cond100$i;
     }
     if (!$x$addr$0$lcssa$off0$i$i) $s$addr$1$lcssa$i$i = $s$addr$0$lcssa$i$i; else {
      $s$addr$110$i$i = $s$addr$0$lcssa$i$i;
      $y$011$i$i = $x$addr$0$lcssa$off0$i$i;
      while (1) {
       $incdec$ptr7$i$i = $s$addr$110$i$i + -1 | 0;
       HEAP8[$incdec$ptr7$i$i >> 0] = ($y$011$i$i >>> 0) % 10 | 0 | 48;
       if ($y$011$i$i >>> 0 < 10) {
        $s$addr$1$lcssa$i$i = $incdec$ptr7$i$i;
        break;
       } else {
        $s$addr$110$i$i = $incdec$ptr7$i$i;
        $y$011$i$i = ($y$011$i$i >>> 0) / 10 | 0;
       }
      }
     }
     if (($s$addr$1$lcssa$i$i | 0) == ($arrayidx$i335 | 0)) {
      HEAP8[$incdec$ptr106$i >> 0] = 48;
      $estr$0$i = $incdec$ptr106$i;
     } else $estr$0$i = $s$addr$1$lcssa$i$i;
     HEAP8[$estr$0$i + -1 >> 0] = (HEAP32[$e2$i >> 2] >> 31 & 2) + 43;
     $incdec$ptr115$i = $estr$0$i + -2 | 0;
     HEAP8[$incdec$ptr115$i >> 0] = $t$0 + 15;
     $tobool135$i = ($fl$1$and219 & 8 | 0) == 0;
     if (($p$0 | 0) > 0) if ($tobool135$i) {
      $s$0$us$us$i = $buf$i;
      $y$addr$2$us$us$i = $y$addr$1$i;
      while (1) {
       $conv116$us$us$i = ~~$y$addr$2$us$us$i;
       $incdec$ptr122$us$us$i = $s$0$us$us$i + 1 | 0;
       HEAP8[$s$0$us$us$i >> 0] = HEAPU8[2248 + $conv116$us$us$i >> 0] | $and62$i;
       $y$addr$2$us$us$i = ($y$addr$2$us$us$i - +($conv116$us$us$i | 0)) * 16.0;
       if (($incdec$ptr122$us$us$i - $sub$ptr$rhs$cast$i | 0) == 1) {
        HEAP8[$incdec$ptr122$us$us$i >> 0] = 46;
        $s$1$us$us$i = $s$0$us$us$i + 2 | 0;
       } else $s$1$us$us$i = $incdec$ptr122$us$us$i;
       if (!($y$addr$2$us$us$i != 0.0)) {
        $s$1$lcssa$i = $s$1$us$us$i;
        break;
       } else $s$0$us$us$i = $s$1$us$us$i;
      }
     } else {
      $s$0$us$i = $buf$i;
      $y$addr$2$us$i = $y$addr$1$i;
      while (1) {
       $conv116$us$i = ~~$y$addr$2$us$i;
       $incdec$ptr122$us$i = $s$0$us$i + 1 | 0;
       HEAP8[$s$0$us$i >> 0] = HEAPU8[2248 + $conv116$us$i >> 0] | $and62$i;
       $y$addr$2$us$i = ($y$addr$2$us$i - +($conv116$us$i | 0)) * 16.0;
       if (($incdec$ptr122$us$i - $sub$ptr$rhs$cast$i | 0) == 1) {
        HEAP8[$incdec$ptr122$us$i >> 0] = 46;
        $s$1$us$i = $s$0$us$i + 2 | 0;
       } else $s$1$us$i = $incdec$ptr122$us$i;
       if (!($y$addr$2$us$i != 0.0)) {
        $s$1$lcssa$i = $s$1$us$i;
        break;
       } else $s$0$us$i = $s$1$us$i;
      }
     } else if ($tobool135$i) {
      $s$0$us644$i = $buf$i;
      $y$addr$2$us645$i = $y$addr$1$i;
      while (1) {
       $conv116$us646$i = ~~$y$addr$2$us645$i;
       $incdec$ptr122$us651$i = $s$0$us644$i + 1 | 0;
       HEAP8[$s$0$us644$i >> 0] = HEAPU8[2248 + $conv116$us646$i >> 0] | $and62$i;
       $y$addr$2$us645$i = ($y$addr$2$us645$i - +($conv116$us646$i | 0)) * 16.0;
       $tobool129$us$i = $y$addr$2$us645$i != 0.0;
       if (($incdec$ptr122$us651$i - $sub$ptr$rhs$cast$i | 0) == 1 & $tobool129$us$i) {
        HEAP8[$incdec$ptr122$us651$i >> 0] = 46;
        $s$1$us663$i = $s$0$us644$i + 2 | 0;
       } else $s$1$us663$i = $incdec$ptr122$us651$i;
       if (!$tobool129$us$i) {
        $s$1$lcssa$i = $s$1$us663$i;
        break;
       } else $s$0$us644$i = $s$1$us663$i;
      }
     } else {
      $s$0$i = $buf$i;
      $y$addr$2$i = $y$addr$1$i;
      while (1) {
       $conv116$i = ~~$y$addr$2$i;
       $incdec$ptr122$i = $s$0$i + 1 | 0;
       HEAP8[$s$0$i >> 0] = HEAPU8[2248 + $conv116$i >> 0] | $and62$i;
       $y$addr$2$i = ($y$addr$2$i - +($conv116$i | 0)) * 16.0;
       if (($incdec$ptr122$i - $sub$ptr$rhs$cast$i | 0) == 1) {
        HEAP8[$incdec$ptr122$i >> 0] = 46;
        $s$1$i = $s$0$i + 2 | 0;
       } else $s$1$i = $incdec$ptr122$i;
       if (!($y$addr$2$i != 0.0)) {
        $s$1$lcssa$i = $s$1$i;
        break;
       } else $s$0$i = $s$1$i;
      }
     }
     $sub$ptr$lhs$cast157$pre$i = $s$1$lcssa$i;
     do if (!$p$0) label = 173; else {
      if (($sub$ptr$sub145$i + $sub$ptr$lhs$cast157$pre$i | 0) >= ($p$0 | 0)) {
       label = 173;
       break;
      }
      $l$0$i = $sub$ptr$sub153$i + $p$0 - $incdec$ptr115$i | 0;
     } while (0);
     if ((label | 0) == 173) {
      label = 0;
      $l$0$i = $sub$ptr$sub162$i - $incdec$ptr115$i + $sub$ptr$lhs$cast157$pre$i | 0;
     }
     $add165$i = $l$0$i + $add67362$i | 0;
     $and$i415$i = $fl$1$and219 & 73728;
     $cmp$i417$i = ($add165$i | 0) < ($w$1 | 0);
     if (($and$i415$i | 0) == 0 & $cmp$i417$i) {
      $sub$i419$i = $w$1 - $add165$i | 0;
      _memset($pad$i | 0, 32, ($sub$i419$i >>> 0 > 256 ? 256 : $sub$i419$i) | 0) | 0;
      if ($sub$i419$i >>> 0 > 255) {
       $l$addr$010$i424$i = $sub$i419$i;
       while (1) {
        ___fwritex($pad$i, 256, $f) | 0;
        $sub5$i426$i = $l$addr$010$i424$i + -256 | 0;
        if ($sub5$i426$i >>> 0 > 255) $l$addr$010$i424$i = $sub5$i426$i; else {
         $l$addr$0$lcssa$i429$i = $sub5$i426$i;
         break;
        }
       }
      } else $l$addr$0$lcssa$i429$i = $sub$i419$i;
      ___fwritex($pad$i, $l$addr$0$lcssa$i429$i, $f) | 0;
     }
     ___fwritex($prefix$0$add$ptr65$i, $add67362$i, $f) | 0;
     if (($and$i415$i | 0) == 65536 & $cmp$i417$i) {
      $sub$i439$i = $w$1 - $add165$i | 0;
      _memset($pad$i | 0, 48, ($sub$i439$i >>> 0 > 256 ? 256 : $sub$i439$i) | 0) | 0;
      if ($sub$i439$i >>> 0 > 255) {
       $l$addr$010$i444$i = $sub$i439$i;
       while (1) {
        ___fwritex($pad$i, 256, $f) | 0;
        $sub5$i446$i = $l$addr$010$i444$i + -256 | 0;
        if ($sub5$i446$i >>> 0 > 255) $l$addr$010$i444$i = $sub5$i446$i; else {
         $l$addr$0$lcssa$i449$i = $sub5$i446$i;
         break;
        }
       }
      } else $l$addr$0$lcssa$i449$i = $sub$i439$i;
      ___fwritex($pad$i, $l$addr$0$lcssa$i449$i, $f) | 0;
     }
     $sub$ptr$sub172$i = $sub$ptr$lhs$cast157$pre$i - $sub$ptr$rhs$cast$i | 0;
     ___fwritex($buf$i, $sub$ptr$sub172$i, $f) | 0;
     $sub$ptr$sub175$i = $sub$ptr$lhs$cast160$i - $incdec$ptr115$i | 0;
     $sub181$i = $l$0$i - $sub$ptr$sub175$i - $sub$ptr$sub172$i | 0;
     if (($sub181$i | 0) > 0) {
      _memset($pad$i | 0, 48, ($sub181$i >>> 0 > 256 ? 256 : $sub181$i) | 0) | 0;
      if ($sub181$i >>> 0 > 255) {
       $l$addr$010$i460$i = $sub181$i;
       while (1) {
        ___fwritex($pad$i, 256, $f) | 0;
        $sub5$i462$i = $l$addr$010$i460$i + -256 | 0;
        if ($sub5$i462$i >>> 0 > 255) $l$addr$010$i460$i = $sub5$i462$i; else {
         $l$addr$0$lcssa$i465$i = $sub5$i462$i;
         break;
        }
       }
      } else $l$addr$0$lcssa$i465$i = $sub181$i;
      ___fwritex($pad$i, $l$addr$0$lcssa$i465$i, $f) | 0;
     }
     ___fwritex($incdec$ptr115$i, $sub$ptr$sub175$i, $f) | 0;
     if (($and$i415$i | 0) == 8192 & $cmp$i417$i) {
      $sub$i475$i = $w$1 - $add165$i | 0;
      _memset($pad$i | 0, 32, ($sub$i475$i >>> 0 > 256 ? 256 : $sub$i475$i) | 0) | 0;
      if ($sub$i475$i >>> 0 > 255) {
       $l$addr$010$i480$i = $sub$i475$i;
       while (1) {
        ___fwritex($pad$i, 256, $f) | 0;
        $sub5$i482$i = $l$addr$010$i480$i + -256 | 0;
        if ($sub5$i482$i >>> 0 > 255) $l$addr$010$i480$i = $sub5$i482$i; else {
         $l$addr$0$lcssa$i485$i = $sub5$i482$i;
         break;
        }
       }
      } else $l$addr$0$lcssa$i485$i = $sub$i475$i;
      ___fwritex($pad$i, $l$addr$0$lcssa$i485$i, $f) | 0;
     }
     $309 = $82;
     $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
     $cnt$0 = $cnt$1;
     $incdec$ptr$i190563 = $incdec$ptr169;
     $l$0 = $cmp$i417$i ? $w$1 : $add165$i;
     $l10n$0 = $l10n$3;
     continue L1;
    }
    $$p$i = ($p$0 | 0) < 0 ? 6 : $p$0;
    if ($tobool56$i) {
     $sub203$i = (HEAP32[$e2$i >> 2] | 0) + -28 | 0;
     HEAP32[$e2$i >> 2] = $sub203$i;
     $198 = $sub203$i;
     $y$addr$3$i = $mul$i343 * 268435456.0;
    } else {
     $198 = HEAP32[$e2$i >> 2] | 0;
     $y$addr$3$i = $mul$i343;
    }
    $arraydecay208$add$ptr213$i = ($198 | 0) < 0 ? $big$i : $add$ptr213$i;
    $y$addr$4$i = $y$addr$3$i;
    $z$0$i = $arraydecay208$add$ptr213$i;
    do {
     $conv216$i = ~~$y$addr$4$i >>> 0;
     HEAP32[$z$0$i >> 2] = $conv216$i;
     $z$0$i = $z$0$i + 4 | 0;
     $y$addr$4$i = ($y$addr$4$i - +($conv216$i >>> 0)) * 1.0e9;
    } while ($y$addr$4$i != 0.0);
    $$pr$i = HEAP32[$e2$i >> 2] | 0;
    if (($$pr$i | 0) > 0) {
     $199 = $$pr$i;
     $a$1735$i = $arraydecay208$add$ptr213$i;
     $z$1734$i = $z$0$i;
     while (1) {
      $cond233$i = ($199 | 0) > 29 ? 29 : $199;
      $d$0728$i = $z$1734$i + -4 | 0;
      do if ($d$0728$i >>> 0 < $a$1735$i >>> 0) $a$2$ph$i = $a$1735$i; else {
       $carry$0730$i = 0;
       $d$0731$i = $d$0728$i;
       do {
        $201 = _bitshift64Shl(HEAP32[$d$0731$i >> 2] | 0, 0, $cond233$i | 0) | 0;
        $203 = _i64Add($201 | 0, tempRet0 | 0, $carry$0730$i | 0, 0) | 0;
        $204 = tempRet0;
        $205 = ___uremdi3($203 | 0, $204 | 0, 1e9, 0) | 0;
        HEAP32[$d$0731$i >> 2] = $205;
        $carry$0730$i = ___udivdi3($203 | 0, $204 | 0, 1e9, 0) | 0;
        $d$0731$i = $d$0731$i + -4 | 0;
       } while ($d$0731$i >>> 0 >= $a$1735$i >>> 0);
       if (!$carry$0730$i) {
        $a$2$ph$i = $a$1735$i;
        break;
       }
       $incdec$ptr246$i = $a$1735$i + -4 | 0;
       HEAP32[$incdec$ptr246$i >> 2] = $carry$0730$i;
       $a$2$ph$i = $incdec$ptr246$i;
      } while (0);
      $z$2$i = $z$1734$i;
      while (1) {
       if ($z$2$i >>> 0 <= $a$2$ph$i >>> 0) break;
       $arrayidx251$i = $z$2$i + -4 | 0;
       if (!(HEAP32[$arrayidx251$i >> 2] | 0)) $z$2$i = $arrayidx251$i; else break;
      }
      $sub256$i = (HEAP32[$e2$i >> 2] | 0) - $cond233$i | 0;
      HEAP32[$e2$i >> 2] = $sub256$i;
      if (($sub256$i | 0) > 0) {
       $199 = $sub256$i;
       $a$1735$i = $a$2$ph$i;
       $z$1734$i = $z$2$i;
      } else {
       $$pr637$i = $sub256$i;
       $a$1$lcssa$i = $a$2$ph$i;
       $z$1$lcssa$i = $z$2$i;
       break;
      }
     }
    } else {
     $$pr637$i = $$pr$i;
     $a$1$lcssa$i = $arraydecay208$add$ptr213$i;
     $z$1$lcssa$i = $z$0$i;
    }
    L240 : do if (($$pr637$i | 0) < 0) {
     $add275$i = (($$p$i + 25 | 0) / 9 | 0) + 1 | 0;
     if (($or$i344 | 0) == 102) {
      $sub$ptr$rhs$cast306$us$i = $arraydecay208$add$ptr213$i;
      $add$ptr311$us$i = $arraydecay208$add$ptr213$i + ($add275$i << 2) | 0;
      $211 = $$pr637$i;
      $a$3725$us$i = $a$1$lcssa$i;
      $z$3724$us$i = $z$1$lcssa$i;
      while (1) {
       $sub264$us$i = 0 - $211 | 0;
       $$sub264$us$i = ($sub264$us$i | 0) > 9 ? 9 : $sub264$us$i;
       do if ($a$3725$us$i >>> 0 < $z$3724$us$i >>> 0) {
        $sub281$us$i = (1 << $$sub264$us$i) + -1 | 0;
        $shr285$us$i = 1e9 >>> $$sub264$us$i;
        $carry262$0721$us$i = 0;
        $d$1720$us$i = $a$3725$us$i;
        do {
         $215 = HEAP32[$d$1720$us$i >> 2] | 0;
         HEAP32[$d$1720$us$i >> 2] = ($215 >>> $$sub264$us$i) + $carry262$0721$us$i;
         $carry262$0721$us$i = Math_imul($215 & $sub281$us$i, $shr285$us$i) | 0;
         $d$1720$us$i = $d$1720$us$i + 4 | 0;
        } while ($d$1720$us$i >>> 0 < $z$3724$us$i >>> 0);
        $incdec$ptr292$a$3$us$i = (HEAP32[$a$3725$us$i >> 2] | 0) == 0 ? $a$3725$us$i + 4 | 0 : $a$3725$us$i;
        if (!$carry262$0721$us$i) {
         $incdec$ptr292$a$3$us748$i = $incdec$ptr292$a$3$us$i;
         $z$4$us$i = $z$3724$us$i;
         break;
        }
        HEAP32[$z$3724$us$i >> 2] = $carry262$0721$us$i;
        $incdec$ptr292$a$3$us748$i = $incdec$ptr292$a$3$us$i;
        $z$4$us$i = $z$3724$us$i + 4 | 0;
       } else {
        $incdec$ptr292$a$3$us748$i = (HEAP32[$a$3725$us$i >> 2] | 0) == 0 ? $a$3725$us$i + 4 | 0 : $a$3725$us$i;
        $z$4$us$i = $z$3724$us$i;
       } while (0);
       $add$ptr311$us$z$4$us$i = ($z$4$us$i - $sub$ptr$rhs$cast306$us$i >> 2 | 0) > ($add275$i | 0) ? $add$ptr311$us$i : $z$4$us$i;
       $211 = (HEAP32[$e2$i >> 2] | 0) + $$sub264$us$i | 0;
       HEAP32[$e2$i >> 2] = $211;
       if (($211 | 0) >= 0) {
        $a$3$lcssa$i = $incdec$ptr292$a$3$us748$i;
        $z$3$lcssa$i = $add$ptr311$us$z$4$us$i;
        break L240;
       } else {
        $a$3725$us$i = $incdec$ptr292$a$3$us748$i;
        $z$3724$us$i = $add$ptr311$us$z$4$us$i;
       }
      }
     } else {
      $216 = $$pr637$i;
      $a$3725$i = $a$1$lcssa$i;
      $z$3724$i = $z$1$lcssa$i;
     }
     while (1) {
      $sub264$i = 0 - $216 | 0;
      $$sub264$i = ($sub264$i | 0) > 9 ? 9 : $sub264$i;
      do if ($a$3725$i >>> 0 < $z$3724$i >>> 0) {
       $sub281$i = (1 << $$sub264$i) + -1 | 0;
       $shr285$i = 1e9 >>> $$sub264$i;
       $carry262$0721$i = 0;
       $d$1720$i = $a$3725$i;
       do {
        $218 = HEAP32[$d$1720$i >> 2] | 0;
        HEAP32[$d$1720$i >> 2] = ($218 >>> $$sub264$i) + $carry262$0721$i;
        $carry262$0721$i = Math_imul($218 & $sub281$i, $shr285$i) | 0;
        $d$1720$i = $d$1720$i + 4 | 0;
       } while ($d$1720$i >>> 0 < $z$3724$i >>> 0);
       $incdec$ptr292$a$3$i = (HEAP32[$a$3725$i >> 2] | 0) == 0 ? $a$3725$i + 4 | 0 : $a$3725$i;
       if (!$carry262$0721$i) {
        $incdec$ptr292$a$3753$i = $incdec$ptr292$a$3$i;
        $z$4$i = $z$3724$i;
        break;
       }
       HEAP32[$z$3724$i >> 2] = $carry262$0721$i;
       $incdec$ptr292$a$3753$i = $incdec$ptr292$a$3$i;
       $z$4$i = $z$3724$i + 4 | 0;
      } else {
       $incdec$ptr292$a$3753$i = (HEAP32[$a$3725$i >> 2] | 0) == 0 ? $a$3725$i + 4 | 0 : $a$3725$i;
       $z$4$i = $z$3724$i;
      } while (0);
      if (($z$4$i - $incdec$ptr292$a$3753$i >> 2 | 0) > ($add275$i | 0)) $z$5$i = $incdec$ptr292$a$3753$i + ($add275$i << 2) | 0; else $z$5$i = $z$4$i;
      $216 = (HEAP32[$e2$i >> 2] | 0) + $$sub264$i | 0;
      HEAP32[$e2$i >> 2] = $216;
      if (($216 | 0) >= 0) {
       $a$3$lcssa$i = $incdec$ptr292$a$3753$i;
       $z$3$lcssa$i = $z$5$i;
       break;
      } else {
       $a$3725$i = $incdec$ptr292$a$3753$i;
       $z$3724$i = $z$5$i;
      }
     }
    } else {
     $a$3$lcssa$i = $a$1$lcssa$i;
     $z$3$lcssa$i = $z$1$lcssa$i;
    } while (0);
    $sub$ptr$lhs$cast318$i = $arraydecay208$add$ptr213$i;
    do if ($a$3$lcssa$i >>> 0 < $z$3$lcssa$i >>> 0) {
     $mul322$i = ($sub$ptr$lhs$cast318$i - $a$3$lcssa$i >> 2) * 9 | 0;
     $221 = HEAP32[$a$3$lcssa$i >> 2] | 0;
     if ($221 >>> 0 < 10) {
      $e$1$i = $mul322$i;
      break;
     } else {
      $e$0717$i = $mul322$i;
      $i$0716$i = 10;
     }
     while (1) {
      $i$0716$i = $i$0716$i * 10 | 0;
      $inc$i = $e$0717$i + 1 | 0;
      if ($221 >>> 0 < $i$0716$i >>> 0) {
       $e$1$i = $inc$i;
       break;
      } else $e$0717$i = $inc$i;
     }
    } else $e$1$i = 0; while (0);
    $cmp338$i = ($or$i344 | 0) == 103;
    $sub343$i = $$p$i - (($or$i344 | 0) != 102 ? $e$1$i : 0) + (($cmp338$i & ($$p$i | 0) != 0) << 31 >> 31) | 0;
    if (($sub343$i | 0) < ((($z$3$lcssa$i - $sub$ptr$lhs$cast318$i >> 2) * 9 | 0) + -9 | 0)) {
     $add355$i = $sub343$i + 9216 | 0;
     $div356$i = ($add355$i | 0) / 9 | 0;
     $add$ptr358$i = $arraydecay208$add$ptr213$i + ($div356$i + -1023 << 2) | 0;
     $j$0710$i = (($add355$i | 0) % 9 | 0) + 1 | 0;
     if (($j$0710$i | 0) < 9) {
      $i$1712$i = 10;
      $j$0713$i = $j$0710$i;
      while (1) {
       $mul367$i = $i$1712$i * 10 | 0;
       $j$0713$i = $j$0713$i + 1 | 0;
       if (($j$0713$i | 0) == 9) {
        $i$1$lcssa$i = $mul367$i;
        break;
       } else $i$1712$i = $mul367$i;
      }
     } else $i$1$lcssa$i = 10;
     $223 = HEAP32[$add$ptr358$i >> 2] | 0;
     $rem370$i = ($223 >>> 0) % ($i$1$lcssa$i >>> 0) | 0;
     if (!$rem370$i) if (($arraydecay208$add$ptr213$i + ($div356$i + -1022 << 2) | 0) == ($z$3$lcssa$i | 0)) {
      $a$7$i = $a$3$lcssa$i;
      $d$3$i = $add$ptr358$i;
      $e$3$i = $e$1$i;
     } else label = 233; else label = 233;
     do if ((label | 0) == 233) {
      label = 0;
      $$365$i = ((($223 >>> 0) / ($i$1$lcssa$i >>> 0) | 0) & 1 | 0) == 0 ? 9007199254740992.0 : 9007199254740994.0;
      $div384$i = ($i$1$lcssa$i | 0) / 2 | 0;
      do if ($rem370$i >>> 0 < $div384$i >>> 0) $small$0$i = .5; else {
       if (($rem370$i | 0) == ($div384$i | 0)) if (($arraydecay208$add$ptr213$i + ($div356$i + -1022 << 2) | 0) == ($z$3$lcssa$i | 0)) {
        $small$0$i = 1.0;
        break;
       }
       $small$0$i = 1.5;
      } while (0);
      do if (!$pl$0$i) {
       $round377$1$i = $$365$i;
       $small$1$i = $small$0$i;
      } else {
       if ((HEAP8[$prefix$0$i >> 0] | 0) != 45) {
        $round377$1$i = $$365$i;
        $small$1$i = $small$0$i;
        break;
       }
       $round377$1$i = $$365$i * -1.0;
       $small$1$i = $small$0$i * -1.0;
      } while (0);
      $sub409$i = $223 - $rem370$i | 0;
      HEAP32[$add$ptr358$i >> 2] = $sub409$i;
      if (!($round377$1$i + $small$1$i != $round377$1$i)) {
       $a$7$i = $a$3$lcssa$i;
       $d$3$i = $add$ptr358$i;
       $e$3$i = $e$1$i;
       break;
      }
      $add414$i = $sub409$i + $i$1$lcssa$i | 0;
      HEAP32[$add$ptr358$i >> 2] = $add414$i;
      if ($add414$i >>> 0 > 999999999) {
       $a$5707$i = $a$3$lcssa$i;
       $d$2706$i = $add$ptr358$i;
       while (1) {
        $incdec$ptr419$i = $d$2706$i + -4 | 0;
        HEAP32[$d$2706$i >> 2] = 0;
        if ($incdec$ptr419$i >>> 0 < $a$5707$i >>> 0) {
         $incdec$ptr423$i = $a$5707$i + -4 | 0;
         HEAP32[$incdec$ptr423$i >> 2] = 0;
         $a$6$i = $incdec$ptr423$i;
        } else $a$6$i = $a$5707$i;
        $inc425$i = (HEAP32[$incdec$ptr419$i >> 2] | 0) + 1 | 0;
        HEAP32[$incdec$ptr419$i >> 2] = $inc425$i;
        if ($inc425$i >>> 0 > 999999999) {
         $a$5707$i = $a$6$i;
         $d$2706$i = $incdec$ptr419$i;
        } else {
         $a$5$lcssa$i = $a$6$i;
         $d$2$lcssa$i = $incdec$ptr419$i;
         break;
        }
       }
      } else {
       $a$5$lcssa$i = $a$3$lcssa$i;
       $d$2$lcssa$i = $add$ptr358$i;
      }
      $mul431$i = ($sub$ptr$lhs$cast318$i - $a$5$lcssa$i >> 2) * 9 | 0;
      $226 = HEAP32[$a$5$lcssa$i >> 2] | 0;
      if ($226 >>> 0 < 10) {
       $a$7$i = $a$5$lcssa$i;
       $d$3$i = $d$2$lcssa$i;
       $e$3$i = $mul431$i;
       break;
      } else {
       $e$2703$i = $mul431$i;
       $i$2702$i = 10;
      }
      while (1) {
       $i$2702$i = $i$2702$i * 10 | 0;
       $inc438$i = $e$2703$i + 1 | 0;
       if ($226 >>> 0 < $i$2702$i >>> 0) {
        $a$7$i = $a$5$lcssa$i;
        $d$3$i = $d$2$lcssa$i;
        $e$3$i = $inc438$i;
        break;
       } else $e$2703$i = $inc438$i;
      }
     } while (0);
     $add$ptr442$i = $d$3$i + 4 | 0;
     $a$8$ph$i = $a$7$i;
     $e$4$ph$i = $e$3$i;
     $z$6$ph$i = $z$3$lcssa$i >>> 0 > $add$ptr442$i >>> 0 ? $add$ptr442$i : $z$3$lcssa$i;
    } else {
     $a$8$ph$i = $a$3$lcssa$i;
     $e$4$ph$i = $e$1$i;
     $z$6$ph$i = $z$3$lcssa$i;
    }
    $sub626$i = 0 - $e$4$ph$i | 0;
    $z$6$i = $z$6$ph$i;
    while (1) {
     if ($z$6$i >>> 0 <= $a$8$ph$i >>> 0) {
      $cmp450$lcssa$i = 0;
      break;
     }
     $arrayidx453$i = $z$6$i + -4 | 0;
     if (!(HEAP32[$arrayidx453$i >> 2] | 0)) $z$6$i = $arrayidx453$i; else {
      $cmp450$lcssa$i = 1;
      break;
     }
    }
    do if ($cmp338$i) {
     $inc468$$p$i = (($$p$i | 0) == 0 & 1) + $$p$i | 0;
     if (($inc468$$p$i | 0) > ($e$4$ph$i | 0) & ($e$4$ph$i | 0) > -5) {
      $p$addr$2$i = $inc468$$p$i + -1 - $e$4$ph$i | 0;
      $t$addr$0$i = $t$0 + -1 | 0;
     } else {
      $p$addr$2$i = $inc468$$p$i + -1 | 0;
      $t$addr$0$i = $t$0 + -2 | 0;
     }
     if ($fl$1$and219 & 8) {
      $p$addr$3$i = $p$addr$2$i;
      $t$addr$1$i = $t$addr$0$i;
      break;
     }
     do if ($cmp450$lcssa$i) {
      $228 = HEAP32[$z$6$i + -4 >> 2] | 0;
      if (!$228) {
       $j$2$i = 9;
       break;
      }
      if (!(($228 >>> 0) % 10 | 0)) {
       $i$3698$i = 10;
       $j$1699$i = 0;
      } else {
       $j$2$i = 0;
       break;
      }
      while (1) {
       $i$3698$i = $i$3698$i * 10 | 0;
       $inc500$i = $j$1699$i + 1 | 0;
       if (($228 >>> 0) % ($i$3698$i >>> 0) | 0) {
        $j$2$i = $inc500$i;
        break;
       } else $j$1699$i = $inc500$i;
      }
     } else $j$2$i = 9; while (0);
     $mul513$i = (($z$6$i - $sub$ptr$lhs$cast318$i >> 2) * 9 | 0) + -9 | 0;
     if (($t$addr$0$i | 32 | 0) == 102) {
      $sub514$i = $mul513$i - $j$2$i | 0;
      $$sub514$i = ($sub514$i | 0) < 0 ? 0 : $sub514$i;
      $p$addr$3$i = ($p$addr$2$i | 0) < ($$sub514$i | 0) ? $p$addr$2$i : $$sub514$i;
      $t$addr$1$i = $t$addr$0$i;
      break;
     } else {
      $sub562$i = $mul513$i + $e$4$ph$i - $j$2$i | 0;
      $$sub562$i = ($sub562$i | 0) < 0 ? 0 : $sub562$i;
      $p$addr$3$i = ($p$addr$2$i | 0) < ($$sub562$i | 0) ? $p$addr$2$i : $$sub562$i;
      $t$addr$1$i = $t$addr$0$i;
      break;
     }
    } else {
     $p$addr$3$i = $$p$i;
     $t$addr$1$i = $t$0;
    } while (0);
    $tobool609$i = ($p$addr$3$i | 0) != 0;
    if ($tobool609$i) $230 = 1; else $230 = ($fl$1$and219 & 8 | 0) != 0;
    $lor$ext$i = $230 & 1;
    $cmp614$i = ($t$addr$1$i | 32 | 0) == 102;
    if ($cmp614$i) {
     $estr$2$i = 0;
     $sub$ptr$sub650$pn$i = ($e$4$ph$i | 0) > 0 ? $e$4$ph$i : 0;
    } else {
     $cond629$i = ($e$4$ph$i | 0) < 0 ? $sub626$i : $e$4$ph$i;
     if (($cond629$i | 0) < 0) {
      $233 = $cond629$i;
      $234 = (($cond629$i | 0) < 0) << 31 >> 31;
      $s$addr$014$i491$i = $arrayidx$i335;
      while (1) {
       $235 = ___uremdi3($233 | 0, $234 | 0, 10, 0) | 0;
       $s$addr$014$i491$i = $s$addr$014$i491$i + -1 | 0;
       HEAP8[$s$addr$014$i491$i >> 0] = $235 | 48;
       $233$looptemp = $233;
       $233 = ___udivdi3($233 | 0, $234 | 0, 10, 0) | 0;
       if (!($234 >>> 0 > 9 | ($234 | 0) == 9 & $233$looptemp >>> 0 > 4294967295)) break; else $234 = tempRet0;
      }
      $s$addr$0$lcssa$i502$i = $s$addr$014$i491$i;
      $x$addr$0$lcssa$off0$i503$i = $233;
     } else {
      $s$addr$0$lcssa$i502$i = $arrayidx$i335;
      $x$addr$0$lcssa$off0$i503$i = $cond629$i;
     }
     if (!$x$addr$0$lcssa$off0$i503$i) $estr$1$ph$i = $s$addr$0$lcssa$i502$i; else {
      $s$addr$110$i507$i = $s$addr$0$lcssa$i502$i;
      $y$011$i506$i = $x$addr$0$lcssa$off0$i503$i;
      while (1) {
       $incdec$ptr7$i511$i = $s$addr$110$i507$i + -1 | 0;
       HEAP8[$incdec$ptr7$i511$i >> 0] = ($y$011$i506$i >>> 0) % 10 | 0 | 48;
       if ($y$011$i506$i >>> 0 < 10) {
        $estr$1$ph$i = $incdec$ptr7$i511$i;
        break;
       } else {
        $s$addr$110$i507$i = $incdec$ptr7$i511$i;
        $y$011$i506$i = ($y$011$i506$i >>> 0) / 10 | 0;
       }
      }
     }
     if (($sub$ptr$lhs$cast160$i - $estr$1$ph$i | 0) < 2) {
      $estr$1693$i = $estr$1$ph$i;
      while (1) {
       $incdec$ptr639$i = $estr$1693$i + -1 | 0;
       HEAP8[$incdec$ptr639$i >> 0] = 48;
       if (($sub$ptr$lhs$cast160$i - $incdec$ptr639$i | 0) < 2) $estr$1693$i = $incdec$ptr639$i; else {
        $estr$1$lcssa$i = $incdec$ptr639$i;
        break;
       }
      }
     } else $estr$1$lcssa$i = $estr$1$ph$i;
     HEAP8[$estr$1$lcssa$i + -1 >> 0] = ($e$4$ph$i >> 31 & 2) + 43;
     $incdec$ptr647$i = $estr$1$lcssa$i + -2 | 0;
     HEAP8[$incdec$ptr647$i >> 0] = $t$addr$1$i;
     $estr$2$i = $incdec$ptr647$i;
     $sub$ptr$sub650$pn$i = $sub$ptr$lhs$cast160$i - $incdec$ptr647$i | 0;
    }
    $add653$i = $pl$0$i + 1 + $p$addr$3$i + $lor$ext$i + $sub$ptr$sub650$pn$i | 0;
    $and$i517$i = $fl$1$and219 & 73728;
    $cmp$i519$i = ($add653$i | 0) < ($w$1 | 0);
    if (($and$i517$i | 0) == 0 & $cmp$i519$i) {
     $sub$i521$i = $w$1 - $add653$i | 0;
     _memset($pad$i | 0, 32, ($sub$i521$i >>> 0 > 256 ? 256 : $sub$i521$i) | 0) | 0;
     if ($sub$i521$i >>> 0 > 255) {
      $l$addr$010$i526$i = $sub$i521$i;
      while (1) {
       ___fwritex($pad$i, 256, $f) | 0;
       $sub5$i528$i = $l$addr$010$i526$i + -256 | 0;
       if ($sub5$i528$i >>> 0 > 255) $l$addr$010$i526$i = $sub5$i528$i; else {
        $l$addr$0$lcssa$i531$i = $sub5$i528$i;
        break;
       }
      }
     } else $l$addr$0$lcssa$i531$i = $sub$i521$i;
     ___fwritex($pad$i, $l$addr$0$lcssa$i531$i, $f) | 0;
    }
    ___fwritex($prefix$0$i, $pl$0$i, $f) | 0;
    if (($and$i517$i | 0) == 65536 & $cmp$i519$i) {
     $sub$i541$i = $w$1 - $add653$i | 0;
     _memset($pad$i | 0, 48, ($sub$i541$i >>> 0 > 256 ? 256 : $sub$i541$i) | 0) | 0;
     if ($sub$i541$i >>> 0 > 255) {
      $l$addr$010$i546$i = $sub$i541$i;
      while (1) {
       ___fwritex($pad$i, 256, $f) | 0;
       $sub5$i548$i = $l$addr$010$i546$i + -256 | 0;
       if ($sub5$i548$i >>> 0 > 255) $l$addr$010$i546$i = $sub5$i548$i; else {
        $l$addr$0$lcssa$i551$i = $sub5$i548$i;
        break;
       }
      }
     } else $l$addr$0$lcssa$i551$i = $sub$i541$i;
     ___fwritex($pad$i, $l$addr$0$lcssa$i551$i, $f) | 0;
    }
    do if ($cmp614$i) {
     $r$0$a$8$i = $a$8$ph$i >>> 0 > $arraydecay208$add$ptr213$i >>> 0 ? $arraydecay208$add$ptr213$i : $a$8$ph$i;
     $d$4680$i = $r$0$a$8$i;
     do {
      $250 = HEAP32[$d$4680$i >> 2] | 0;
      if (!$250) $s$addr$1$lcssa$i568$i = $add$ptr671$i; else {
       $s$addr$110$i561$i = $add$ptr671$i;
       $y$011$i560$i = $250;
       while (1) {
        $incdec$ptr7$i565$i = $s$addr$110$i561$i + -1 | 0;
        HEAP8[$incdec$ptr7$i565$i >> 0] = ($y$011$i560$i >>> 0) % 10 | 0 | 48;
        if ($y$011$i560$i >>> 0 < 10) {
         $s$addr$1$lcssa$i568$i = $incdec$ptr7$i565$i;
         break;
        } else {
         $s$addr$110$i561$i = $incdec$ptr7$i565$i;
         $y$011$i560$i = ($y$011$i560$i >>> 0) / 10 | 0;
        }
       }
      }
      do if (($d$4680$i | 0) == ($r$0$a$8$i | 0)) {
       if (($s$addr$1$lcssa$i568$i | 0) != ($add$ptr671$i | 0)) {
        $s668$1$i = $s$addr$1$lcssa$i568$i;
        break;
       }
       HEAP8[$incdec$ptr689$i >> 0] = 48;
       $s668$1$i = $incdec$ptr689$i;
      } else {
       if ($s$addr$1$lcssa$i568$i >>> 0 > $buf$i >>> 0) $s668$0678$i = $s$addr$1$lcssa$i568$i; else {
        $s668$1$i = $s$addr$1$lcssa$i568$i;
        break;
       }
       while (1) {
        $incdec$ptr681$i = $s668$0678$i + -1 | 0;
        HEAP8[$incdec$ptr681$i >> 0] = 48;
        if ($incdec$ptr681$i >>> 0 > $buf$i >>> 0) $s668$0678$i = $incdec$ptr681$i; else {
         $s668$1$i = $incdec$ptr681$i;
         break;
        }
       }
      } while (0);
      ___fwritex($s668$1$i, $sub$ptr$lhs$cast694$i - $s668$1$i | 0, $f) | 0;
      $d$4680$i = $d$4680$i + 4 | 0;
     } while ($d$4680$i >>> 0 <= $arraydecay208$add$ptr213$i >>> 0);
     if (!$tobool609$i) if (!($fl$1$and219 & 8)) break;
     ___fwritex(2264, 1, $f) | 0;
     if ($d$4680$i >>> 0 < $z$6$i >>> 0 & ($p$addr$3$i | 0) > 0) {
      $d$5674$i = $d$4680$i;
      $p$addr$4675$i = $p$addr$3$i;
      while (1) {
       $252 = HEAP32[$d$5674$i >> 2] | 0;
       if (!$252) {
        $s715$0669$i = $add$ptr671$i;
        label = 300;
       } else {
        $s$addr$110$i578$i = $add$ptr671$i;
        $y$011$i577$i = $252;
        while (1) {
         $s$addr$110$i578$i = $s$addr$110$i578$i + -1 | 0;
         HEAP8[$s$addr$110$i578$i >> 0] = ($y$011$i577$i >>> 0) % 10 | 0 | 48;
         if ($y$011$i577$i >>> 0 < 10) break; else $y$011$i577$i = ($y$011$i577$i >>> 0) / 10 | 0;
        }
        if ($s$addr$110$i578$i >>> 0 > $buf$i >>> 0) {
         $s715$0669$i = $s$addr$110$i578$i;
         label = 300;
        } else $s715$0$lcssa$i = $s$addr$110$i578$i;
       }
       if ((label | 0) == 300) while (1) {
        label = 0;
        $incdec$ptr725$i = $s715$0669$i + -1 | 0;
        HEAP8[$incdec$ptr725$i >> 0] = 48;
        if ($incdec$ptr725$i >>> 0 > $buf$i >>> 0) {
         $s715$0669$i = $incdec$ptr725$i;
         label = 300;
        } else {
         $s715$0$lcssa$i = $incdec$ptr725$i;
         break;
        }
       }
       ___fwritex($s715$0$lcssa$i, ($p$addr$4675$i | 0) > 9 ? 9 : $p$addr$4675$i, $f) | 0;
       $d$5674$i = $d$5674$i + 4 | 0;
       $sub735$i = $p$addr$4675$i + -9 | 0;
       if (!($d$5674$i >>> 0 < $z$6$i >>> 0 & ($sub735$i | 0) > 0)) {
        $p$addr$4$lcssa$i = $sub735$i;
        break;
       } else $p$addr$4675$i = $sub735$i;
      }
     } else $p$addr$4$lcssa$i = $p$addr$3$i;
     if (($p$addr$4$lcssa$i | 0) <= 0) break;
     _memset($pad$i | 0, 48, ($p$addr$4$lcssa$i >>> 0 > 256 ? 256 : $p$addr$4$lcssa$i) | 0) | 0;
     if ($p$addr$4$lcssa$i >>> 0 > 255) {
      $l$addr$010$i594$i = $p$addr$4$lcssa$i;
      while (1) {
       ___fwritex($pad$i, 256, $f) | 0;
       $sub5$i596$i = $l$addr$010$i594$i + -256 | 0;
       if ($sub5$i596$i >>> 0 > 255) $l$addr$010$i594$i = $sub5$i596$i; else {
        $l$addr$0$lcssa$i599$i = $sub5$i596$i;
        break;
       }
      }
     } else $l$addr$0$lcssa$i599$i = $p$addr$4$lcssa$i;
     ___fwritex($pad$i, $l$addr$0$lcssa$i599$i, $f) | 0;
    } else {
     $z$6$add$ptr742$i = $cmp450$lcssa$i ? $z$6$i : $a$8$ph$i + 4 | 0;
     do if (($p$addr$3$i | 0) > -1) {
      $tobool781$not$i = ($fl$1$and219 & 8 | 0) != 0;
      $d$6687$i = $a$8$ph$i;
      $p$addr$5688$i = $p$addr$3$i;
      do {
       $254 = HEAP32[$d$6687$i >> 2] | 0;
       if (!$254) label = 311; else {
        $s$addr$110$i609$i = $add$ptr671$i;
        $y$011$i608$i = $254;
        while (1) {
         $s$addr$110$i609$i = $s$addr$110$i609$i + -1 | 0;
         HEAP8[$s$addr$110$i609$i >> 0] = ($y$011$i608$i >>> 0) % 10 | 0 | 48;
         if ($y$011$i608$i >>> 0 < 10) break; else $y$011$i608$i = ($y$011$i608$i >>> 0) / 10 | 0;
        }
        if (($s$addr$110$i609$i | 0) == ($add$ptr671$i | 0)) label = 311; else $s753$0$i = $s$addr$110$i609$i;
       }
       if ((label | 0) == 311) {
        label = 0;
        HEAP8[$incdec$ptr689$i >> 0] = 48;
        $s753$0$i = $incdec$ptr689$i;
       }
       do if (($d$6687$i | 0) == ($a$8$ph$i | 0)) {
        $incdec$ptr776$i = $s753$0$i + 1 | 0;
        ___fwritex($s753$0$i, 1, $f) | 0;
        if (!(($p$addr$5688$i | 0) > 0 | $tobool781$not$i)) {
         $s753$2$i = $incdec$ptr776$i;
         break;
        }
        ___fwritex(2264, 1, $f) | 0;
        $s753$2$i = $incdec$ptr776$i;
       } else {
        if ($s753$0$i >>> 0 > $buf$i >>> 0) $s753$1682$i = $s753$0$i; else {
         $s753$2$i = $s753$0$i;
         break;
        }
        while (1) {
         $incdec$ptr773$i = $s753$1682$i + -1 | 0;
         HEAP8[$incdec$ptr773$i >> 0] = 48;
         if ($incdec$ptr773$i >>> 0 > $buf$i >>> 0) $s753$1682$i = $incdec$ptr773$i; else {
          $s753$2$i = $incdec$ptr773$i;
          break;
         }
        }
       } while (0);
       $sub$ptr$sub789$i = $sub$ptr$lhs$cast694$i - $s753$2$i | 0;
       ___fwritex($s753$2$i, ($sub$ptr$sub789$i | 0) < ($p$addr$5688$i | 0) ? $sub$ptr$sub789$i : $p$addr$5688$i, $f) | 0;
       $p$addr$5688$i = $p$addr$5688$i - $sub$ptr$sub789$i | 0;
       $d$6687$i = $d$6687$i + 4 | 0;
      } while ($d$6687$i >>> 0 < $z$6$add$ptr742$i >>> 0 & ($p$addr$5688$i | 0) > -1);
      if (($p$addr$5688$i | 0) <= 0) break;
      _memset($pad$i | 0, 48, ($p$addr$5688$i >>> 0 > 256 ? 256 : $p$addr$5688$i) | 0) | 0;
      if ($p$addr$5688$i >>> 0 > 255) {
       $l$addr$010$i627$i = $p$addr$5688$i;
       while (1) {
        ___fwritex($pad$i, 256, $f) | 0;
        $sub5$i629$i = $l$addr$010$i627$i + -256 | 0;
        if ($sub5$i629$i >>> 0 > 255) $l$addr$010$i627$i = $sub5$i629$i; else {
         $l$addr$0$lcssa$i632$i = $sub5$i629$i;
         break;
        }
       }
      } else $l$addr$0$lcssa$i632$i = $p$addr$5688$i;
      ___fwritex($pad$i, $l$addr$0$lcssa$i632$i, $f) | 0;
     } while (0);
     ___fwritex($estr$2$i, $sub$ptr$lhs$cast160$i - $estr$2$i | 0, $f) | 0;
    } while (0);
    if (($and$i517$i | 0) == 8192 & $cmp$i519$i) {
     $sub$i$i = $w$1 - $add653$i | 0;
     _memset($pad$i | 0, 32, ($sub$i$i >>> 0 > 256 ? 256 : $sub$i$i) | 0) | 0;
     if ($sub$i$i >>> 0 > 255) {
      $l$addr$010$i$i = $sub$i$i;
      while (1) {
       ___fwritex($pad$i, 256, $f) | 0;
       $sub5$i$i = $l$addr$010$i$i + -256 | 0;
       if ($sub5$i$i >>> 0 > 255) $l$addr$010$i$i = $sub5$i$i; else {
        $l$addr$0$lcssa$i$i = $sub5$i$i;
        break;
       }
      }
     } else $l$addr$0$lcssa$i$i = $sub$i$i;
     ___fwritex($pad$i, $l$addr$0$lcssa$i$i, $f) | 0;
    }
    $309 = $82;
    $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
    $cnt$0 = $cnt$1;
    $incdec$ptr$i190563 = $incdec$ptr169;
    $l$0 = $cmp$i519$i ? $w$1 : $add653$i;
    $l10n$0 = $l10n$3;
    continue L1;
    break;
   }
  case 111:
   {
    $107 = $82;
    $110 = ($107 | 0) == 0 & ($arg$sroa$0$sroa$1$4$extract$trunc531556568 | 0) == 0;
    if ($110) $s$addr$0$lcssa$i269 = $add$ptr205; else {
     $112 = $107;
     $115 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
     $s$addr$07$i = $add$ptr205;
     while (1) {
      $incdec$ptr$i265 = $s$addr$07$i + -1 | 0;
      HEAP8[$incdec$ptr$i265 >> 0] = $112 & 7 | 48;
      $112 = _bitshift64Lshr($112 | 0, $115 | 0, 3) | 0;
      $115 = tempRet0;
      if (($112 | 0) == 0 & ($115 | 0) == 0) {
       $s$addr$0$lcssa$i269 = $incdec$ptr$i265;
       break;
      } else $s$addr$07$i = $incdec$ptr$i265;
     }
    }
    if (!($fl$1$and219 & 8)) {
     $148 = $82;
     $a$0 = $s$addr$0$lcssa$i269;
     $arg$sroa$0$sroa$1$4$extract$trunc531553 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
     $fl$4 = $fl$1$and219;
     $p$2 = $p$0;
     $pl$1 = 0;
     $prefix$1 = 2168;
     label = 94;
    } else {
     $148 = $82;
     $a$0 = $s$addr$0$lcssa$i269;
     $arg$sroa$0$sroa$1$4$extract$trunc531553 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
     $fl$4 = $fl$1$and219;
     $p$2 = $p$0;
     $pl$1 = $110 & 1 ^ 1;
     $prefix$1 = $110 ? 2168 : 2173;
     label = 94;
    }
    break;
   }
  case 105:
  case 100:
   {
    if (($arg$sroa$0$sroa$1$4$extract$trunc531556568 | 0) < 0) {
     $124 = _i64Subtract(0, 0, $82 | 0, $arg$sroa$0$sroa$1$4$extract$trunc531556568 | 0) | 0;
     $127 = $124;
     $arg$sroa$0$sroa$1$4$extract$trunc531554 = tempRet0;
     $pl$0 = 1;
     $prefix$0 = 2168;
     label = 89;
     break L92;
    }
    if (!($fl$1$and219 & 2048)) {
     $and287 = $fl$1$and219 & 1;
     $127 = $82;
     $arg$sroa$0$sroa$1$4$extract$trunc531554 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
     $pl$0 = $and287;
     $prefix$0 = ($and287 | 0) == 0 ? 2168 : 2170;
     label = 89;
    } else {
     $127 = $82;
     $arg$sroa$0$sroa$1$4$extract$trunc531554 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
     $pl$0 = 1;
     $prefix$0 = 2169;
     label = 89;
    }
    break;
   }
  case 88:
  case 120:
   {
    $fl$3 = $fl$1$and219;
    $p$1 = $p$0;
    $t$1 = $t$0;
    label = 77;
    break;
   }
  case 112:
   {
    $fl$3 = $fl$1$and219 | 8;
    $p$1 = $p$0 >>> 0 > 8 ? $p$0 : 8;
    $t$1 = 120;
    label = 77;
    break;
   }
  case 109:
   {
    $a$1 = _strerror(HEAP32[(___errno_location() | 0) >> 2] | 0) | 0;
    label = 99;
    break;
   }
  case 115:
   {
    $a$1 = ($82 | 0) == 0 ? 2184 : $82;
    label = 99;
    break;
   }
  default:
   {
    $313 = $82;
    $a$2 = $incdec$ptr$i190563;
    $arg$sroa$0$sroa$1$4$extract$trunc531555 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
    $fl$6 = $fl$1$and219;
    $p$5 = $p$0;
    $pl$2 = 0;
    $prefix$2 = 2168;
    $z$2 = $add$ptr205;
   }
  } while (0);
  L445 : do if ((label | 0) == 77) {
   label = 0;
   $95 = $82;
   $and249 = $t$1 & 32;
   if (($95 | 0) == 0 & ($arg$sroa$0$sroa$1$4$extract$trunc531556568 | 0) == 0) {
    $148 = $82;
    $a$0 = $add$ptr205;
    $arg$sroa$0$sroa$1$4$extract$trunc531553 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
    $fl$4 = $fl$3;
    $p$2 = $p$1;
    $pl$1 = 0;
    $prefix$1 = 2168;
    label = 94;
   } else {
    $101 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
    $99 = $95;
    $s$addr$06$i = $add$ptr205;
    do {
     $s$addr$06$i = $s$addr$06$i + -1 | 0;
     HEAP8[$s$addr$06$i >> 0] = HEAPU8[2248 + ($99 & 15) >> 0] | $and249;
     $99 = _bitshift64Lshr($99 | 0, $101 | 0, 4) | 0;
     $101 = tempRet0;
    } while (!(($99 | 0) == 0 & ($101 | 0) == 0));
    if (!($fl$3 & 8)) {
     $148 = $82;
     $a$0 = $s$addr$06$i;
     $arg$sroa$0$sroa$1$4$extract$trunc531553 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
     $fl$4 = $fl$3;
     $p$2 = $p$1;
     $pl$1 = 0;
     $prefix$1 = 2168;
     label = 94;
    } else {
     $148 = $82;
     $a$0 = $s$addr$06$i;
     $arg$sroa$0$sroa$1$4$extract$trunc531553 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
     $fl$4 = $fl$3;
     $p$2 = $p$1;
     $pl$1 = 2;
     $prefix$1 = 2168 + ($t$1 >> 4) | 0;
     label = 94;
    }
   }
  } else if ((label | 0) == 89) {
   label = 0;
   $128 = $127;
   if ($arg$sroa$0$sroa$1$4$extract$trunc531554 >>> 0 > 0 | ($arg$sroa$0$sroa$1$4$extract$trunc531554 | 0) == 0 & $128 >>> 0 > 4294967295) {
    $134 = $128;
    $135 = $arg$sroa$0$sroa$1$4$extract$trunc531554;
    $s$addr$014$i = $add$ptr205;
    while (1) {
     $136 = ___uremdi3($134 | 0, $135 | 0, 10, 0) | 0;
     $s$addr$014$i = $s$addr$014$i + -1 | 0;
     HEAP8[$s$addr$014$i >> 0] = $136 | 48;
     $134$looptemp = $134;
     $134 = ___udivdi3($134 | 0, $135 | 0, 10, 0) | 0;
     if (!($135 >>> 0 > 9 | ($135 | 0) == 9 & $134$looptemp >>> 0 > 4294967295)) break; else $135 = tempRet0;
    }
    $s$addr$0$lcssa$i275 = $s$addr$014$i;
    $x$addr$0$lcssa$off0$i = $134;
   } else {
    $s$addr$0$lcssa$i275 = $add$ptr205;
    $x$addr$0$lcssa$off0$i = $128;
   }
   if (!$x$addr$0$lcssa$off0$i) {
    $148 = $127;
    $a$0 = $s$addr$0$lcssa$i275;
    $arg$sroa$0$sroa$1$4$extract$trunc531553 = $arg$sroa$0$sroa$1$4$extract$trunc531554;
    $fl$4 = $fl$1$and219;
    $p$2 = $p$0;
    $pl$1 = $pl$0;
    $prefix$1 = $prefix$0;
    label = 94;
   } else {
    $s$addr$110$i = $s$addr$0$lcssa$i275;
    $y$011$i = $x$addr$0$lcssa$off0$i;
    while (1) {
     $incdec$ptr7$i = $s$addr$110$i + -1 | 0;
     HEAP8[$incdec$ptr7$i >> 0] = ($y$011$i >>> 0) % 10 | 0 | 48;
     if ($y$011$i >>> 0 < 10) {
      $148 = $127;
      $a$0 = $incdec$ptr7$i;
      $arg$sroa$0$sroa$1$4$extract$trunc531553 = $arg$sroa$0$sroa$1$4$extract$trunc531554;
      $fl$4 = $fl$1$and219;
      $p$2 = $p$0;
      $pl$1 = $pl$0;
      $prefix$1 = $prefix$0;
      label = 94;
      break;
     } else {
      $s$addr$110$i = $incdec$ptr7$i;
      $y$011$i = ($y$011$i >>> 0) / 10 | 0;
     }
    }
   }
  } else if ((label | 0) == 99) {
   label = 0;
   $call349 = _memchr($a$1, 0, $p$0) | 0;
   if (!$call349) {
    $313 = $82;
    $a$2 = $a$1;
    $arg$sroa$0$sroa$1$4$extract$trunc531555 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
    $fl$6 = $and219;
    $p$5 = $p$0;
    $pl$2 = 0;
    $prefix$2 = 2168;
    $z$2 = $a$1 + $p$0 | 0;
    break;
   } else {
    $313 = $82;
    $a$2 = $a$1;
    $arg$sroa$0$sroa$1$4$extract$trunc531555 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
    $fl$6 = $and219;
    $p$5 = $call349 - $a$1 | 0;
    $pl$2 = 0;
    $prefix$2 = 2168;
    $z$2 = $call349;
    break;
   }
  } else if ((label | 0) == 104) {
   label = 0;
   $i$0612 = 0;
   $l$1611 = 0;
   $ws$0613 = $314;
   while (1) {
    $156 = HEAP32[$ws$0613 >> 2] | 0;
    if (!$156) {
     $i$0$lcssa = $i$0612;
     $l$1$lcssa = $l$1611;
     break;
    }
    $call377 = _wctomb($mb, $156) | 0;
    if (($call377 | 0) <= -1) {
     $retval$0 = -1;
     label = 362;
     break L1;
    }
    $add388 = $call377 + $i$0612 | 0;
    if ($call377 >>> 0 > ($p$4658 - $i$0612 | 0) >>> 0) {
     $316 = $314;
     $317 = $315;
     $i$0609 = $i$0612;
     label = 110;
     break L445;
    }
    if ($add388 >>> 0 < $p$4658 >>> 0) {
     $i$0612 = $add388;
     $l$1611 = $call377;
     $ws$0613 = $ws$0613 + 4 | 0;
    } else {
     $i$0$lcssa = $add388;
     $l$1$lcssa = $call377;
     break;
    }
   }
   if (($l$1$lcssa | 0) < 0) {
    $retval$0 = -1;
    label = 362;
    break L1;
   } else {
    $316 = $314;
    $317 = $315;
    $i$0609 = $i$0$lcssa;
    label = 110;
   }
  } while (0);
  if ((label | 0) == 94) {
   label = 0;
   $and302$fl$4 = ($p$2 | 0) > -1 ? $fl$4 & -65537 : $fl$4;
   $152 = ($148 | 0) == 0 & ($arg$sroa$0$sroa$1$4$extract$trunc531553 | 0) == 0;
   if ($152 & ($p$2 | 0) == 0) {
    $313 = $148;
    $a$2 = $add$ptr205;
    $arg$sroa$0$sroa$1$4$extract$trunc531555 = $arg$sroa$0$sroa$1$4$extract$trunc531553;
    $fl$6 = $and302$fl$4;
    $p$5 = 0;
    $pl$2 = $pl$1;
    $prefix$2 = $prefix$1;
    $z$2 = $add$ptr205;
   } else {
    $add315 = ($152 & 1) + ($sub$ptr$lhs$cast310 - $a$0) | 0;
    $313 = $148;
    $a$2 = $a$0;
    $arg$sroa$0$sroa$1$4$extract$trunc531555 = $arg$sroa$0$sroa$1$4$extract$trunc531553;
    $fl$6 = $and302$fl$4;
    $p$5 = ($p$2 | 0) > ($add315 | 0) ? $p$2 : $add315;
    $pl$2 = $pl$1;
    $prefix$2 = $prefix$1;
    $z$2 = $add$ptr205;
   }
  } else if ((label | 0) == 110) {
   label = 0;
   $and$i297 = $fl$1$and219 & 73728;
   $cmp$i299 = ($i$0609 | 0) < ($w$1 | 0);
   if (($and$i297 | 0) == 0 & $cmp$i299) {
    $sub$i301 = $w$1 - $i$0609 | 0;
    _memset($pad$i | 0, 32, ($sub$i301 >>> 0 > 256 ? 256 : $sub$i301) | 0) | 0;
    if ($sub$i301 >>> 0 > 255) {
     $l$addr$010$i306 = $sub$i301;
     while (1) {
      ___fwritex($pad$i, 256, $f) | 0;
      $sub5$i308 = $l$addr$010$i306 + -256 | 0;
      if ($sub5$i308 >>> 0 > 255) $l$addr$010$i306 = $sub5$i308; else {
       $l$addr$0$lcssa$i311 = $sub5$i308;
       break;
      }
     }
    } else $l$addr$0$lcssa$i311 = $sub$i301;
    ___fwritex($pad$i, $l$addr$0$lcssa$i311, $f) | 0;
   }
   L481 : do if ($i$0609) {
    $i$1617 = 0;
    $ws$1618 = $316;
    while (1) {
     $157 = HEAP32[$ws$1618 >> 2] | 0;
     if (!$157) break L481;
     $call404 = _wctomb($mb, $157) | 0;
     $i$1617 = $call404 + $i$1617 | 0;
     if (($i$1617 | 0) > ($i$0609 | 0)) break L481;
     ___fwritex($mb, $call404, $f) | 0;
     if ($i$1617 >>> 0 >= $i$0609 >>> 0) break; else $ws$1618 = $ws$1618 + 4 | 0;
    }
   } while (0);
   if (($and$i297 | 0) == 8192 & $cmp$i299) {
    $sub$i321 = $w$1 - $i$0609 | 0;
    _memset($pad$i | 0, 32, ($sub$i321 >>> 0 > 256 ? 256 : $sub$i321) | 0) | 0;
    if ($sub$i321 >>> 0 > 255) {
     $l$addr$010$i326 = $sub$i321;
     while (1) {
      ___fwritex($pad$i, 256, $f) | 0;
      $sub5$i328 = $l$addr$010$i326 + -256 | 0;
      if ($sub5$i328 >>> 0 > 255) $l$addr$010$i326 = $sub5$i328; else {
       $l$addr$0$lcssa$i331 = $sub5$i328;
       break;
      }
     }
    } else $l$addr$0$lcssa$i331 = $sub$i321;
    ___fwritex($pad$i, $l$addr$0$lcssa$i331, $f) | 0;
   }
   $309 = $317;
   $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531556568;
   $cnt$0 = $cnt$1;
   $incdec$ptr$i190563 = $incdec$ptr169;
   $l$0 = $cmp$i299 ? $w$1 : $i$0609;
   $l10n$0 = $l10n$3;
   continue;
  }
  $sub$ptr$sub426 = $z$2 - $a$2 | 0;
  $sub$ptr$sub426$p$5 = ($p$5 | 0) < ($sub$ptr$sub426 | 0) ? $sub$ptr$sub426 : $p$5;
  $add434 = $pl$2 + $sub$ptr$sub426$p$5 | 0;
  $w$2 = ($w$1 | 0) < ($add434 | 0) ? $add434 : $w$1;
  $and$i352 = $fl$6 & 73728;
  $cmp$i354 = ($add434 | 0) < ($w$2 | 0);
  if (($and$i352 | 0) == 0 & $cmp$i354) {
   $sub$i356 = $w$2 - $add434 | 0;
   _memset($pad$i | 0, 32, ($sub$i356 >>> 0 > 256 ? 256 : $sub$i356) | 0) | 0;
   if ($sub$i356 >>> 0 > 255) {
    $l$addr$010$i361 = $sub$i356;
    while (1) {
     ___fwritex($pad$i, 256, $f) | 0;
     $sub5$i363 = $l$addr$010$i361 + -256 | 0;
     if ($sub5$i363 >>> 0 > 255) $l$addr$010$i361 = $sub5$i363; else {
      $l$addr$0$lcssa$i366 = $sub5$i363;
      break;
     }
    }
   } else $l$addr$0$lcssa$i366 = $sub$i356;
   ___fwritex($pad$i, $l$addr$0$lcssa$i366, $f) | 0;
  }
  ___fwritex($prefix$2, $pl$2, $f) | 0;
  if (($and$i352 | 0) == 65536 & $cmp$i354) {
   $sub$i282 = $w$2 - $add434 | 0;
   _memset($pad$i | 0, 48, ($sub$i282 >>> 0 > 256 ? 256 : $sub$i282) | 0) | 0;
   if ($sub$i282 >>> 0 > 255) {
    $l$addr$010$i287 = $sub$i282;
    while (1) {
     ___fwritex($pad$i, 256, $f) | 0;
     $sub5$i289 = $l$addr$010$i287 + -256 | 0;
     if ($sub5$i289 >>> 0 > 255) $l$addr$010$i287 = $sub5$i289; else {
      $l$addr$0$lcssa$i292 = $sub5$i289;
      break;
     }
    }
   } else $l$addr$0$lcssa$i292 = $sub$i282;
   ___fwritex($pad$i, $l$addr$0$lcssa$i292, $f) | 0;
  }
  if (($sub$ptr$sub426 | 0) < ($sub$ptr$sub426$p$5 | 0)) {
   $sub$i248 = $sub$ptr$sub426$p$5 - $sub$ptr$sub426 | 0;
   _memset($pad$i | 0, 48, ($sub$i248 >>> 0 > 256 ? 256 : $sub$i248) | 0) | 0;
   if ($sub$i248 >>> 0 > 255) {
    $l$addr$010$i253 = $sub$i248;
    while (1) {
     ___fwritex($pad$i, 256, $f) | 0;
     $sub5$i255 = $l$addr$010$i253 + -256 | 0;
     if ($sub5$i255 >>> 0 > 255) $l$addr$010$i253 = $sub5$i255; else {
      $l$addr$0$lcssa$i258 = $sub5$i255;
      break;
     }
    }
   } else $l$addr$0$lcssa$i258 = $sub$i248;
   ___fwritex($pad$i, $l$addr$0$lcssa$i258, $f) | 0;
  }
  ___fwritex($a$2, $sub$ptr$sub426, $f) | 0;
  if (!(($and$i352 | 0) == 8192 & $cmp$i354)) {
   $309 = $313;
   $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531555;
   $cnt$0 = $cnt$1;
   $incdec$ptr$i190563 = $incdec$ptr169;
   $l$0 = $w$2;
   $l10n$0 = $l10n$3;
   continue;
  }
  $sub$i179 = $w$2 - $add434 | 0;
  _memset($pad$i | 0, 32, ($sub$i179 >>> 0 > 256 ? 256 : $sub$i179) | 0) | 0;
  if ($sub$i179 >>> 0 > 255) {
   $l$addr$010$i = $sub$i179;
   while (1) {
    ___fwritex($pad$i, 256, $f) | 0;
    $sub5$i = $l$addr$010$i + -256 | 0;
    if ($sub5$i >>> 0 > 255) $l$addr$010$i = $sub5$i; else {
     $l$addr$0$lcssa$i = $sub5$i;
     break;
    }
   }
  } else $l$addr$0$lcssa$i = $sub$i179;
  ___fwritex($pad$i, $l$addr$0$lcssa$i, $f) | 0;
  $309 = $313;
  $arg$sroa$0$sroa$1$4$extract$trunc531552 = $arg$sroa$0$sroa$1$4$extract$trunc531555;
  $cnt$0 = $cnt$1;
  $incdec$ptr$i190563 = $incdec$ptr169;
  $l$0 = $w$2;
  $l10n$0 = $l10n$3;
 }
 if ((label | 0) == 344) {
  if ($f) {
   $retval$0 = $cnt$1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if (!$l10n$0) {
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  } else $i$2577 = 1;
  while (1) {
   $256 = HEAP32[$nl_type + ($i$2577 << 2) >> 2] | 0;
   if (!$256) {
    $i$3575 = $i$2577;
    break;
   }
   $add$ptr466 = $nl_arg + ($i$2577 << 3) | 0;
   L540 : do if ($256 >>> 0 <= 20) do switch ($256 | 0) {
   case 9:
    {
     $arglist_current35 = HEAP32[$ap >> 2] | 0;
     $257 = HEAP32[$arglist_current35 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current35 + 4;
     HEAP32[$add$ptr466 >> 2] = $257;
     break L540;
     break;
    }
   case 10:
    {
     $arglist_current38 = HEAP32[$ap >> 2] | 0;
     $258 = HEAP32[$arglist_current38 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current38 + 4;
     $261 = $add$ptr466;
     HEAP32[$261 >> 2] = $258;
     HEAP32[$261 + 4 >> 2] = (($258 | 0) < 0) << 31 >> 31;
     break L540;
     break;
    }
   case 11:
    {
     $arglist_current41 = HEAP32[$ap >> 2] | 0;
     $265 = HEAP32[$arglist_current41 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current41 + 4;
     $266 = $add$ptr466;
     HEAP32[$266 >> 2] = $265;
     HEAP32[$266 + 4 >> 2] = 0;
     break L540;
     break;
    }
   case 12:
    {
     $arglist_current44 = HEAP32[$ap >> 2] | 0;
     $270 = $arglist_current44;
     $272 = HEAP32[$270 >> 2] | 0;
     $275 = HEAP32[$270 + 4 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current44 + 8;
     $276 = $add$ptr466;
     HEAP32[$276 >> 2] = $272;
     HEAP32[$276 + 4 >> 2] = $275;
     break L540;
     break;
    }
   case 13:
    {
     $arglist_current47 = HEAP32[$ap >> 2] | 0;
     $280 = HEAP32[$arglist_current47 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current47 + 4;
     $281 = ($280 & 65535) << 16 >> 16;
     $284 = $add$ptr466;
     HEAP32[$284 >> 2] = $281;
     HEAP32[$284 + 4 >> 2] = (($281 | 0) < 0) << 31 >> 31;
     break L540;
     break;
    }
   case 14:
    {
     $arglist_current50 = HEAP32[$ap >> 2] | 0;
     $288 = HEAP32[$arglist_current50 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current50 + 4;
     $289 = $add$ptr466;
     HEAP32[$289 >> 2] = $288 & 65535;
     HEAP32[$289 + 4 >> 2] = 0;
     break L540;
     break;
    }
   case 15:
    {
     $arglist_current53 = HEAP32[$ap >> 2] | 0;
     $293 = HEAP32[$arglist_current53 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current53 + 4;
     $294 = ($293 & 255) << 24 >> 24;
     $297 = $add$ptr466;
     HEAP32[$297 >> 2] = $294;
     HEAP32[$297 + 4 >> 2] = (($294 | 0) < 0) << 31 >> 31;
     break L540;
     break;
    }
   case 16:
    {
     $arglist_current56 = HEAP32[$ap >> 2] | 0;
     $301 = HEAP32[$arglist_current56 >> 2] | 0;
     HEAP32[$ap >> 2] = $arglist_current56 + 4;
     $302 = $add$ptr466;
     HEAP32[$302 >> 2] = $301 & 255;
     HEAP32[$302 + 4 >> 2] = 0;
     break L540;
     break;
    }
   case 17:
    {
     $arglist_current59 = HEAP32[$ap >> 2] | 0;
     HEAP32[tempDoublePtr >> 2] = HEAP32[$arglist_current59 >> 2];
     HEAP32[tempDoublePtr + 4 >> 2] = HEAP32[$arglist_current59 + 4 >> 2];
     $306 = +HEAPF64[tempDoublePtr >> 3];
     HEAP32[$ap >> 2] = $arglist_current59 + 8;
     HEAPF64[$add$ptr466 >> 3] = $306;
     break L540;
     break;
    }
   case 18:
    {
     $arglist_current62 = HEAP32[$ap >> 2] | 0;
     HEAP32[tempDoublePtr >> 2] = HEAP32[$arglist_current62 >> 2];
     HEAP32[tempDoublePtr + 4 >> 2] = HEAP32[$arglist_current62 + 4 >> 2];
     $307 = +HEAPF64[tempDoublePtr >> 3];
     HEAP32[$ap >> 2] = $arglist_current62 + 8;
     HEAPF64[$add$ptr466 >> 3] = $307;
     break L540;
     break;
    }
   default:
    break L540;
   } while (0); while (0);
   $i$2577 = $i$2577 + 1 | 0;
   if (($i$2577 | 0) >= 10) {
    $retval$0 = 1;
    label = 362;
    break;
   }
  }
  if ((label | 0) == 362) {
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  while (1) {
   if (HEAP32[$nl_type + ($i$3575 << 2) >> 2] | 0) {
    $retval$0 = -1;
    label = 362;
    break;
   }
   $i$3575 = $i$3575 + 1 | 0;
   if (($i$3575 | 0) >= 10) {
    $retval$0 = 1;
    label = 362;
    break;
   }
  }
  if ((label | 0) == 362) {
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 } else if ((label | 0) == 362) {
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 return 0;
}
function _malloc($bytes) {
 $bytes = $bytes | 0;
 var $$pre$phi$i$iZ2D = 0, $$pre$phi$i145Z2D = 0, $$pre$phi$i67$iZ2D = 0, $$pre$phi$iZ2D = 0, $$pre$phiZ2D = 0, $0 = 0, $1 = 0, $10 = 0, $101 = 0, $102 = 0, $103 = 0, $105 = 0, $106 = 0, $108 = 0, $109 = 0, $110 = 0, $111 = 0, $112 = 0, $116 = 0, $120 = 0, $121 = 0, $125 = 0, $128 = 0, $129 = 0, $13 = 0, $130 = 0, $133 = 0, $138 = 0, $14 = 0, $141 = 0, $143 = 0, $149 = 0, $15 = 0, $150 = 0, $151 = 0, $157 = 0, $158 = 0, $159 = 0, $16 = 0, $163 = 0, $164 = 0, $165 = 0, $166 = 0, $168 = 0, $17 = 0, $174 = 0, $176 = 0, $179 = 0, $180 = 0, $181 = 0, $183 = 0, $184 = 0, $186 = 0, $189 = 0, $19 = 0, $190 = 0, $191 = 0, $192 = 0, $194 = 0, $196 = 0, $2 = 0, $20 = 0, $203 = 0, $204 = 0, $205 = 0, $208 = 0, $209 = 0, $211 = 0, $214 = 0, $215 = 0, $216 = 0, $217 = 0, $22 = 0, $23 = 0, $25 = 0, $26 = 0, $27 = 0, $28 = 0, $3 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $35 = 0, $41 = 0, $43 = 0, $46 = 0, $47 = 0, $48 = 0, $49 = 0, $50 = 0, $52 = 0, $53 = 0, $55 = 0, $59 = 0, $62 = 0, $63 = 0, $64 = 0, $65 = 0, $68 = 0, $69 = 0, $70 = 0, $71 = 0, $72 = 0, $78 = 0, $8 = 0, $80 = 0, $83 = 0, $84 = 0, $85 = 0, $87 = 0, $88 = 0, $9 = 0, $90 = 0, $93 = 0, $94 = 0, $95 = 0, $96 = 0, $98 = 0, $99 = 0, $F$0$i$i = 0, $F104$0 = 0, $F197$0$i = 0, $F224$0$i$i = 0, $F289$0$i = 0, $I252$0$i$i = 0, $I315$0$i = 0, $I57$0$i$i = 0, $K105$017$i$i = 0, $K305$043$i$i = 0, $K372$024$i = 0, $R$0$i = 0, $R$0$i$i = 0, $R$0$i135 = 0, $R$1$i = 0, $R$1$i$i = 0, $R$1$i137 = 0, $RP$0$i = 0, $RP$0$i$i = 0, $RP$0$i134 = 0, $T$0$lcssa$i = 0, $T$0$lcssa$i$i = 0, $T$0$lcssa$i69$i = 0, $T$016$i$i = 0, $T$023$i = 0, $T$042$i$i = 0, $add$i$i = 0, $add$i147 = 0, $add$ptr$i = 0, $add$ptr$i$i$i = 0, $add$ptr$i126 = 0, $add$ptr14$i$i = 0, $add$ptr16$i$i = 0, $add$ptr16$sum$i$i = 0, $add$ptr16$sum2627$i$i = 0, $add$ptr16$sum56$i$i = 0, $add$ptr17$i$i = 0, $add$ptr224$i = 0, $add$ptr2418$i$i = 0, $add$ptr2420$i$i = 0, $add$ptr4$sum$i49$i = 0, $add$ptr7$i$i = 0, $add$ptr95 = 0, $add143 = 0, $add147$i = 0, $add17$i = 0, $add17$i150 = 0, $add177$i = 0, $add212$i = 0, $add26$i$i = 0, $add267$i = 0, $add278$i$i = 0, $add345$i = 0, $add51$i = 0, $add64 = 0, $add8 = 0, $add83$i$i = 0, $add9$i = 0, $and$i110 = 0, $and101$i = 0, $and11$i = 0, $and12$i = 0, $and13$i = 0, $and144 = 0, $and17$i = 0, $and264$i$i = 0, $and268$i$i = 0, $and273$i$i = 0, $and3$i = 0, $and32$i = 0, $and330$i = 0, $and335$i = 0, $and340$i = 0, $and37$i$i = 0, $and41 = 0, $and46 = 0, $and49 = 0, $and53 = 0, $and57 = 0, $and6$i = 0, $and61 = 0, $and63$i = 0, $and69$i$i = 0, $and72$i = 0, $and73$i$i = 0, $and76$i = 0, $and77$i = 0, $and78$i$i = 0, $and8$i = 0, $and80$i = 0, $and84$i = 0, $and88$i = 0, $and9$i = 0, $arrayidx = 0, $arrayidx$i$i = 0, $arrayidx$i21$i = 0, $arrayidx$i57$i = 0, $arrayidx103 = 0, $arrayidx103$i$i = 0, $arrayidx107$i$i = 0, $arrayidx113$i = 0, $arrayidx123$i$i = 0, $arrayidx126$i$i = 0, $arrayidx143$i$i = 0, $arrayidx150$i = 0, $arrayidx154$i131 = 0, $arrayidx160$i = 0, $arrayidx164$i = 0, $arrayidx183$i = 0, $arrayidx196$i = 0, $arrayidx203$i = 0, $arrayidx223$i$i = 0, $arrayidx287$i$i = 0, $arrayidx288$i = 0, $arrayidx325$i$i = 0, $arrayidx354$i = 0, $arrayidx393$i = 0, $arrayidx61$i = 0, $arrayidx65$i = 0, $arrayidx66 = 0, $arrayidx71$i = 0, $arrayidx75$i = 0, $arrayidx91$i$i = 0, $arrayidx94$i = 0, $arrayidx96$i$i = 0, $bk = 0, $bk135$i = 0, $bk47$i = 0, $bk78 = 0, $bk82$i$i = 0, $br$0$i = 0, $call$i$i = 0, $call128$i = 0, $call129$i = 0, $call34$i = 0, $call65$i = 0, $call80$i = 0, $child$i$i = 0, $cmp101$i = 0, $cmp138$i164 = 0, $cmp32$i = 0, $cmp66$i158 = 0, $cmp82$i = 0, $cond = 0, $cond$i = 0, $cond$i$i = 0, $cond$i$i$i = 0, $cond$i17$i = 0, $cond$i27$i = 0, $cond$i42$i = 0, $cond115$i$i = 0, $cond13$i$i = 0, $cond15$i$i = 0, $cond315$i$i = 0, $cond382$i = 0, $cond6$i = 0, $fd138$i = 0, $fd145$i$i = 0, $fd344$i$i = 0, $fd412$i = 0, $fd50$i = 0, $fd59$i$i = 0, $fd68$pre$phi$i$iZ2D = 0, $fd69 = 0, $fd85$i$i = 0, $fd9 = 0, $head178 = 0, $head182$i = 0, $head208$i$i = 0, $head25 = 0, $head273$i = 0, $head31$i$i = 0, $i$02$i$i = 0, $idx$0$i = 0, $mem$0 = 0, $nb$0 = 0, $neg$i149 = 0, $oldfirst$0$i$i = 0, $qsize$0$i$i = 0, $rsize$0$i = 0, $rsize$0$i120 = 0, $rsize$1$i = 0, $rsize$2$i = 0, $rsize$3$lcssa$i = 0, $rsize$328$i = 0, $rst$0$i = 0, $rst$1$i = 0, $shl = 0, $shl$i$i = 0, $shl$i111 = 0, $shl$i20$i = 0, $shl102 = 0, $shl105 = 0, $shl195$i = 0, $shl198$i = 0, $shl22 = 0, $shl221$i$i = 0, $shl226$i$i = 0, $shl265$i$i = 0, $shl270$i$i = 0, $shl287$i = 0, $shl290$i = 0, $shl294$i$i = 0, $shl332$i = 0, $shl337$i = 0, $shl361$i = 0, $shl37 = 0, $shl39$i$i = 0, $shl59$i = 0, $shl65 = 0, $shl70$i$i = 0, $shl75$i$i = 0, $shl9$i = 0, $shl90 = 0, $shl95$i$i = 0, $shr = 0, $shr$i$i = 0, $shr$i106 = 0, $shr$i54$i = 0, $shr101 = 0, $shr11$i = 0, $shr15$i = 0, $shr194$i = 0, $shr214$i$i = 0, $shr253$i$i = 0, $shr282$i = 0, $shr3 = 0, $shr317$i = 0, $shr4$i = 0, $shr47 = 0, $shr51 = 0, $shr55 = 0, $shr58$i$i = 0, $shr59 = 0, $shr7$i = 0, $shr74$i = 0, $shr78$i = 0, $shr82$i = 0, $shr86$i = 0, $size$i$i = 0, $size185$i = 0, $size242$i = 0, $sizebits$0$i = 0, $sp$0$i$i = 0, $sp$0$i$i$i = 0, $sp$0109$i = 0, $sp$1105$i = 0, $ssize$0$i = 0, $ssize$1$i = 0, $ssize$2$i = 0, $sub$i105 = 0, $sub$i148 = 0, $sub$ptr$sub$i = 0, $sub$ptr$sub$i$i = 0, $sub100$i = 0, $sub100$rsize$3$i = 0, $sub109$i = 0, $sub159 = 0, $sub18$i$i = 0, $sub187 = 0, $sub2$i = 0, $sub253$i = 0, $sub31$i = 0, $sub33$i = 0, $sub38$i = 0, $sub44 = 0, $sub5$i$i = 0, $sub5$i$i$i = 0, $sub5$i29$i = 0, $sub69$i = 0, $sub91 = 0, $t$0$i = 0, $t$0$i119 = 0, $t$1$i = 0, $t$2$ph$i = 0, $t$2$v$3$i = 0, $t$227$i = 0, $tbase$0$i = 0, $tbase$291$i = 0, $tsize$0$i = 0, $tsize$0748284$i = 0, $tsize$1$i = 0, $tsize$290$i = 0, $v$0$i = 0, $v$0$i121 = 0, $v$1$i = 0, $v$2$i = 0, $v$3$lcssa$i = 0, $v$329$i = 0, label = 0, sp = 0, $add$ptr2420$i$i$looptemp = 0;
 sp = STACKTOP;
 do if ($bytes >>> 0 < 245) {
  if ($bytes >>> 0 < 11) $cond = 16; else $cond = $bytes + 11 & -8;
  $shr = $cond >>> 3;
  $0 = HEAP32[302] | 0;
  $shr3 = $0 >>> $shr;
  if ($shr3 & 3) {
   $add8 = ($shr3 & 1 ^ 1) + $shr | 0;
   $shl = $add8 << 1;
   $arrayidx = 1248 + ($shl << 2) | 0;
   $1 = 1248 + ($shl + 2 << 2) | 0;
   $2 = HEAP32[$1 >> 2] | 0;
   $fd9 = $2 + 8 | 0;
   $3 = HEAP32[$fd9 >> 2] | 0;
   do if (($arrayidx | 0) == ($3 | 0)) HEAP32[302] = $0 & ~(1 << $add8); else {
    if ($3 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
    $bk = $3 + 12 | 0;
    if ((HEAP32[$bk >> 2] | 0) == ($2 | 0)) {
     HEAP32[$bk >> 2] = $arrayidx;
     HEAP32[$1 >> 2] = $3;
     break;
    } else _abort();
   } while (0);
   $shl22 = $add8 << 3;
   HEAP32[$2 + 4 >> 2] = $shl22 | 3;
   $head25 = $2 + ($shl22 | 4) | 0;
   HEAP32[$head25 >> 2] = HEAP32[$head25 >> 2] | 1;
   $mem$0 = $fd9;
   STACKTOP = sp;
   return $mem$0 | 0;
  }
  if ($cond >>> 0 > (HEAP32[304] | 0) >>> 0) {
   if ($shr3) {
    $shl37 = 2 << $shr;
    $and41 = $shr3 << $shr & ($shl37 | 0 - $shl37);
    $sub44 = ($and41 & 0 - $and41) + -1 | 0;
    $and46 = $sub44 >>> 12 & 16;
    $shr47 = $sub44 >>> $and46;
    $and49 = $shr47 >>> 5 & 8;
    $shr51 = $shr47 >>> $and49;
    $and53 = $shr51 >>> 2 & 4;
    $shr55 = $shr51 >>> $and53;
    $and57 = $shr55 >>> 1 & 2;
    $shr59 = $shr55 >>> $and57;
    $and61 = $shr59 >>> 1 & 1;
    $add64 = ($and49 | $and46 | $and53 | $and57 | $and61) + ($shr59 >>> $and61) | 0;
    $shl65 = $add64 << 1;
    $arrayidx66 = 1248 + ($shl65 << 2) | 0;
    $8 = 1248 + ($shl65 + 2 << 2) | 0;
    $9 = HEAP32[$8 >> 2] | 0;
    $fd69 = $9 + 8 | 0;
    $10 = HEAP32[$fd69 >> 2] | 0;
    do if (($arrayidx66 | 0) == ($10 | 0)) HEAP32[302] = $0 & ~(1 << $add64); else {
     if ($10 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
     $bk78 = $10 + 12 | 0;
     if ((HEAP32[$bk78 >> 2] | 0) == ($9 | 0)) {
      HEAP32[$bk78 >> 2] = $arrayidx66;
      HEAP32[$8 >> 2] = $10;
      break;
     } else _abort();
    } while (0);
    $shl90 = $add64 << 3;
    $sub91 = $shl90 - $cond | 0;
    HEAP32[$9 + 4 >> 2] = $cond | 3;
    $add$ptr95 = $9 + $cond | 0;
    HEAP32[$9 + ($cond | 4) >> 2] = $sub91 | 1;
    HEAP32[$9 + $shl90 >> 2] = $sub91;
    $13 = HEAP32[304] | 0;
    if ($13) {
     $14 = HEAP32[307] | 0;
     $shr101 = $13 >>> 3;
     $shl102 = $shr101 << 1;
     $arrayidx103 = 1248 + ($shl102 << 2) | 0;
     $15 = HEAP32[302] | 0;
     $shl105 = 1 << $shr101;
     if (!($15 & $shl105)) {
      HEAP32[302] = $15 | $shl105;
      $$pre$phiZ2D = 1248 + ($shl102 + 2 << 2) | 0;
      $F104$0 = $arrayidx103;
     } else {
      $16 = 1248 + ($shl102 + 2 << 2) | 0;
      $17 = HEAP32[$16 >> 2] | 0;
      if ($17 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
       $$pre$phiZ2D = $16;
       $F104$0 = $17;
      }
     }
     HEAP32[$$pre$phiZ2D >> 2] = $14;
     HEAP32[$F104$0 + 12 >> 2] = $14;
     HEAP32[$14 + 8 >> 2] = $F104$0;
     HEAP32[$14 + 12 >> 2] = $arrayidx103;
    }
    HEAP32[304] = $sub91;
    HEAP32[307] = $add$ptr95;
    $mem$0 = $fd69;
    STACKTOP = sp;
    return $mem$0 | 0;
   }
   $19 = HEAP32[303] | 0;
   if (!$19) $nb$0 = $cond; else {
    $sub2$i = ($19 & 0 - $19) + -1 | 0;
    $and3$i = $sub2$i >>> 12 & 16;
    $shr4$i = $sub2$i >>> $and3$i;
    $and6$i = $shr4$i >>> 5 & 8;
    $shr7$i = $shr4$i >>> $and6$i;
    $and9$i = $shr7$i >>> 2 & 4;
    $shr11$i = $shr7$i >>> $and9$i;
    $and13$i = $shr11$i >>> 1 & 2;
    $shr15$i = $shr11$i >>> $and13$i;
    $and17$i = $shr15$i >>> 1 & 1;
    $20 = HEAP32[1512 + (($and6$i | $and3$i | $and9$i | $and13$i | $and17$i) + ($shr15$i >>> $and17$i) << 2) >> 2] | 0;
    $rsize$0$i = (HEAP32[$20 + 4 >> 2] & -8) - $cond | 0;
    $t$0$i = $20;
    $v$0$i = $20;
    while (1) {
     $22 = HEAP32[$t$0$i + 16 >> 2] | 0;
     if (!$22) {
      $23 = HEAP32[$t$0$i + 20 >> 2] | 0;
      if (!$23) break; else $cond6$i = $23;
     } else $cond6$i = $22;
     $sub31$i = (HEAP32[$cond6$i + 4 >> 2] & -8) - $cond | 0;
     $cmp32$i = $sub31$i >>> 0 < $rsize$0$i >>> 0;
     $rsize$0$i = $cmp32$i ? $sub31$i : $rsize$0$i;
     $t$0$i = $cond6$i;
     $v$0$i = $cmp32$i ? $cond6$i : $v$0$i;
    }
    $25 = HEAP32[306] | 0;
    if ($v$0$i >>> 0 < $25 >>> 0) _abort();
    $add$ptr$i = $v$0$i + $cond | 0;
    if ($v$0$i >>> 0 >= $add$ptr$i >>> 0) _abort();
    $26 = HEAP32[$v$0$i + 24 >> 2] | 0;
    $27 = HEAP32[$v$0$i + 12 >> 2] | 0;
    do if (($27 | 0) == ($v$0$i | 0)) {
     $arrayidx61$i = $v$0$i + 20 | 0;
     $31 = HEAP32[$arrayidx61$i >> 2] | 0;
     if (!$31) {
      $arrayidx65$i = $v$0$i + 16 | 0;
      $32 = HEAP32[$arrayidx65$i >> 2] | 0;
      if (!$32) {
       $R$1$i = 0;
       break;
      } else {
       $R$0$i = $32;
       $RP$0$i = $arrayidx65$i;
      }
     } else {
      $R$0$i = $31;
      $RP$0$i = $arrayidx61$i;
     }
     while (1) {
      $arrayidx71$i = $R$0$i + 20 | 0;
      $33 = HEAP32[$arrayidx71$i >> 2] | 0;
      if ($33) {
       $R$0$i = $33;
       $RP$0$i = $arrayidx71$i;
       continue;
      }
      $arrayidx75$i = $R$0$i + 16 | 0;
      $34 = HEAP32[$arrayidx75$i >> 2] | 0;
      if (!$34) break; else {
       $R$0$i = $34;
       $RP$0$i = $arrayidx75$i;
      }
     }
     if ($RP$0$i >>> 0 < $25 >>> 0) _abort(); else {
      HEAP32[$RP$0$i >> 2] = 0;
      $R$1$i = $R$0$i;
      break;
     }
    } else {
     $28 = HEAP32[$v$0$i + 8 >> 2] | 0;
     if ($28 >>> 0 < $25 >>> 0) _abort();
     $bk47$i = $28 + 12 | 0;
     if ((HEAP32[$bk47$i >> 2] | 0) != ($v$0$i | 0)) _abort();
     $fd50$i = $27 + 8 | 0;
     if ((HEAP32[$fd50$i >> 2] | 0) == ($v$0$i | 0)) {
      HEAP32[$bk47$i >> 2] = $27;
      HEAP32[$fd50$i >> 2] = $28;
      $R$1$i = $27;
      break;
     } else _abort();
    } while (0);
    do if ($26) {
     $35 = HEAP32[$v$0$i + 28 >> 2] | 0;
     $arrayidx94$i = 1512 + ($35 << 2) | 0;
     if (($v$0$i | 0) == (HEAP32[$arrayidx94$i >> 2] | 0)) {
      HEAP32[$arrayidx94$i >> 2] = $R$1$i;
      if (!$R$1$i) {
       HEAP32[303] = HEAP32[303] & ~(1 << $35);
       break;
      }
     } else {
      if ($26 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
      $arrayidx113$i = $26 + 16 | 0;
      if ((HEAP32[$arrayidx113$i >> 2] | 0) == ($v$0$i | 0)) HEAP32[$arrayidx113$i >> 2] = $R$1$i; else HEAP32[$26 + 20 >> 2] = $R$1$i;
      if (!$R$1$i) break;
     }
     if ($R$1$i >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
     HEAP32[$R$1$i + 24 >> 2] = $26;
     $41 = HEAP32[$v$0$i + 16 >> 2] | 0;
     do if ($41) if ($41 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
      HEAP32[$R$1$i + 16 >> 2] = $41;
      HEAP32[$41 + 24 >> 2] = $R$1$i;
      break;
     } while (0);
     $43 = HEAP32[$v$0$i + 20 >> 2] | 0;
     if ($43) if ($43 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
      HEAP32[$R$1$i + 20 >> 2] = $43;
      HEAP32[$43 + 24 >> 2] = $R$1$i;
      break;
     }
    } while (0);
    if ($rsize$0$i >>> 0 < 16) {
     $add177$i = $rsize$0$i + $cond | 0;
     HEAP32[$v$0$i + 4 >> 2] = $add177$i | 3;
     $head182$i = $v$0$i + ($add177$i + 4) | 0;
     HEAP32[$head182$i >> 2] = HEAP32[$head182$i >> 2] | 1;
    } else {
     HEAP32[$v$0$i + 4 >> 2] = $cond | 3;
     HEAP32[$v$0$i + ($cond | 4) >> 2] = $rsize$0$i | 1;
     HEAP32[$v$0$i + ($rsize$0$i + $cond) >> 2] = $rsize$0$i;
     $46 = HEAP32[304] | 0;
     if ($46) {
      $47 = HEAP32[307] | 0;
      $shr194$i = $46 >>> 3;
      $shl195$i = $shr194$i << 1;
      $arrayidx196$i = 1248 + ($shl195$i << 2) | 0;
      $48 = HEAP32[302] | 0;
      $shl198$i = 1 << $shr194$i;
      if (!($48 & $shl198$i)) {
       HEAP32[302] = $48 | $shl198$i;
       $$pre$phi$iZ2D = 1248 + ($shl195$i + 2 << 2) | 0;
       $F197$0$i = $arrayidx196$i;
      } else {
       $49 = 1248 + ($shl195$i + 2 << 2) | 0;
       $50 = HEAP32[$49 >> 2] | 0;
       if ($50 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
        $$pre$phi$iZ2D = $49;
        $F197$0$i = $50;
       }
      }
      HEAP32[$$pre$phi$iZ2D >> 2] = $47;
      HEAP32[$F197$0$i + 12 >> 2] = $47;
      HEAP32[$47 + 8 >> 2] = $F197$0$i;
      HEAP32[$47 + 12 >> 2] = $arrayidx196$i;
     }
     HEAP32[304] = $rsize$0$i;
     HEAP32[307] = $add$ptr$i;
    }
    $mem$0 = $v$0$i + 8 | 0;
    STACKTOP = sp;
    return $mem$0 | 0;
   }
  } else $nb$0 = $cond;
 } else if ($bytes >>> 0 > 4294967231) $nb$0 = -1; else {
  $add143 = $bytes + 11 | 0;
  $and144 = $add143 & -8;
  $52 = HEAP32[303] | 0;
  if (!$52) $nb$0 = $and144; else {
   $sub$i105 = 0 - $and144 | 0;
   $shr$i106 = $add143 >>> 8;
   if (!$shr$i106) $idx$0$i = 0; else if ($and144 >>> 0 > 16777215) $idx$0$i = 31; else {
    $and$i110 = ($shr$i106 + 1048320 | 0) >>> 16 & 8;
    $shl$i111 = $shr$i106 << $and$i110;
    $and8$i = ($shl$i111 + 520192 | 0) >>> 16 & 4;
    $shl9$i = $shl$i111 << $and8$i;
    $and12$i = ($shl9$i + 245760 | 0) >>> 16 & 2;
    $add17$i = 14 - ($and8$i | $and$i110 | $and12$i) + ($shl9$i << $and12$i >>> 15) | 0;
    $idx$0$i = $and144 >>> ($add17$i + 7 | 0) & 1 | $add17$i << 1;
   }
   $53 = HEAP32[1512 + ($idx$0$i << 2) >> 2] | 0;
   L126 : do if (!$53) {
    $rsize$2$i = $sub$i105;
    $t$1$i = 0;
    $v$2$i = 0;
   } else {
    if (($idx$0$i | 0) == 31) $cond$i = 0; else $cond$i = 25 - ($idx$0$i >>> 1) | 0;
    $rsize$0$i120 = $sub$i105;
    $rst$0$i = 0;
    $sizebits$0$i = $and144 << $cond$i;
    $t$0$i119 = $53;
    $v$0$i121 = 0;
    while (1) {
     $and32$i = HEAP32[$t$0$i119 + 4 >> 2] & -8;
     $sub33$i = $and32$i - $and144 | 0;
     if ($sub33$i >>> 0 < $rsize$0$i120 >>> 0) if (($and32$i | 0) == ($and144 | 0)) {
      $rsize$2$i = $sub33$i;
      $t$1$i = $t$0$i119;
      $v$2$i = $t$0$i119;
      break L126;
     } else {
      $rsize$1$i = $sub33$i;
      $v$1$i = $t$0$i119;
     } else {
      $rsize$1$i = $rsize$0$i120;
      $v$1$i = $v$0$i121;
     }
     $55 = HEAP32[$t$0$i119 + 20 >> 2] | 0;
     $t$0$i119 = HEAP32[$t$0$i119 + ($sizebits$0$i >>> 31 << 2) + 16 >> 2] | 0;
     $rst$1$i = ($55 | 0) == 0 | ($55 | 0) == ($t$0$i119 | 0) ? $rst$0$i : $55;
     if (!$t$0$i119) {
      $rsize$2$i = $rsize$1$i;
      $t$1$i = $rst$1$i;
      $v$2$i = $v$1$i;
      break;
     } else {
      $rsize$0$i120 = $rsize$1$i;
      $rst$0$i = $rst$1$i;
      $sizebits$0$i = $sizebits$0$i << 1;
      $v$0$i121 = $v$1$i;
     }
    }
   } while (0);
   if (($t$1$i | 0) == 0 & ($v$2$i | 0) == 0) {
    $shl59$i = 2 << $idx$0$i;
    $and63$i = $52 & ($shl59$i | 0 - $shl59$i);
    if (!$and63$i) {
     $nb$0 = $and144;
     break;
    }
    $sub69$i = ($and63$i & 0 - $and63$i) + -1 | 0;
    $and72$i = $sub69$i >>> 12 & 16;
    $shr74$i = $sub69$i >>> $and72$i;
    $and76$i = $shr74$i >>> 5 & 8;
    $shr78$i = $shr74$i >>> $and76$i;
    $and80$i = $shr78$i >>> 2 & 4;
    $shr82$i = $shr78$i >>> $and80$i;
    $and84$i = $shr82$i >>> 1 & 2;
    $shr86$i = $shr82$i >>> $and84$i;
    $and88$i = $shr86$i >>> 1 & 1;
    $t$2$ph$i = HEAP32[1512 + (($and76$i | $and72$i | $and80$i | $and84$i | $and88$i) + ($shr86$i >>> $and88$i) << 2) >> 2] | 0;
   } else $t$2$ph$i = $t$1$i;
   if (!$t$2$ph$i) {
    $rsize$3$lcssa$i = $rsize$2$i;
    $v$3$lcssa$i = $v$2$i;
   } else {
    $rsize$328$i = $rsize$2$i;
    $t$227$i = $t$2$ph$i;
    $v$329$i = $v$2$i;
    while (1) {
     $sub100$i = (HEAP32[$t$227$i + 4 >> 2] & -8) - $and144 | 0;
     $cmp101$i = $sub100$i >>> 0 < $rsize$328$i >>> 0;
     $sub100$rsize$3$i = $cmp101$i ? $sub100$i : $rsize$328$i;
     $t$2$v$3$i = $cmp101$i ? $t$227$i : $v$329$i;
     $59 = HEAP32[$t$227$i + 16 >> 2] | 0;
     if ($59) {
      $rsize$328$i = $sub100$rsize$3$i;
      $t$227$i = $59;
      $v$329$i = $t$2$v$3$i;
      continue;
     }
     $t$227$i = HEAP32[$t$227$i + 20 >> 2] | 0;
     if (!$t$227$i) {
      $rsize$3$lcssa$i = $sub100$rsize$3$i;
      $v$3$lcssa$i = $t$2$v$3$i;
      break;
     } else {
      $rsize$328$i = $sub100$rsize$3$i;
      $v$329$i = $t$2$v$3$i;
     }
    }
   }
   if (!$v$3$lcssa$i) $nb$0 = $and144; else if ($rsize$3$lcssa$i >>> 0 < ((HEAP32[304] | 0) - $and144 | 0) >>> 0) {
    $62 = HEAP32[306] | 0;
    if ($v$3$lcssa$i >>> 0 < $62 >>> 0) _abort();
    $add$ptr$i126 = $v$3$lcssa$i + $and144 | 0;
    if ($v$3$lcssa$i >>> 0 >= $add$ptr$i126 >>> 0) _abort();
    $63 = HEAP32[$v$3$lcssa$i + 24 >> 2] | 0;
    $64 = HEAP32[$v$3$lcssa$i + 12 >> 2] | 0;
    do if (($64 | 0) == ($v$3$lcssa$i | 0)) {
     $arrayidx150$i = $v$3$lcssa$i + 20 | 0;
     $68 = HEAP32[$arrayidx150$i >> 2] | 0;
     if (!$68) {
      $arrayidx154$i131 = $v$3$lcssa$i + 16 | 0;
      $69 = HEAP32[$arrayidx154$i131 >> 2] | 0;
      if (!$69) {
       $R$1$i137 = 0;
       break;
      } else {
       $R$0$i135 = $69;
       $RP$0$i134 = $arrayidx154$i131;
      }
     } else {
      $R$0$i135 = $68;
      $RP$0$i134 = $arrayidx150$i;
     }
     while (1) {
      $arrayidx160$i = $R$0$i135 + 20 | 0;
      $70 = HEAP32[$arrayidx160$i >> 2] | 0;
      if ($70) {
       $R$0$i135 = $70;
       $RP$0$i134 = $arrayidx160$i;
       continue;
      }
      $arrayidx164$i = $R$0$i135 + 16 | 0;
      $71 = HEAP32[$arrayidx164$i >> 2] | 0;
      if (!$71) break; else {
       $R$0$i135 = $71;
       $RP$0$i134 = $arrayidx164$i;
      }
     }
     if ($RP$0$i134 >>> 0 < $62 >>> 0) _abort(); else {
      HEAP32[$RP$0$i134 >> 2] = 0;
      $R$1$i137 = $R$0$i135;
      break;
     }
    } else {
     $65 = HEAP32[$v$3$lcssa$i + 8 >> 2] | 0;
     if ($65 >>> 0 < $62 >>> 0) _abort();
     $bk135$i = $65 + 12 | 0;
     if ((HEAP32[$bk135$i >> 2] | 0) != ($v$3$lcssa$i | 0)) _abort();
     $fd138$i = $64 + 8 | 0;
     if ((HEAP32[$fd138$i >> 2] | 0) == ($v$3$lcssa$i | 0)) {
      HEAP32[$bk135$i >> 2] = $64;
      HEAP32[$fd138$i >> 2] = $65;
      $R$1$i137 = $64;
      break;
     } else _abort();
    } while (0);
    do if ($63) {
     $72 = HEAP32[$v$3$lcssa$i + 28 >> 2] | 0;
     $arrayidx183$i = 1512 + ($72 << 2) | 0;
     if (($v$3$lcssa$i | 0) == (HEAP32[$arrayidx183$i >> 2] | 0)) {
      HEAP32[$arrayidx183$i >> 2] = $R$1$i137;
      if (!$R$1$i137) {
       HEAP32[303] = HEAP32[303] & ~(1 << $72);
       break;
      }
     } else {
      if ($63 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
      $arrayidx203$i = $63 + 16 | 0;
      if ((HEAP32[$arrayidx203$i >> 2] | 0) == ($v$3$lcssa$i | 0)) HEAP32[$arrayidx203$i >> 2] = $R$1$i137; else HEAP32[$63 + 20 >> 2] = $R$1$i137;
      if (!$R$1$i137) break;
     }
     if ($R$1$i137 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
     HEAP32[$R$1$i137 + 24 >> 2] = $63;
     $78 = HEAP32[$v$3$lcssa$i + 16 >> 2] | 0;
     do if ($78) if ($78 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
      HEAP32[$R$1$i137 + 16 >> 2] = $78;
      HEAP32[$78 + 24 >> 2] = $R$1$i137;
      break;
     } while (0);
     $80 = HEAP32[$v$3$lcssa$i + 20 >> 2] | 0;
     if ($80) if ($80 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
      HEAP32[$R$1$i137 + 20 >> 2] = $80;
      HEAP32[$80 + 24 >> 2] = $R$1$i137;
      break;
     }
    } while (0);
    L204 : do if ($rsize$3$lcssa$i >>> 0 < 16) {
     $add267$i = $rsize$3$lcssa$i + $and144 | 0;
     HEAP32[$v$3$lcssa$i + 4 >> 2] = $add267$i | 3;
     $head273$i = $v$3$lcssa$i + ($add267$i + 4) | 0;
     HEAP32[$head273$i >> 2] = HEAP32[$head273$i >> 2] | 1;
    } else {
     HEAP32[$v$3$lcssa$i + 4 >> 2] = $and144 | 3;
     HEAP32[$v$3$lcssa$i + ($and144 | 4) >> 2] = $rsize$3$lcssa$i | 1;
     HEAP32[$v$3$lcssa$i + ($rsize$3$lcssa$i + $and144) >> 2] = $rsize$3$lcssa$i;
     $shr282$i = $rsize$3$lcssa$i >>> 3;
     if ($rsize$3$lcssa$i >>> 0 < 256) {
      $shl287$i = $shr282$i << 1;
      $arrayidx288$i = 1248 + ($shl287$i << 2) | 0;
      $83 = HEAP32[302] | 0;
      $shl290$i = 1 << $shr282$i;
      do if (!($83 & $shl290$i)) {
       HEAP32[302] = $83 | $shl290$i;
       $$pre$phi$i145Z2D = 1248 + ($shl287$i + 2 << 2) | 0;
       $F289$0$i = $arrayidx288$i;
      } else {
       $84 = 1248 + ($shl287$i + 2 << 2) | 0;
       $85 = HEAP32[$84 >> 2] | 0;
       if ($85 >>> 0 >= (HEAP32[306] | 0) >>> 0) {
        $$pre$phi$i145Z2D = $84;
        $F289$0$i = $85;
        break;
       }
       _abort();
      } while (0);
      HEAP32[$$pre$phi$i145Z2D >> 2] = $add$ptr$i126;
      HEAP32[$F289$0$i + 12 >> 2] = $add$ptr$i126;
      HEAP32[$v$3$lcssa$i + ($and144 + 8) >> 2] = $F289$0$i;
      HEAP32[$v$3$lcssa$i + ($and144 + 12) >> 2] = $arrayidx288$i;
      break;
     }
     $shr317$i = $rsize$3$lcssa$i >>> 8;
     if (!$shr317$i) $I315$0$i = 0; else if ($rsize$3$lcssa$i >>> 0 > 16777215) $I315$0$i = 31; else {
      $and330$i = ($shr317$i + 1048320 | 0) >>> 16 & 8;
      $shl332$i = $shr317$i << $and330$i;
      $and335$i = ($shl332$i + 520192 | 0) >>> 16 & 4;
      $shl337$i = $shl332$i << $and335$i;
      $and340$i = ($shl337$i + 245760 | 0) >>> 16 & 2;
      $add345$i = 14 - ($and335$i | $and330$i | $and340$i) + ($shl337$i << $and340$i >>> 15) | 0;
      $I315$0$i = $rsize$3$lcssa$i >>> ($add345$i + 7 | 0) & 1 | $add345$i << 1;
     }
     $arrayidx354$i = 1512 + ($I315$0$i << 2) | 0;
     HEAP32[$v$3$lcssa$i + ($and144 + 28) >> 2] = $I315$0$i;
     HEAP32[$v$3$lcssa$i + ($and144 + 20) >> 2] = 0;
     HEAP32[$v$3$lcssa$i + ($and144 + 16) >> 2] = 0;
     $87 = HEAP32[303] | 0;
     $shl361$i = 1 << $I315$0$i;
     if (!($87 & $shl361$i)) {
      HEAP32[303] = $87 | $shl361$i;
      HEAP32[$arrayidx354$i >> 2] = $add$ptr$i126;
      HEAP32[$v$3$lcssa$i + ($and144 + 24) >> 2] = $arrayidx354$i;
      HEAP32[$v$3$lcssa$i + ($and144 + 12) >> 2] = $add$ptr$i126;
      HEAP32[$v$3$lcssa$i + ($and144 + 8) >> 2] = $add$ptr$i126;
      break;
     }
     $88 = HEAP32[$arrayidx354$i >> 2] | 0;
     if (($I315$0$i | 0) == 31) $cond382$i = 0; else $cond382$i = 25 - ($I315$0$i >>> 1) | 0;
     L225 : do if ((HEAP32[$88 + 4 >> 2] & -8 | 0) == ($rsize$3$lcssa$i | 0)) $T$0$lcssa$i = $88; else {
      $K372$024$i = $rsize$3$lcssa$i << $cond382$i;
      $T$023$i = $88;
      while (1) {
       $arrayidx393$i = $T$023$i + ($K372$024$i >>> 31 << 2) + 16 | 0;
       $90 = HEAP32[$arrayidx393$i >> 2] | 0;
       if (!$90) break;
       if ((HEAP32[$90 + 4 >> 2] & -8 | 0) == ($rsize$3$lcssa$i | 0)) {
        $T$0$lcssa$i = $90;
        break L225;
       } else {
        $K372$024$i = $K372$024$i << 1;
        $T$023$i = $90;
       }
      }
      if ($arrayidx393$i >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
       HEAP32[$arrayidx393$i >> 2] = $add$ptr$i126;
       HEAP32[$v$3$lcssa$i + ($and144 + 24) >> 2] = $T$023$i;
       HEAP32[$v$3$lcssa$i + ($and144 + 12) >> 2] = $add$ptr$i126;
       HEAP32[$v$3$lcssa$i + ($and144 + 8) >> 2] = $add$ptr$i126;
       break L204;
      }
     } while (0);
     $fd412$i = $T$0$lcssa$i + 8 | 0;
     $93 = HEAP32[$fd412$i >> 2] | 0;
     $94 = HEAP32[306] | 0;
     if ($T$0$lcssa$i >>> 0 < $94 >>> 0) _abort();
     if ($93 >>> 0 < $94 >>> 0) _abort(); else {
      HEAP32[$93 + 12 >> 2] = $add$ptr$i126;
      HEAP32[$fd412$i >> 2] = $add$ptr$i126;
      HEAP32[$v$3$lcssa$i + ($and144 + 8) >> 2] = $93;
      HEAP32[$v$3$lcssa$i + ($and144 + 12) >> 2] = $T$0$lcssa$i;
      HEAP32[$v$3$lcssa$i + ($and144 + 24) >> 2] = 0;
      break;
     }
    } while (0);
    $mem$0 = $v$3$lcssa$i + 8 | 0;
    STACKTOP = sp;
    return $mem$0 | 0;
   } else $nb$0 = $and144;
  }
 } while (0);
 $95 = HEAP32[304] | 0;
 if ($nb$0 >>> 0 <= $95 >>> 0) {
  $sub159 = $95 - $nb$0 | 0;
  $96 = HEAP32[307] | 0;
  if ($sub159 >>> 0 > 15) {
   HEAP32[307] = $96 + $nb$0;
   HEAP32[304] = $sub159;
   HEAP32[$96 + ($nb$0 + 4) >> 2] = $sub159 | 1;
   HEAP32[$96 + $95 >> 2] = $sub159;
   HEAP32[$96 + 4 >> 2] = $nb$0 | 3;
  } else {
   HEAP32[304] = 0;
   HEAP32[307] = 0;
   HEAP32[$96 + 4 >> 2] = $95 | 3;
   $head178 = $96 + ($95 + 4) | 0;
   HEAP32[$head178 >> 2] = HEAP32[$head178 >> 2] | 1;
  }
  $mem$0 = $96 + 8 | 0;
  STACKTOP = sp;
  return $mem$0 | 0;
 }
 $98 = HEAP32[305] | 0;
 if ($nb$0 >>> 0 < $98 >>> 0) {
  $sub187 = $98 - $nb$0 | 0;
  HEAP32[305] = $sub187;
  $99 = HEAP32[308] | 0;
  HEAP32[308] = $99 + $nb$0;
  HEAP32[$99 + ($nb$0 + 4) >> 2] = $sub187 | 1;
  HEAP32[$99 + 4 >> 2] = $nb$0 | 3;
  $mem$0 = $99 + 8 | 0;
  STACKTOP = sp;
  return $mem$0 | 0;
 }
 do if (!(HEAP32[420] | 0)) {
  $call$i$i = _sysconf(30) | 0;
  if (!($call$i$i + -1 & $call$i$i)) {
   HEAP32[422] = $call$i$i;
   HEAP32[421] = $call$i$i;
   HEAP32[423] = -1;
   HEAP32[424] = -1;
   HEAP32[425] = 0;
   HEAP32[413] = 0;
   HEAP32[420] = (_time(0) | 0) & -16 ^ 1431655768;
   break;
  } else _abort();
 } while (0);
 $add$i147 = $nb$0 + 48 | 0;
 $101 = HEAP32[422] | 0;
 $sub$i148 = $nb$0 + 47 | 0;
 $add9$i = $101 + $sub$i148 | 0;
 $neg$i149 = 0 - $101 | 0;
 $and11$i = $add9$i & $neg$i149;
 if ($and11$i >>> 0 <= $nb$0 >>> 0) {
  $mem$0 = 0;
  STACKTOP = sp;
  return $mem$0 | 0;
 }
 $102 = HEAP32[412] | 0;
 if ($102) {
  $103 = HEAP32[410] | 0;
  $add17$i150 = $103 + $and11$i | 0;
  if ($add17$i150 >>> 0 <= $103 >>> 0 | $add17$i150 >>> 0 > $102 >>> 0) {
   $mem$0 = 0;
   STACKTOP = sp;
   return $mem$0 | 0;
  }
 }
 L269 : do if (!(HEAP32[413] & 4)) {
  $105 = HEAP32[308] | 0;
  L271 : do if (!$105) label = 182; else {
   $sp$0$i$i = 1656 | 0;
   while (1) {
    $106 = HEAP32[$sp$0$i$i >> 2] | 0;
    if ($106 >>> 0 <= $105 >>> 0) {
     $size$i$i = $sp$0$i$i + 4 | 0;
     if (($106 + (HEAP32[$size$i$i >> 2] | 0) | 0) >>> 0 > $105 >>> 0) break;
    }
    $108 = HEAP32[$sp$0$i$i + 8 >> 2] | 0;
    if (!$108) {
     label = 182;
     break L271;
    } else $sp$0$i$i = $108;
   }
   if (!$sp$0$i$i) label = 182; else {
    $and77$i = $add9$i - (HEAP32[305] | 0) & $neg$i149;
    if ($and77$i >>> 0 < 2147483647) {
     $call80$i = _sbrk($and77$i | 0) | 0;
     $cmp82$i = ($call80$i | 0) == ((HEAP32[$sp$0$i$i >> 2] | 0) + (HEAP32[$size$i$i >> 2] | 0) | 0);
     $br$0$i = $call80$i;
     $ssize$1$i = $and77$i;
     $tbase$0$i = $cmp82$i ? $call80$i : -1;
     $tsize$0$i = $cmp82$i ? $and77$i : 0;
     label = 191;
    } else $tsize$0748284$i = 0;
   }
  } while (0);
  do if ((label | 0) == 182) {
   $call34$i = _sbrk(0) | 0;
   if (($call34$i | 0) == (-1 | 0)) $tsize$0748284$i = 0; else {
    $109 = $call34$i;
    $110 = HEAP32[421] | 0;
    $sub38$i = $110 + -1 | 0;
    if (!($sub38$i & $109)) $ssize$0$i = $and11$i; else $ssize$0$i = $and11$i - $109 + ($sub38$i + $109 & 0 - $110) | 0;
    $111 = HEAP32[410] | 0;
    $add51$i = $111 + $ssize$0$i | 0;
    if ($ssize$0$i >>> 0 > $nb$0 >>> 0 & $ssize$0$i >>> 0 < 2147483647) {
     $112 = HEAP32[412] | 0;
     if ($112) if ($add51$i >>> 0 <= $111 >>> 0 | $add51$i >>> 0 > $112 >>> 0) {
      $tsize$0748284$i = 0;
      break;
     }
     $call65$i = _sbrk($ssize$0$i | 0) | 0;
     $cmp66$i158 = ($call65$i | 0) == ($call34$i | 0);
     $br$0$i = $call65$i;
     $ssize$1$i = $ssize$0$i;
     $tbase$0$i = $cmp66$i158 ? $call34$i : -1;
     $tsize$0$i = $cmp66$i158 ? $ssize$0$i : 0;
     label = 191;
    } else $tsize$0748284$i = 0;
   }
  } while (0);
  L291 : do if ((label | 0) == 191) {
   $sub109$i = 0 - $ssize$1$i | 0;
   if (($tbase$0$i | 0) != (-1 | 0)) {
    $tbase$291$i = $tbase$0$i;
    $tsize$290$i = $tsize$0$i;
    label = 202;
    break L269;
   }
   do if (($br$0$i | 0) != (-1 | 0) & $ssize$1$i >>> 0 < 2147483647 & $ssize$1$i >>> 0 < $add$i147 >>> 0) {
    $116 = HEAP32[422] | 0;
    $and101$i = $sub$i148 - $ssize$1$i + $116 & 0 - $116;
    if ($and101$i >>> 0 < 2147483647) if ((_sbrk($and101$i | 0) | 0) == (-1 | 0)) {
     _sbrk($sub109$i | 0) | 0;
     $tsize$0748284$i = $tsize$0$i;
     break L291;
    } else {
     $ssize$2$i = $and101$i + $ssize$1$i | 0;
     break;
    } else $ssize$2$i = $ssize$1$i;
   } else $ssize$2$i = $ssize$1$i; while (0);
   if (($br$0$i | 0) == (-1 | 0)) $tsize$0748284$i = $tsize$0$i; else {
    $tbase$291$i = $br$0$i;
    $tsize$290$i = $ssize$2$i;
    label = 202;
    break L269;
   }
  } while (0);
  HEAP32[413] = HEAP32[413] | 4;
  $tsize$1$i = $tsize$0748284$i;
  label = 199;
 } else {
  $tsize$1$i = 0;
  label = 199;
 } while (0);
 if ((label | 0) == 199) if ($and11$i >>> 0 < 2147483647) {
  $call128$i = _sbrk($and11$i | 0) | 0;
  $call129$i = _sbrk(0) | 0;
  if (($call129$i | 0) != (-1 | 0) & ($call128$i | 0) != (-1 | 0) & $call128$i >>> 0 < $call129$i >>> 0) {
   $sub$ptr$sub$i = $call129$i - $call128$i | 0;
   $cmp138$i164 = $sub$ptr$sub$i >>> 0 > ($nb$0 + 40 | 0) >>> 0;
   if ($cmp138$i164) {
    $tbase$291$i = $call128$i;
    $tsize$290$i = $cmp138$i164 ? $sub$ptr$sub$i : $tsize$1$i;
    label = 202;
   }
  }
 }
 if ((label | 0) == 202) {
  $add147$i = (HEAP32[410] | 0) + $tsize$290$i | 0;
  HEAP32[410] = $add147$i;
  if ($add147$i >>> 0 > (HEAP32[411] | 0) >>> 0) HEAP32[411] = $add147$i;
  $120 = HEAP32[308] | 0;
  L311 : do if (!$120) {
   $121 = HEAP32[306] | 0;
   if (($121 | 0) == 0 | $tbase$291$i >>> 0 < $121 >>> 0) HEAP32[306] = $tbase$291$i;
   HEAP32[414] = $tbase$291$i;
   HEAP32[415] = $tsize$290$i;
   HEAP32[417] = 0;
   HEAP32[311] = HEAP32[420];
   HEAP32[310] = -1;
   $i$02$i$i = 0;
   do {
    $shl$i$i = $i$02$i$i << 1;
    $arrayidx$i$i = 1248 + ($shl$i$i << 2) | 0;
    HEAP32[1248 + ($shl$i$i + 3 << 2) >> 2] = $arrayidx$i$i;
    HEAP32[1248 + ($shl$i$i + 2 << 2) >> 2] = $arrayidx$i$i;
    $i$02$i$i = $i$02$i$i + 1 | 0;
   } while (($i$02$i$i | 0) != 32);
   $125 = $tbase$291$i + 8 | 0;
   if (!($125 & 7)) $cond$i$i = 0; else $cond$i$i = 0 - $125 & 7;
   $sub5$i$i = $tsize$290$i + -40 - $cond$i$i | 0;
   HEAP32[308] = $tbase$291$i + $cond$i$i;
   HEAP32[305] = $sub5$i$i;
   HEAP32[$tbase$291$i + ($cond$i$i + 4) >> 2] = $sub5$i$i | 1;
   HEAP32[$tbase$291$i + ($tsize$290$i + -36) >> 2] = 40;
   HEAP32[309] = HEAP32[424];
  } else {
   $sp$0109$i = 1656 | 0;
   while (1) {
    $128 = HEAP32[$sp$0109$i >> 2] | 0;
    $size185$i = $sp$0109$i + 4 | 0;
    $129 = HEAP32[$size185$i >> 2] | 0;
    if (($tbase$291$i | 0) == ($128 + $129 | 0)) {
     label = 214;
     break;
    }
    $130 = HEAP32[$sp$0109$i + 8 >> 2] | 0;
    if (!$130) break; else $sp$0109$i = $130;
   }
   if ((label | 0) == 214) if (!(HEAP32[$sp$0109$i + 12 >> 2] & 8)) if ($120 >>> 0 >= $128 >>> 0 & $120 >>> 0 < $tbase$291$i >>> 0) {
    HEAP32[$size185$i >> 2] = $129 + $tsize$290$i;
    $add212$i = (HEAP32[305] | 0) + $tsize$290$i | 0;
    $133 = $120 + 8 | 0;
    if (!($133 & 7)) $cond$i27$i = 0; else $cond$i27$i = 0 - $133 & 7;
    $sub5$i29$i = $add212$i - $cond$i27$i | 0;
    HEAP32[308] = $120 + $cond$i27$i;
    HEAP32[305] = $sub5$i29$i;
    HEAP32[$120 + ($cond$i27$i + 4) >> 2] = $sub5$i29$i | 1;
    HEAP32[$120 + ($add212$i + 4) >> 2] = 40;
    HEAP32[309] = HEAP32[424];
    break;
   }
   if ($tbase$291$i >>> 0 < (HEAP32[306] | 0) >>> 0) HEAP32[306] = $tbase$291$i;
   $add$ptr224$i = $tbase$291$i + $tsize$290$i | 0;
   $sp$1105$i = 1656 | 0;
   while (1) {
    if ((HEAP32[$sp$1105$i >> 2] | 0) == ($add$ptr224$i | 0)) {
     label = 224;
     break;
    }
    $138 = HEAP32[$sp$1105$i + 8 >> 2] | 0;
    if (!$138) break; else $sp$1105$i = $138;
   }
   if ((label | 0) == 224) if (!(HEAP32[$sp$1105$i + 12 >> 2] & 8)) {
    HEAP32[$sp$1105$i >> 2] = $tbase$291$i;
    $size242$i = $sp$1105$i + 4 | 0;
    HEAP32[$size242$i >> 2] = (HEAP32[$size242$i >> 2] | 0) + $tsize$290$i;
    $141 = $tbase$291$i + 8 | 0;
    if (!($141 & 7)) $cond$i42$i = 0; else $cond$i42$i = 0 - $141 & 7;
    $143 = $tbase$291$i + ($tsize$290$i + 8) | 0;
    if (!($143 & 7)) $cond15$i$i = 0; else $cond15$i$i = 0 - $143 & 7;
    $add$ptr16$i$i = $tbase$291$i + ($cond15$i$i + $tsize$290$i) | 0;
    $add$ptr4$sum$i49$i = $cond$i42$i + $nb$0 | 0;
    $add$ptr17$i$i = $tbase$291$i + $add$ptr4$sum$i49$i | 0;
    $sub18$i$i = $add$ptr16$i$i - ($tbase$291$i + $cond$i42$i) - $nb$0 | 0;
    HEAP32[$tbase$291$i + ($cond$i42$i + 4) >> 2] = $nb$0 | 3;
    L338 : do if (($add$ptr16$i$i | 0) == (HEAP32[308] | 0)) {
     $add$i$i = (HEAP32[305] | 0) + $sub18$i$i | 0;
     HEAP32[305] = $add$i$i;
     HEAP32[308] = $add$ptr17$i$i;
     HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 4) >> 2] = $add$i$i | 1;
    } else {
     if (($add$ptr16$i$i | 0) == (HEAP32[307] | 0)) {
      $add26$i$i = (HEAP32[304] | 0) + $sub18$i$i | 0;
      HEAP32[304] = $add26$i$i;
      HEAP32[307] = $add$ptr17$i$i;
      HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 4) >> 2] = $add26$i$i | 1;
      HEAP32[$tbase$291$i + ($add26$i$i + $add$ptr4$sum$i49$i) >> 2] = $add26$i$i;
      break;
     }
     $add$ptr16$sum$i$i = $tsize$290$i + 4 | 0;
     $149 = HEAP32[$tbase$291$i + ($add$ptr16$sum$i$i + $cond15$i$i) >> 2] | 0;
     if (($149 & 3 | 0) == 1) {
      $and37$i$i = $149 & -8;
      $shr$i54$i = $149 >>> 3;
      L345 : do if ($149 >>> 0 < 256) {
       $150 = HEAP32[$tbase$291$i + (($cond15$i$i | 8) + $tsize$290$i) >> 2] | 0;
       $151 = HEAP32[$tbase$291$i + ($tsize$290$i + 12 + $cond15$i$i) >> 2] | 0;
       $arrayidx$i57$i = 1248 + ($shr$i54$i << 1 << 2) | 0;
       do if (($150 | 0) != ($arrayidx$i57$i | 0)) {
        if ($150 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
        if ((HEAP32[$150 + 12 >> 2] | 0) == ($add$ptr16$i$i | 0)) break;
        _abort();
       } while (0);
       if (($151 | 0) == ($150 | 0)) {
        HEAP32[302] = HEAP32[302] & ~(1 << $shr$i54$i);
        break;
       }
       do if (($151 | 0) == ($arrayidx$i57$i | 0)) $fd68$pre$phi$i$iZ2D = $151 + 8 | 0; else {
        if ($151 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
        $fd59$i$i = $151 + 8 | 0;
        if ((HEAP32[$fd59$i$i >> 2] | 0) == ($add$ptr16$i$i | 0)) {
         $fd68$pre$phi$i$iZ2D = $fd59$i$i;
         break;
        }
        _abort();
       } while (0);
       HEAP32[$150 + 12 >> 2] = $151;
       HEAP32[$fd68$pre$phi$i$iZ2D >> 2] = $150;
      } else {
       $157 = HEAP32[$tbase$291$i + (($cond15$i$i | 24) + $tsize$290$i) >> 2] | 0;
       $158 = HEAP32[$tbase$291$i + ($tsize$290$i + 12 + $cond15$i$i) >> 2] | 0;
       do if (($158 | 0) == ($add$ptr16$i$i | 0)) {
        $add$ptr16$sum56$i$i = $cond15$i$i | 16;
        $arrayidx96$i$i = $tbase$291$i + ($add$ptr16$sum$i$i + $add$ptr16$sum56$i$i) | 0;
        $163 = HEAP32[$arrayidx96$i$i >> 2] | 0;
        if (!$163) {
         $child$i$i = $tbase$291$i + ($add$ptr16$sum56$i$i + $tsize$290$i) | 0;
         $164 = HEAP32[$child$i$i >> 2] | 0;
         if (!$164) {
          $R$1$i$i = 0;
          break;
         } else {
          $R$0$i$i = $164;
          $RP$0$i$i = $child$i$i;
         }
        } else {
         $R$0$i$i = $163;
         $RP$0$i$i = $arrayidx96$i$i;
        }
        while (1) {
         $arrayidx103$i$i = $R$0$i$i + 20 | 0;
         $165 = HEAP32[$arrayidx103$i$i >> 2] | 0;
         if ($165) {
          $R$0$i$i = $165;
          $RP$0$i$i = $arrayidx103$i$i;
          continue;
         }
         $arrayidx107$i$i = $R$0$i$i + 16 | 0;
         $166 = HEAP32[$arrayidx107$i$i >> 2] | 0;
         if (!$166) break; else {
          $R$0$i$i = $166;
          $RP$0$i$i = $arrayidx107$i$i;
         }
        }
        if ($RP$0$i$i >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
         HEAP32[$RP$0$i$i >> 2] = 0;
         $R$1$i$i = $R$0$i$i;
         break;
        }
       } else {
        $159 = HEAP32[$tbase$291$i + (($cond15$i$i | 8) + $tsize$290$i) >> 2] | 0;
        if ($159 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
        $bk82$i$i = $159 + 12 | 0;
        if ((HEAP32[$bk82$i$i >> 2] | 0) != ($add$ptr16$i$i | 0)) _abort();
        $fd85$i$i = $158 + 8 | 0;
        if ((HEAP32[$fd85$i$i >> 2] | 0) == ($add$ptr16$i$i | 0)) {
         HEAP32[$bk82$i$i >> 2] = $158;
         HEAP32[$fd85$i$i >> 2] = $159;
         $R$1$i$i = $158;
         break;
        } else _abort();
       } while (0);
       if (!$157) break;
       $168 = HEAP32[$tbase$291$i + ($tsize$290$i + 28 + $cond15$i$i) >> 2] | 0;
       $arrayidx123$i$i = 1512 + ($168 << 2) | 0;
       do if (($add$ptr16$i$i | 0) == (HEAP32[$arrayidx123$i$i >> 2] | 0)) {
        HEAP32[$arrayidx123$i$i >> 2] = $R$1$i$i;
        if ($R$1$i$i) break;
        HEAP32[303] = HEAP32[303] & ~(1 << $168);
        break L345;
       } else {
        if ($157 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
        $arrayidx143$i$i = $157 + 16 | 0;
        if ((HEAP32[$arrayidx143$i$i >> 2] | 0) == ($add$ptr16$i$i | 0)) HEAP32[$arrayidx143$i$i >> 2] = $R$1$i$i; else HEAP32[$157 + 20 >> 2] = $R$1$i$i;
        if (!$R$1$i$i) break L345;
       } while (0);
       if ($R$1$i$i >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
       HEAP32[$R$1$i$i + 24 >> 2] = $157;
       $add$ptr16$sum2627$i$i = $cond15$i$i | 16;
       $174 = HEAP32[$tbase$291$i + ($add$ptr16$sum2627$i$i + $tsize$290$i) >> 2] | 0;
       do if ($174) if ($174 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
        HEAP32[$R$1$i$i + 16 >> 2] = $174;
        HEAP32[$174 + 24 >> 2] = $R$1$i$i;
        break;
       } while (0);
       $176 = HEAP32[$tbase$291$i + ($add$ptr16$sum$i$i + $add$ptr16$sum2627$i$i) >> 2] | 0;
       if (!$176) break;
       if ($176 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
        HEAP32[$R$1$i$i + 20 >> 2] = $176;
        HEAP32[$176 + 24 >> 2] = $R$1$i$i;
        break;
       }
      } while (0);
      $oldfirst$0$i$i = $tbase$291$i + (($and37$i$i | $cond15$i$i) + $tsize$290$i) | 0;
      $qsize$0$i$i = $and37$i$i + $sub18$i$i | 0;
     } else {
      $oldfirst$0$i$i = $add$ptr16$i$i;
      $qsize$0$i$i = $sub18$i$i;
     }
     $head208$i$i = $oldfirst$0$i$i + 4 | 0;
     HEAP32[$head208$i$i >> 2] = HEAP32[$head208$i$i >> 2] & -2;
     HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 4) >> 2] = $qsize$0$i$i | 1;
     HEAP32[$tbase$291$i + ($qsize$0$i$i + $add$ptr4$sum$i49$i) >> 2] = $qsize$0$i$i;
     $shr214$i$i = $qsize$0$i$i >>> 3;
     if ($qsize$0$i$i >>> 0 < 256) {
      $shl221$i$i = $shr214$i$i << 1;
      $arrayidx223$i$i = 1248 + ($shl221$i$i << 2) | 0;
      $179 = HEAP32[302] | 0;
      $shl226$i$i = 1 << $shr214$i$i;
      do if (!($179 & $shl226$i$i)) {
       HEAP32[302] = $179 | $shl226$i$i;
       $$pre$phi$i67$iZ2D = 1248 + ($shl221$i$i + 2 << 2) | 0;
       $F224$0$i$i = $arrayidx223$i$i;
      } else {
       $180 = 1248 + ($shl221$i$i + 2 << 2) | 0;
       $181 = HEAP32[$180 >> 2] | 0;
       if ($181 >>> 0 >= (HEAP32[306] | 0) >>> 0) {
        $$pre$phi$i67$iZ2D = $180;
        $F224$0$i$i = $181;
        break;
       }
       _abort();
      } while (0);
      HEAP32[$$pre$phi$i67$iZ2D >> 2] = $add$ptr17$i$i;
      HEAP32[$F224$0$i$i + 12 >> 2] = $add$ptr17$i$i;
      HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 8) >> 2] = $F224$0$i$i;
      HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 12) >> 2] = $arrayidx223$i$i;
      break;
     }
     $shr253$i$i = $qsize$0$i$i >>> 8;
     do if (!$shr253$i$i) $I252$0$i$i = 0; else {
      if ($qsize$0$i$i >>> 0 > 16777215) {
       $I252$0$i$i = 31;
       break;
      }
      $and264$i$i = ($shr253$i$i + 1048320 | 0) >>> 16 & 8;
      $shl265$i$i = $shr253$i$i << $and264$i$i;
      $and268$i$i = ($shl265$i$i + 520192 | 0) >>> 16 & 4;
      $shl270$i$i = $shl265$i$i << $and268$i$i;
      $and273$i$i = ($shl270$i$i + 245760 | 0) >>> 16 & 2;
      $add278$i$i = 14 - ($and268$i$i | $and264$i$i | $and273$i$i) + ($shl270$i$i << $and273$i$i >>> 15) | 0;
      $I252$0$i$i = $qsize$0$i$i >>> ($add278$i$i + 7 | 0) & 1 | $add278$i$i << 1;
     } while (0);
     $arrayidx287$i$i = 1512 + ($I252$0$i$i << 2) | 0;
     HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 28) >> 2] = $I252$0$i$i;
     HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 20) >> 2] = 0;
     HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 16) >> 2] = 0;
     $183 = HEAP32[303] | 0;
     $shl294$i$i = 1 << $I252$0$i$i;
     if (!($183 & $shl294$i$i)) {
      HEAP32[303] = $183 | $shl294$i$i;
      HEAP32[$arrayidx287$i$i >> 2] = $add$ptr17$i$i;
      HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 24) >> 2] = $arrayidx287$i$i;
      HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 12) >> 2] = $add$ptr17$i$i;
      HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 8) >> 2] = $add$ptr17$i$i;
      break;
     }
     $184 = HEAP32[$arrayidx287$i$i >> 2] | 0;
     if (($I252$0$i$i | 0) == 31) $cond315$i$i = 0; else $cond315$i$i = 25 - ($I252$0$i$i >>> 1) | 0;
     L434 : do if ((HEAP32[$184 + 4 >> 2] & -8 | 0) == ($qsize$0$i$i | 0)) $T$0$lcssa$i69$i = $184; else {
      $K305$043$i$i = $qsize$0$i$i << $cond315$i$i;
      $T$042$i$i = $184;
      while (1) {
       $arrayidx325$i$i = $T$042$i$i + ($K305$043$i$i >>> 31 << 2) + 16 | 0;
       $186 = HEAP32[$arrayidx325$i$i >> 2] | 0;
       if (!$186) break;
       if ((HEAP32[$186 + 4 >> 2] & -8 | 0) == ($qsize$0$i$i | 0)) {
        $T$0$lcssa$i69$i = $186;
        break L434;
       } else {
        $K305$043$i$i = $K305$043$i$i << 1;
        $T$042$i$i = $186;
       }
      }
      if ($arrayidx325$i$i >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
       HEAP32[$arrayidx325$i$i >> 2] = $add$ptr17$i$i;
       HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 24) >> 2] = $T$042$i$i;
       HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 12) >> 2] = $add$ptr17$i$i;
       HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 8) >> 2] = $add$ptr17$i$i;
       break L338;
      }
     } while (0);
     $fd344$i$i = $T$0$lcssa$i69$i + 8 | 0;
     $189 = HEAP32[$fd344$i$i >> 2] | 0;
     $190 = HEAP32[306] | 0;
     if ($T$0$lcssa$i69$i >>> 0 < $190 >>> 0) _abort();
     if ($189 >>> 0 < $190 >>> 0) _abort(); else {
      HEAP32[$189 + 12 >> 2] = $add$ptr17$i$i;
      HEAP32[$fd344$i$i >> 2] = $add$ptr17$i$i;
      HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 8) >> 2] = $189;
      HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 12) >> 2] = $T$0$lcssa$i69$i;
      HEAP32[$tbase$291$i + ($add$ptr4$sum$i49$i + 24) >> 2] = 0;
      break;
     }
    } while (0);
    $mem$0 = $tbase$291$i + ($cond$i42$i | 8) | 0;
    STACKTOP = sp;
    return $mem$0 | 0;
   }
   $sp$0$i$i$i = 1656 | 0;
   while (1) {
    $191 = HEAP32[$sp$0$i$i$i >> 2] | 0;
    if ($191 >>> 0 <= $120 >>> 0) {
     $192 = HEAP32[$sp$0$i$i$i + 4 >> 2] | 0;
     $add$ptr$i$i$i = $191 + $192 | 0;
     if ($add$ptr$i$i$i >>> 0 > $120 >>> 0) break;
    }
    $sp$0$i$i$i = HEAP32[$sp$0$i$i$i + 8 >> 2] | 0;
   }
   $194 = $191 + ($192 + -39) | 0;
   if (!($194 & 7)) $cond$i17$i = 0; else $cond$i17$i = 0 - $194 & 7;
   $add$ptr7$i$i = $191 + ($192 + -47 + $cond$i17$i) | 0;
   $cond13$i$i = $add$ptr7$i$i >>> 0 < ($120 + 16 | 0) >>> 0 ? $120 : $add$ptr7$i$i;
   $add$ptr14$i$i = $cond13$i$i + 8 | 0;
   $196 = $tbase$291$i + 8 | 0;
   if (!($196 & 7)) $cond$i$i$i = 0; else $cond$i$i$i = 0 - $196 & 7;
   $sub5$i$i$i = $tsize$290$i + -40 - $cond$i$i$i | 0;
   HEAP32[308] = $tbase$291$i + $cond$i$i$i;
   HEAP32[305] = $sub5$i$i$i;
   HEAP32[$tbase$291$i + ($cond$i$i$i + 4) >> 2] = $sub5$i$i$i | 1;
   HEAP32[$tbase$291$i + ($tsize$290$i + -36) >> 2] = 40;
   HEAP32[309] = HEAP32[424];
   HEAP32[$cond13$i$i + 4 >> 2] = 27;
   HEAP32[$add$ptr14$i$i + 0 >> 2] = HEAP32[414];
   HEAP32[$add$ptr14$i$i + 4 >> 2] = HEAP32[415];
   HEAP32[$add$ptr14$i$i + 8 >> 2] = HEAP32[416];
   HEAP32[$add$ptr14$i$i + 12 >> 2] = HEAP32[417];
   HEAP32[414] = $tbase$291$i;
   HEAP32[415] = $tsize$290$i;
   HEAP32[417] = 0;
   HEAP32[416] = $add$ptr14$i$i;
   $add$ptr2418$i$i = $cond13$i$i + 28 | 0;
   HEAP32[$add$ptr2418$i$i >> 2] = 7;
   if (($cond13$i$i + 32 | 0) >>> 0 < $add$ptr$i$i$i >>> 0) {
    $add$ptr2420$i$i = $add$ptr2418$i$i;
    do {
     $add$ptr2420$i$i$looptemp = $add$ptr2420$i$i;
     $add$ptr2420$i$i = $add$ptr2420$i$i + 4 | 0;
     HEAP32[$add$ptr2420$i$i >> 2] = 7;
    } while (($add$ptr2420$i$i$looptemp + 8 | 0) >>> 0 < $add$ptr$i$i$i >>> 0);
   }
   if (($cond13$i$i | 0) != ($120 | 0)) {
    $sub$ptr$sub$i$i = $cond13$i$i - $120 | 0;
    $head31$i$i = $120 + ($sub$ptr$sub$i$i + 4) | 0;
    HEAP32[$head31$i$i >> 2] = HEAP32[$head31$i$i >> 2] & -2;
    HEAP32[$120 + 4 >> 2] = $sub$ptr$sub$i$i | 1;
    HEAP32[$120 + $sub$ptr$sub$i$i >> 2] = $sub$ptr$sub$i$i;
    $shr$i$i = $sub$ptr$sub$i$i >>> 3;
    if ($sub$ptr$sub$i$i >>> 0 < 256) {
     $shl$i20$i = $shr$i$i << 1;
     $arrayidx$i21$i = 1248 + ($shl$i20$i << 2) | 0;
     $203 = HEAP32[302] | 0;
     $shl39$i$i = 1 << $shr$i$i;
     do if (!($203 & $shl39$i$i)) {
      HEAP32[302] = $203 | $shl39$i$i;
      $$pre$phi$i$iZ2D = 1248 + ($shl$i20$i + 2 << 2) | 0;
      $F$0$i$i = $arrayidx$i21$i;
     } else {
      $204 = 1248 + ($shl$i20$i + 2 << 2) | 0;
      $205 = HEAP32[$204 >> 2] | 0;
      if ($205 >>> 0 >= (HEAP32[306] | 0) >>> 0) {
       $$pre$phi$i$iZ2D = $204;
       $F$0$i$i = $205;
       break;
      }
      _abort();
     } while (0);
     HEAP32[$$pre$phi$i$iZ2D >> 2] = $120;
     HEAP32[$F$0$i$i + 12 >> 2] = $120;
     HEAP32[$120 + 8 >> 2] = $F$0$i$i;
     HEAP32[$120 + 12 >> 2] = $arrayidx$i21$i;
     break;
    }
    $shr58$i$i = $sub$ptr$sub$i$i >>> 8;
    if (!$shr58$i$i) $I57$0$i$i = 0; else if ($sub$ptr$sub$i$i >>> 0 > 16777215) $I57$0$i$i = 31; else {
     $and69$i$i = ($shr58$i$i + 1048320 | 0) >>> 16 & 8;
     $shl70$i$i = $shr58$i$i << $and69$i$i;
     $and73$i$i = ($shl70$i$i + 520192 | 0) >>> 16 & 4;
     $shl75$i$i = $shl70$i$i << $and73$i$i;
     $and78$i$i = ($shl75$i$i + 245760 | 0) >>> 16 & 2;
     $add83$i$i = 14 - ($and73$i$i | $and69$i$i | $and78$i$i) + ($shl75$i$i << $and78$i$i >>> 15) | 0;
     $I57$0$i$i = $sub$ptr$sub$i$i >>> ($add83$i$i + 7 | 0) & 1 | $add83$i$i << 1;
    }
    $arrayidx91$i$i = 1512 + ($I57$0$i$i << 2) | 0;
    HEAP32[$120 + 28 >> 2] = $I57$0$i$i;
    HEAP32[$120 + 20 >> 2] = 0;
    HEAP32[$120 + 16 >> 2] = 0;
    $208 = HEAP32[303] | 0;
    $shl95$i$i = 1 << $I57$0$i$i;
    if (!($208 & $shl95$i$i)) {
     HEAP32[303] = $208 | $shl95$i$i;
     HEAP32[$arrayidx91$i$i >> 2] = $120;
     HEAP32[$120 + 24 >> 2] = $arrayidx91$i$i;
     HEAP32[$120 + 12 >> 2] = $120;
     HEAP32[$120 + 8 >> 2] = $120;
     break;
    }
    $209 = HEAP32[$arrayidx91$i$i >> 2] | 0;
    if (($I57$0$i$i | 0) == 31) $cond115$i$i = 0; else $cond115$i$i = 25 - ($I57$0$i$i >>> 1) | 0;
    L489 : do if ((HEAP32[$209 + 4 >> 2] & -8 | 0) == ($sub$ptr$sub$i$i | 0)) $T$0$lcssa$i$i = $209; else {
     $K105$017$i$i = $sub$ptr$sub$i$i << $cond115$i$i;
     $T$016$i$i = $209;
     while (1) {
      $arrayidx126$i$i = $T$016$i$i + ($K105$017$i$i >>> 31 << 2) + 16 | 0;
      $211 = HEAP32[$arrayidx126$i$i >> 2] | 0;
      if (!$211) break;
      if ((HEAP32[$211 + 4 >> 2] & -8 | 0) == ($sub$ptr$sub$i$i | 0)) {
       $T$0$lcssa$i$i = $211;
       break L489;
      } else {
       $K105$017$i$i = $K105$017$i$i << 1;
       $T$016$i$i = $211;
      }
     }
     if ($arrayidx126$i$i >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
      HEAP32[$arrayidx126$i$i >> 2] = $120;
      HEAP32[$120 + 24 >> 2] = $T$016$i$i;
      HEAP32[$120 + 12 >> 2] = $120;
      HEAP32[$120 + 8 >> 2] = $120;
      break L311;
     }
    } while (0);
    $fd145$i$i = $T$0$lcssa$i$i + 8 | 0;
    $214 = HEAP32[$fd145$i$i >> 2] | 0;
    $215 = HEAP32[306] | 0;
    if ($T$0$lcssa$i$i >>> 0 < $215 >>> 0) _abort();
    if ($214 >>> 0 < $215 >>> 0) _abort(); else {
     HEAP32[$214 + 12 >> 2] = $120;
     HEAP32[$fd145$i$i >> 2] = $120;
     HEAP32[$120 + 8 >> 2] = $214;
     HEAP32[$120 + 12 >> 2] = $T$0$lcssa$i$i;
     HEAP32[$120 + 24 >> 2] = 0;
     break;
    }
   }
  } while (0);
  $216 = HEAP32[305] | 0;
  if ($216 >>> 0 > $nb$0 >>> 0) {
   $sub253$i = $216 - $nb$0 | 0;
   HEAP32[305] = $sub253$i;
   $217 = HEAP32[308] | 0;
   HEAP32[308] = $217 + $nb$0;
   HEAP32[$217 + ($nb$0 + 4) >> 2] = $sub253$i | 1;
   HEAP32[$217 + 4 >> 2] = $nb$0 | 3;
   $mem$0 = $217 + 8 | 0;
   STACKTOP = sp;
   return $mem$0 | 0;
  }
 }
 HEAP32[(___errno_location() | 0) >> 2] = 12;
 $mem$0 = 0;
 STACKTOP = sp;
 return $mem$0 | 0;
}
function _free($mem) {
 $mem = $mem | 0;
 var $$pre$phiZ2D = 0, $0 = 0, $1 = 0, $10 = 0, $11 = 0, $14 = 0, $15 = 0, $16 = 0, $17 = 0, $18 = 0, $2 = 0, $24 = 0, $26 = 0, $30 = 0, $36 = 0, $37 = 0, $4 = 0, $43 = 0, $44 = 0, $45 = 0, $49 = 0, $5 = 0, $50 = 0, $51 = 0, $52 = 0, $54 = 0, $60 = 0, $62 = 0, $65 = 0, $66 = 0, $67 = 0, $70 = 0, $71 = 0, $73 = 0, $76 = 0, $77 = 0, $9 = 0, $F502$0 = 0, $I526$0 = 0, $K575$0270 = 0, $R$0 = 0, $R$1 = 0, $R327$0 = 0, $R327$1 = 0, $RP$0 = 0, $RP355$0 = 0, $T$0$lcssa = 0, $T$0269 = 0, $add$ptr = 0, $add$ptr$sum230 = 0, $add$ptr16 = 0, $add$ptr6 = 0, $add17 = 0, $add243 = 0, $add254 = 0, $add262 = 0, $add551 = 0, $and = 0, $and5 = 0, $and537 = 0, $and541 = 0, $and546 = 0, $arrayidx = 0, $arrayidx108 = 0, $arrayidx113 = 0, $arrayidx130 = 0, $arrayidx149 = 0, $arrayidx274 = 0, $arrayidx357 = 0, $arrayidx369 = 0, $arrayidx374 = 0, $arrayidx395 = 0, $arrayidx414 = 0, $arrayidx501 = 0, $arrayidx559 = 0, $arrayidx591 = 0, $arrayidx99 = 0, $bk338 = 0, $bk82 = 0, $child = 0, $child356 = 0, $cond = 0, $dec = 0, $fd306 = 0, $fd317$pre$phiZ2D = 0, $fd342 = 0, $fd56 = 0, $fd609 = 0, $fd67$pre$phiZ2D = 0, $fd86 = 0, $head209 = 0, $head228 = 0, $p$0 = 0, $psize$0 = 0, $psize$1 = 0, $shl500 = 0, $shl503 = 0, $shl538 = 0, $shl543 = 0, $shl565 = 0, $shr = 0, $shr263 = 0, $shr493 = 0, $shr527 = 0, $sp$0$i = 0, $sp$0$in$i = 0, sp = 0;
 sp = STACKTOP;
 if (!$mem) {
  STACKTOP = sp;
  return;
 }
 $add$ptr = $mem + -8 | 0;
 $0 = HEAP32[306] | 0;
 if ($add$ptr >>> 0 < $0 >>> 0) _abort();
 $1 = HEAP32[$mem + -4 >> 2] | 0;
 $and = $1 & 3;
 if (($and | 0) == 1) _abort();
 $and5 = $1 & -8;
 $add$ptr6 = $mem + ($and5 + -8) | 0;
 do if (!($1 & 1)) {
  $2 = HEAP32[$add$ptr >> 2] | 0;
  if (!$and) {
   STACKTOP = sp;
   return;
  }
  $add$ptr$sum230 = -8 - $2 | 0;
  $add$ptr16 = $mem + $add$ptr$sum230 | 0;
  $add17 = $2 + $and5 | 0;
  if ($add$ptr16 >>> 0 < $0 >>> 0) _abort();
  if (($add$ptr16 | 0) == (HEAP32[307] | 0)) {
   $head209 = $mem + ($and5 + -4) | 0;
   if ((HEAP32[$head209 >> 2] & 3 | 0) != 3) {
    $p$0 = $add$ptr16;
    $psize$0 = $add17;
    break;
   }
   HEAP32[304] = $add17;
   HEAP32[$head209 >> 2] = HEAP32[$head209 >> 2] & -2;
   HEAP32[$mem + ($add$ptr$sum230 + 4) >> 2] = $add17 | 1;
   HEAP32[$add$ptr6 >> 2] = $add17;
   STACKTOP = sp;
   return;
  }
  $shr = $2 >>> 3;
  if ($2 >>> 0 < 256) {
   $4 = HEAP32[$mem + ($add$ptr$sum230 + 8) >> 2] | 0;
   $5 = HEAP32[$mem + ($add$ptr$sum230 + 12) >> 2] | 0;
   $arrayidx = 1248 + ($shr << 1 << 2) | 0;
   if (($4 | 0) != ($arrayidx | 0)) {
    if ($4 >>> 0 < $0 >>> 0) _abort();
    if ((HEAP32[$4 + 12 >> 2] | 0) != ($add$ptr16 | 0)) _abort();
   }
   if (($5 | 0) == ($4 | 0)) {
    HEAP32[302] = HEAP32[302] & ~(1 << $shr);
    $p$0 = $add$ptr16;
    $psize$0 = $add17;
    break;
   }
   if (($5 | 0) == ($arrayidx | 0)) $fd67$pre$phiZ2D = $5 + 8 | 0; else {
    if ($5 >>> 0 < $0 >>> 0) _abort();
    $fd56 = $5 + 8 | 0;
    if ((HEAP32[$fd56 >> 2] | 0) == ($add$ptr16 | 0)) $fd67$pre$phiZ2D = $fd56; else _abort();
   }
   HEAP32[$4 + 12 >> 2] = $5;
   HEAP32[$fd67$pre$phiZ2D >> 2] = $4;
   $p$0 = $add$ptr16;
   $psize$0 = $add17;
   break;
  }
  $9 = HEAP32[$mem + ($add$ptr$sum230 + 24) >> 2] | 0;
  $10 = HEAP32[$mem + ($add$ptr$sum230 + 12) >> 2] | 0;
  do if (($10 | 0) == ($add$ptr16 | 0)) {
   $arrayidx99 = $mem + ($add$ptr$sum230 + 20) | 0;
   $14 = HEAP32[$arrayidx99 >> 2] | 0;
   if (!$14) {
    $child = $mem + ($add$ptr$sum230 + 16) | 0;
    $15 = HEAP32[$child >> 2] | 0;
    if (!$15) {
     $R$1 = 0;
     break;
    } else {
     $R$0 = $15;
     $RP$0 = $child;
    }
   } else {
    $R$0 = $14;
    $RP$0 = $arrayidx99;
   }
   while (1) {
    $arrayidx108 = $R$0 + 20 | 0;
    $16 = HEAP32[$arrayidx108 >> 2] | 0;
    if ($16) {
     $R$0 = $16;
     $RP$0 = $arrayidx108;
     continue;
    }
    $arrayidx113 = $R$0 + 16 | 0;
    $17 = HEAP32[$arrayidx113 >> 2] | 0;
    if (!$17) break; else {
     $R$0 = $17;
     $RP$0 = $arrayidx113;
    }
   }
   if ($RP$0 >>> 0 < $0 >>> 0) _abort(); else {
    HEAP32[$RP$0 >> 2] = 0;
    $R$1 = $R$0;
    break;
   }
  } else {
   $11 = HEAP32[$mem + ($add$ptr$sum230 + 8) >> 2] | 0;
   if ($11 >>> 0 < $0 >>> 0) _abort();
   $bk82 = $11 + 12 | 0;
   if ((HEAP32[$bk82 >> 2] | 0) != ($add$ptr16 | 0)) _abort();
   $fd86 = $10 + 8 | 0;
   if ((HEAP32[$fd86 >> 2] | 0) == ($add$ptr16 | 0)) {
    HEAP32[$bk82 >> 2] = $10;
    HEAP32[$fd86 >> 2] = $11;
    $R$1 = $10;
    break;
   } else _abort();
  } while (0);
  if (!$9) {
   $p$0 = $add$ptr16;
   $psize$0 = $add17;
  } else {
   $18 = HEAP32[$mem + ($add$ptr$sum230 + 28) >> 2] | 0;
   $arrayidx130 = 1512 + ($18 << 2) | 0;
   if (($add$ptr16 | 0) == (HEAP32[$arrayidx130 >> 2] | 0)) {
    HEAP32[$arrayidx130 >> 2] = $R$1;
    if (!$R$1) {
     HEAP32[303] = HEAP32[303] & ~(1 << $18);
     $p$0 = $add$ptr16;
     $psize$0 = $add17;
     break;
    }
   } else {
    if ($9 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
    $arrayidx149 = $9 + 16 | 0;
    if ((HEAP32[$arrayidx149 >> 2] | 0) == ($add$ptr16 | 0)) HEAP32[$arrayidx149 >> 2] = $R$1; else HEAP32[$9 + 20 >> 2] = $R$1;
    if (!$R$1) {
     $p$0 = $add$ptr16;
     $psize$0 = $add17;
     break;
    }
   }
   if ($R$1 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
   HEAP32[$R$1 + 24 >> 2] = $9;
   $24 = HEAP32[$mem + ($add$ptr$sum230 + 16) >> 2] | 0;
   do if ($24) if ($24 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
    HEAP32[$R$1 + 16 >> 2] = $24;
    HEAP32[$24 + 24 >> 2] = $R$1;
    break;
   } while (0);
   $26 = HEAP32[$mem + ($add$ptr$sum230 + 20) >> 2] | 0;
   if (!$26) {
    $p$0 = $add$ptr16;
    $psize$0 = $add17;
   } else if ($26 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
    HEAP32[$R$1 + 20 >> 2] = $26;
    HEAP32[$26 + 24 >> 2] = $R$1;
    $p$0 = $add$ptr16;
    $psize$0 = $add17;
    break;
   }
  }
 } else {
  $p$0 = $add$ptr;
  $psize$0 = $and5;
 } while (0);
 if ($p$0 >>> 0 >= $add$ptr6 >>> 0) _abort();
 $head228 = $mem + ($and5 + -4) | 0;
 $30 = HEAP32[$head228 >> 2] | 0;
 if (!($30 & 1)) _abort();
 if (!($30 & 2)) {
  if (($add$ptr6 | 0) == (HEAP32[308] | 0)) {
   $add243 = (HEAP32[305] | 0) + $psize$0 | 0;
   HEAP32[305] = $add243;
   HEAP32[308] = $p$0;
   HEAP32[$p$0 + 4 >> 2] = $add243 | 1;
   if (($p$0 | 0) != (HEAP32[307] | 0)) {
    STACKTOP = sp;
    return;
   }
   HEAP32[307] = 0;
   HEAP32[304] = 0;
   STACKTOP = sp;
   return;
  }
  if (($add$ptr6 | 0) == (HEAP32[307] | 0)) {
   $add254 = (HEAP32[304] | 0) + $psize$0 | 0;
   HEAP32[304] = $add254;
   HEAP32[307] = $p$0;
   HEAP32[$p$0 + 4 >> 2] = $add254 | 1;
   HEAP32[$p$0 + $add254 >> 2] = $add254;
   STACKTOP = sp;
   return;
  }
  $add262 = ($30 & -8) + $psize$0 | 0;
  $shr263 = $30 >>> 3;
  do if ($30 >>> 0 < 256) {
   $36 = HEAP32[$mem + $and5 >> 2] | 0;
   $37 = HEAP32[$mem + ($and5 | 4) >> 2] | 0;
   $arrayidx274 = 1248 + ($shr263 << 1 << 2) | 0;
   if (($36 | 0) != ($arrayidx274 | 0)) {
    if ($36 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
    if ((HEAP32[$36 + 12 >> 2] | 0) != ($add$ptr6 | 0)) _abort();
   }
   if (($37 | 0) == ($36 | 0)) {
    HEAP32[302] = HEAP32[302] & ~(1 << $shr263);
    break;
   }
   if (($37 | 0) == ($arrayidx274 | 0)) $fd317$pre$phiZ2D = $37 + 8 | 0; else {
    if ($37 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
    $fd306 = $37 + 8 | 0;
    if ((HEAP32[$fd306 >> 2] | 0) == ($add$ptr6 | 0)) $fd317$pre$phiZ2D = $fd306; else _abort();
   }
   HEAP32[$36 + 12 >> 2] = $37;
   HEAP32[$fd317$pre$phiZ2D >> 2] = $36;
  } else {
   $43 = HEAP32[$mem + ($and5 + 16) >> 2] | 0;
   $44 = HEAP32[$mem + ($and5 | 4) >> 2] | 0;
   do if (($44 | 0) == ($add$ptr6 | 0)) {
    $arrayidx357 = $mem + ($and5 + 12) | 0;
    $49 = HEAP32[$arrayidx357 >> 2] | 0;
    if (!$49) {
     $child356 = $mem + ($and5 + 8) | 0;
     $50 = HEAP32[$child356 >> 2] | 0;
     if (!$50) {
      $R327$1 = 0;
      break;
     } else {
      $R327$0 = $50;
      $RP355$0 = $child356;
     }
    } else {
     $R327$0 = $49;
     $RP355$0 = $arrayidx357;
    }
    while (1) {
     $arrayidx369 = $R327$0 + 20 | 0;
     $51 = HEAP32[$arrayidx369 >> 2] | 0;
     if ($51) {
      $R327$0 = $51;
      $RP355$0 = $arrayidx369;
      continue;
     }
     $arrayidx374 = $R327$0 + 16 | 0;
     $52 = HEAP32[$arrayidx374 >> 2] | 0;
     if (!$52) break; else {
      $R327$0 = $52;
      $RP355$0 = $arrayidx374;
     }
    }
    if ($RP355$0 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
     HEAP32[$RP355$0 >> 2] = 0;
     $R327$1 = $R327$0;
     break;
    }
   } else {
    $45 = HEAP32[$mem + $and5 >> 2] | 0;
    if ($45 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
    $bk338 = $45 + 12 | 0;
    if ((HEAP32[$bk338 >> 2] | 0) != ($add$ptr6 | 0)) _abort();
    $fd342 = $44 + 8 | 0;
    if ((HEAP32[$fd342 >> 2] | 0) == ($add$ptr6 | 0)) {
     HEAP32[$bk338 >> 2] = $44;
     HEAP32[$fd342 >> 2] = $45;
     $R327$1 = $44;
     break;
    } else _abort();
   } while (0);
   if ($43) {
    $54 = HEAP32[$mem + ($and5 + 20) >> 2] | 0;
    $arrayidx395 = 1512 + ($54 << 2) | 0;
    if (($add$ptr6 | 0) == (HEAP32[$arrayidx395 >> 2] | 0)) {
     HEAP32[$arrayidx395 >> 2] = $R327$1;
     if (!$R327$1) {
      HEAP32[303] = HEAP32[303] & ~(1 << $54);
      break;
     }
    } else {
     if ($43 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
     $arrayidx414 = $43 + 16 | 0;
     if ((HEAP32[$arrayidx414 >> 2] | 0) == ($add$ptr6 | 0)) HEAP32[$arrayidx414 >> 2] = $R327$1; else HEAP32[$43 + 20 >> 2] = $R327$1;
     if (!$R327$1) break;
    }
    if ($R327$1 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort();
    HEAP32[$R327$1 + 24 >> 2] = $43;
    $60 = HEAP32[$mem + ($and5 + 8) >> 2] | 0;
    do if ($60) if ($60 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
     HEAP32[$R327$1 + 16 >> 2] = $60;
     HEAP32[$60 + 24 >> 2] = $R327$1;
     break;
    } while (0);
    $62 = HEAP32[$mem + ($and5 + 12) >> 2] | 0;
    if ($62) if ($62 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
     HEAP32[$R327$1 + 20 >> 2] = $62;
     HEAP32[$62 + 24 >> 2] = $R327$1;
     break;
    }
   }
  } while (0);
  HEAP32[$p$0 + 4 >> 2] = $add262 | 1;
  HEAP32[$p$0 + $add262 >> 2] = $add262;
  if (($p$0 | 0) == (HEAP32[307] | 0)) {
   HEAP32[304] = $add262;
   STACKTOP = sp;
   return;
  } else $psize$1 = $add262;
 } else {
  HEAP32[$head228 >> 2] = $30 & -2;
  HEAP32[$p$0 + 4 >> 2] = $psize$0 | 1;
  HEAP32[$p$0 + $psize$0 >> 2] = $psize$0;
  $psize$1 = $psize$0;
 }
 $shr493 = $psize$1 >>> 3;
 if ($psize$1 >>> 0 < 256) {
  $shl500 = $shr493 << 1;
  $arrayidx501 = 1248 + ($shl500 << 2) | 0;
  $65 = HEAP32[302] | 0;
  $shl503 = 1 << $shr493;
  if (!($65 & $shl503)) {
   HEAP32[302] = $65 | $shl503;
   $$pre$phiZ2D = 1248 + ($shl500 + 2 << 2) | 0;
   $F502$0 = $arrayidx501;
  } else {
   $66 = 1248 + ($shl500 + 2 << 2) | 0;
   $67 = HEAP32[$66 >> 2] | 0;
   if ($67 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
    $$pre$phiZ2D = $66;
    $F502$0 = $67;
   }
  }
  HEAP32[$$pre$phiZ2D >> 2] = $p$0;
  HEAP32[$F502$0 + 12 >> 2] = $p$0;
  HEAP32[$p$0 + 8 >> 2] = $F502$0;
  HEAP32[$p$0 + 12 >> 2] = $arrayidx501;
  STACKTOP = sp;
  return;
 }
 $shr527 = $psize$1 >>> 8;
 if (!$shr527) $I526$0 = 0; else if ($psize$1 >>> 0 > 16777215) $I526$0 = 31; else {
  $and537 = ($shr527 + 1048320 | 0) >>> 16 & 8;
  $shl538 = $shr527 << $and537;
  $and541 = ($shl538 + 520192 | 0) >>> 16 & 4;
  $shl543 = $shl538 << $and541;
  $and546 = ($shl543 + 245760 | 0) >>> 16 & 2;
  $add551 = 14 - ($and541 | $and537 | $and546) + ($shl543 << $and546 >>> 15) | 0;
  $I526$0 = $psize$1 >>> ($add551 + 7 | 0) & 1 | $add551 << 1;
 }
 $arrayidx559 = 1512 + ($I526$0 << 2) | 0;
 HEAP32[$p$0 + 28 >> 2] = $I526$0;
 HEAP32[$p$0 + 20 >> 2] = 0;
 HEAP32[$p$0 + 16 >> 2] = 0;
 $70 = HEAP32[303] | 0;
 $shl565 = 1 << $I526$0;
 L199 : do if (!($70 & $shl565)) {
  HEAP32[303] = $70 | $shl565;
  HEAP32[$arrayidx559 >> 2] = $p$0;
  HEAP32[$p$0 + 24 >> 2] = $arrayidx559;
  HEAP32[$p$0 + 12 >> 2] = $p$0;
  HEAP32[$p$0 + 8 >> 2] = $p$0;
 } else {
  $71 = HEAP32[$arrayidx559 >> 2] | 0;
  if (($I526$0 | 0) == 31) $cond = 0; else $cond = 25 - ($I526$0 >>> 1) | 0;
  L205 : do if ((HEAP32[$71 + 4 >> 2] & -8 | 0) == ($psize$1 | 0)) $T$0$lcssa = $71; else {
   $K575$0270 = $psize$1 << $cond;
   $T$0269 = $71;
   while (1) {
    $arrayidx591 = $T$0269 + ($K575$0270 >>> 31 << 2) + 16 | 0;
    $73 = HEAP32[$arrayidx591 >> 2] | 0;
    if (!$73) break;
    if ((HEAP32[$73 + 4 >> 2] & -8 | 0) == ($psize$1 | 0)) {
     $T$0$lcssa = $73;
     break L205;
    } else {
     $K575$0270 = $K575$0270 << 1;
     $T$0269 = $73;
    }
   }
   if ($arrayidx591 >>> 0 < (HEAP32[306] | 0) >>> 0) _abort(); else {
    HEAP32[$arrayidx591 >> 2] = $p$0;
    HEAP32[$p$0 + 24 >> 2] = $T$0269;
    HEAP32[$p$0 + 12 >> 2] = $p$0;
    HEAP32[$p$0 + 8 >> 2] = $p$0;
    break L199;
   }
  } while (0);
  $fd609 = $T$0$lcssa + 8 | 0;
  $76 = HEAP32[$fd609 >> 2] | 0;
  $77 = HEAP32[306] | 0;
  if ($T$0$lcssa >>> 0 < $77 >>> 0) _abort();
  if ($76 >>> 0 < $77 >>> 0) _abort(); else {
   HEAP32[$76 + 12 >> 2] = $p$0;
   HEAP32[$fd609 >> 2] = $p$0;
   HEAP32[$p$0 + 8 >> 2] = $76;
   HEAP32[$p$0 + 12 >> 2] = $T$0$lcssa;
   HEAP32[$p$0 + 24 >> 2] = 0;
   break;
  }
 } while (0);
 $dec = (HEAP32[310] | 0) + -1 | 0;
 HEAP32[310] = $dec;
 if (!$dec) $sp$0$in$i = 1664 | 0; else {
  STACKTOP = sp;
  return;
 }
 while (1) {
  $sp$0$i = HEAP32[$sp$0$in$i >> 2] | 0;
  if (!$sp$0$i) break; else $sp$0$in$i = $sp$0$i + 8 | 0;
 }
 HEAP32[310] = -1;
 STACKTOP = sp;
 return;
}
function _fma_sf64($0, $1, $2, $3, $4, $5, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $4 = $4 | 0;
 $5 = $5 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $10 = 0, $100 = 0, $101 = 0, $103 = 0, $105 = 0, $107 = 0, $108 = 0, $109 = 0, $11 = 0, $110 = 0, $111 = 0, $112 = 0, $113 = 0, $114 = 0, $115 = 0, $116 = 0, $118 = 0, $119 = 0, $12 = 0, $121 = 0, $122 = 0, $124 = 0, $125 = 0, $126 = 0, $127 = 0, $128 = 0, $129 = 0, $130 = 0, $131 = 0, $138 = 0, $139 = 0, $14 = 0, $140 = 0, $144 = 0, $149 = 0, $151 = 0, $155 = 0, $156 = 0, $158 = 0, $16 = 0, $161 = 0, $163 = 0, $165 = 0, $167 = 0, $169 = 0, $172 = 0, $173 = 0, $174 = 0, $175 = 0, $18 = 0, $19 = 0, $190 = 0, $191 = 0, $193 = 0, $194 = 0, $20 = 0, $203 = 0, $205 = 0, $206 = 0, $207 = 0, $221 = 0, $223 = 0, $224 = 0, $225 = 0, $226 = 0, $227 = 0, $230 = 0, $238 = 0, $240 = 0, $241 = 0, $242 = 0, $243 = 0, $244 = 0, $245 = 0, $252 = 0, $253 = 0, $254 = 0, $255 = 0, $256 = 0, $258 = 0, $260 = 0, $261 = 0, $262 = 0, $269 = 0, $27 = 0, $272 = 0, $273 = 0, $279 = 0, $281 = 0, $284 = 0, $286 = 0, $289 = 0, $291 = 0, $298 = 0, $299 = 0, $300 = 0, $303 = 0, $304 = 0, $311 = 0, $313 = 0, $314 = 0, $315 = 0, $317 = 0, $318 = 0, $6 = 0, $68 = 0, $7 = 0, $71 = 0, $77 = 0, $79 = 0, $88 = 0, $90 = 0, $92 = 0, $95 = 0, $96 = 0, $97 = 0, $99 = 0, $add = 0, $c_sign$0 = 0, $cmp = 0, $cmp46 = 0, $conv12 = 0, $conv6 = 0, $conv9 = 0, $inc = 0, $l$0$i = 0, $l$0263136$i = 0, $or$cond86 = 0, $r_exp$0 = 0, $r_exp$1 = 0, $r_sign$0 = 0, $r_sign$1 = 0, $r_sign$2 = 0, $sub$i = 0, $sub151 = 0, $sub163 = 0, $sub2$i147202 = 0, $sub2$i159203 = 0, $sub2$i199 = 0, $sub2$i200 = 0, $sub3$i = 0, $sub332$i = 0, $sub33335$i = 0, $sub8$i = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $6 = _bitshift64Lshr($4 | 0, $5 | 0, 63) | 0;
 $7 = tempRet0;
 $10 = _bitshift64Lshr($2 ^ $0 | 0, $3 ^ $1 | 0, 63) | 0;
 $11 = tempRet0;
 $12 = _bitshift64Lshr($0 | 0, $1 | 0, 52) | 0;
 $conv6 = $12 & 2047;
 $14 = _bitshift64Lshr($2 | 0, $3 | 0, 52) | 0;
 $conv9 = $14 & 2047;
 $16 = _bitshift64Lshr($4 | 0, $5 | 0, 52) | 0;
 $conv12 = $16 & 2047;
 $18 = $1 & 1048575;
 $19 = $3 & 1048575;
 $20 = $5 & 1048575;
 $cmp = ($conv6 | 0) == 2047;
 if (!$cmp) if (!(($conv9 | 0) == 2047 | ($conv12 | 0) == 2047)) {
  if (!$conv6) {
   if (!(($0 | 0) == 0 & ($18 | 0) == 0)) {
    $77 = _llvm_ctlz_i64($0 | 0, $18 | 0, 0) | 0;
    $79 = _bitshift64Shl($0 | 0, $18 | 0, $77 + -11 | 0) | 0;
    $95 = $79;
    $96 = tempRet0;
    $sub2$i159203 = 12 - $77 | 0;
    label = 24;
   }
  } else {
   $95 = $0;
   $96 = $18 | 1048576;
   $sub2$i159203 = $conv6;
   label = 24;
  }
  do if ((label | 0) == 24) {
   if (!$conv9) {
    if (($2 | 0) == 0 & ($19 | 0) == 0) break;
    $90 = _llvm_ctlz_i64($2 | 0, $19 | 0, 0) | 0;
    $92 = _bitshift64Shl($2 | 0, $19 | 0, $90 + -11 | 0) | 0;
    $100 = tempRet0;
    $99 = $92;
    $sub2$i147202 = 12 - $90 | 0;
   } else {
    $100 = $19 | 1048576;
    $99 = $2;
    $sub2$i147202 = $conv9;
   }
   $add = $sub2$i147202 + $sub2$i159203 | 0;
   $97 = _bitshift64Shl($95 | 0, $96 | 0, 10) | 0;
   $101 = _bitshift64Shl($99 | 0, $100 | 0, 10) | 0;
   $103 = _bitshift64Lshr($95 | 0, $96 | 0, 22) | 0;
   $105 = _bitshift64Lshr($99 | 0, $100 | 0, 22) | 0;
   $107 = $97 & -1024;
   $108 = $101 & -1024;
   $109 = ___muldi3($108 | 0, 0, $107 | 0, 0) | 0;
   $110 = tempRet0;
   $111 = ___muldi3($105 | 0, 0, $107 | 0, 0) | 0;
   $112 = tempRet0;
   $113 = ___muldi3($108 | 0, 0, $103 | 0, 0) | 0;
   $114 = tempRet0;
   $115 = ___muldi3($105 | 0, 0, $103 | 0, 0) | 0;
   $116 = tempRet0;
   $118 = _i64Add($110 | 0, 0, $111 & -1024 | 0, 0) | 0;
   $119 = tempRet0;
   _i64Add($118 | 0, $119 | 0, $113 & -1024 | 0, 0) | 0;
   $121 = tempRet0;
   $122 = _i64Add($114 | 0, 0, $112 | 0, 0) | 0;
   $124 = _i64Add($122 | 0, tempRet0 | 0, $121 | 0, 0) | 0;
   $125 = tempRet0;
   _i64Add($124 | 0, $125 | 0, $115 | 0, 0) | 0;
   $126 = tempRet0;
   $127 = _i64Add($118 | 0, $119 | 0, $113 | 0, $114 | 0) | 0;
   $128 = tempRet0;
   $129 = $109 & -1048576;
   _i64Add(0, $126 | 0, $115 | 0, $116 | 0) | 0;
   $130 = tempRet0;
   $131 = _i64Add($124 | 0, $125 | 0, $115 | 0, $116 | 0) | 0;
   if ($130 >>> 0 < 536870912 | ($130 | 0) == 536870912 & $131 >>> 0 < 0) {
    $138 = _bitshift64Shl($131 | 0, $130 | 0, 1) | 0;
    $139 = tempRet0;
    $140 = _bitshift64Lshr($127 | 0, $128 | 0, 31) | 0;
    $144 = _bitshift64Shl($129 | 0, $127 | 0, 1) | 0;
    $149 = $144;
    $151 = tempRet0;
    $156 = $138 | $140 & 1;
    $158 = $139;
    $r_exp$0 = $add + -1022 | 0;
   } else {
    $149 = $129;
    $151 = $127;
    $156 = $131;
    $158 = $130;
    $r_exp$0 = $add + -1021 | 0;
   }
   do if (!$conv12) {
    if (!(($4 | 0) == 0 & ($20 | 0) == 0)) {
     $167 = _llvm_ctlz_i64($4 | 0, $20 | 0, 0) | 0;
     $169 = _bitshift64Shl($4 | 0, $20 | 0, $167 + -11 | 0) | 0;
     $172 = $169;
     $173 = tempRet0;
     $sub2$i200 = 12 - $167 | 0;
     break;
    }
    $155 = (($149 | 0) != 0 | ($151 | 0) != 0) & 1 | $156;
    if (($155 | 0) == 0 & ($158 | 0) == 0) $sub8$i = 63; else {
     $161 = _llvm_ctlz_i64($155 | 0, $158 | 0, 0) | 0;
     if (!$161) ___assert_fail(1104, 1064, 183, 1136); else $sub8$i = $161 + -1 | 0;
    }
    $163 = _bitshift64Shl($155 | 0, $158 | 0, $sub8$i | 0) | 0;
    $165 = _roundpack_sf64($10, $r_exp$0 - $sub8$i | 0, $163, tempRet0, $rm, $pfflags) | 0;
    $317 = tempRet0;
    $318 = $165;
    tempRet0 = $317;
    STACKTOP = sp;
    return $318 | 0;
   } else {
    $172 = $4;
    $173 = $20 | 1048576;
    $sub2$i200 = $conv12;
   } while (0);
   $inc = $sub2$i200 + 1 | 0;
   $174 = _bitshift64Shl($172 | 0, $173 | 0, 9) | 0;
   $175 = tempRet0;
   if (($r_exp$0 | 0) > ($inc | 0)) {
    $190 = $174;
    $191 = 0;
    $193 = $175;
    $194 = 0;
    $242 = $149;
    $243 = $151;
    $254 = $156;
    $255 = $158;
    $c_sign$0 = $6;
    $r_exp$1 = $r_exp$0;
    $r_sign$1 = $10;
    $sub2$i199 = $inc;
   } else {
    $or$cond86 = ($r_exp$0 | 0) != ($inc | 0) | ($158 >>> 0 < $175 >>> 0 | ($158 | 0) == ($175 | 0) & $156 >>> 0 < $174 >>> 0);
    $190 = $or$cond86 ? $156 : $174;
    $191 = $or$cond86 ? $149 : 0;
    $193 = $or$cond86 ? $158 : $175;
    $194 = $or$cond86 ? $151 : 0;
    $242 = $or$cond86 ? 0 : $149;
    $243 = $or$cond86 ? 0 : $151;
    $254 = $or$cond86 ? $174 : $156;
    $255 = $or$cond86 ? $175 : $158;
    $c_sign$0 = $or$cond86 ? $10 : $6;
    $r_exp$1 = $or$cond86 ? $inc : $r_exp$0;
    $r_sign$1 = $or$cond86 ? $6 : $10;
    $sub2$i199 = $or$cond86 ? $r_exp$0 : $inc;
   }
   $sub151 = $r_exp$1 - $sub2$i199 | 0;
   do if (($sub151 | 0) > 127) {
    $240 = (($191 | $190 | 0) != 0 | ($194 | $193 | 0) != 0) & 1;
    $241 = 0;
    $252 = 0;
    $253 = 0;
   } else if (($sub151 | 0) > 64) {
    $sub163 = $sub151 + -64 | 0;
    if (!$sub163) {
     $240 = $190;
     $241 = $193;
     $252 = 0;
     $253 = 0;
     break;
    }
    if (($sub163 | 0) > 63) {
     $240 = (($190 | 0) != 0 | ($193 | 0) != 0) & 1;
     $241 = 0;
     $252 = 0;
     $253 = 0;
     break;
    } else {
     $203 = _bitshift64Shl(1, 0, $sub163 | 0) | 0;
     $205 = _i64Add($203 | 0, tempRet0 | 0, -1, -1) | 0;
     $206 = tempRet0;
     $207 = _bitshift64Lshr($190 | 0, $193 | 0, $sub163 | 0) | 0;
     $240 = (($205 & $190 | 0) != 0 | ($206 & $193 | 0) != 0) & 1 | $207;
     $241 = tempRet0;
     $252 = 0;
     $253 = 0;
     break;
    }
   } else {
    if (($sub151 | 0) == 64) {
     $240 = (($191 | 0) != 0 | ($194 | 0) != 0) & 1 | $190;
     $241 = $193;
     $252 = 0;
     $253 = 0;
     break;
    }
    if (($r_exp$1 | 0) == ($sub2$i199 | 0)) {
     $240 = $191;
     $241 = $194;
     $252 = $190;
     $253 = $193;
     break;
    }
    $221 = _bitshift64Shl(1, 0, $sub151 | 0) | 0;
    $223 = _i64Add($221 | 0, tempRet0 | 0, -1, -1) | 0;
    $224 = tempRet0;
    $225 = _bitshift64Shl($190 | 0, $193 | 0, 64 - $sub151 | 0) | 0;
    $226 = tempRet0;
    $227 = _bitshift64Lshr($191 | 0, $194 | 0, $sub151 | 0) | 0;
    $230 = $226 | tempRet0;
    $238 = _bitshift64Lshr($190 | 0, $193 | 0, $sub151 | 0) | 0;
    $240 = $225 | $227 | (($223 & $191 | 0) != 0 | ($224 & $194 | 0) != 0) & 1;
    $241 = $230;
    $252 = $238;
    $253 = tempRet0;
    break;
   } while (0);
   if (($r_sign$1 | 0) == ($c_sign$0 | 0)) {
    $244 = _i64Add($240 | 0, $241 | 0, $242 | 0, $243 | 0) | 0;
    $245 = tempRet0;
    $256 = _i64Add($252 | 0, $253 | 0, $254 | 0, $255 | 0) | 0;
    $258 = _i64Add($256 | 0, tempRet0 | 0, ($245 >>> 0 < $241 >>> 0 | ($245 | 0) == ($241 | 0) & $244 >>> 0 < $240 >>> 0) & 1 | 0, 0) | 0;
    $279 = $258;
    $281 = tempRet0;
    $284 = $244;
    $286 = $245;
    $r_sign$2 = $r_sign$1;
   } else {
    $260 = _i64Subtract($242 | 0, $243 | 0, $240 | 0, $241 | 0) | 0;
    $261 = tempRet0;
    $262 = _i64Subtract($254 | 0, $255 | 0, $252 | 0, $253 | 0) | 0;
    $269 = ($261 >>> 0 > $243 >>> 0 | ($261 | 0) == ($243 | 0) & $260 >>> 0 > $242 >>> 0) << 31 >> 31;
    $272 = _i64Add($269 | 0, (($269 | 0) < 0) << 31 >> 31 | 0, $262 | 0, tempRet0 | 0) | 0;
    $273 = tempRet0;
    if (($272 | $260 | 0) == 0 & ($273 | $261 | 0) == 0) {
     $279 = $272;
     $281 = $273;
     $284 = $260;
     $286 = $261;
     $r_sign$2 = ($rm | 0) == 2 & 1;
    } else {
     $279 = $272;
     $281 = $273;
     $284 = $260;
     $286 = $261;
     $r_sign$2 = $r_sign$1;
    }
   }
   do if (($279 | 0) == 0 & ($281 | 0) == 0) if (($284 | 0) == 0 & ($286 | 0) == 0) {
    $l$0263136$i = 128;
    $sub33335$i = $r_exp$1 + -127 | 0;
    label = 70;
    break;
   } else {
    $289 = _llvm_ctlz_i64($284 | 0, $286 | 0, 0) | 0;
    $l$0$i = $289 + 64 | 0;
    label = 64;
    break;
   } else {
    $291 = _llvm_ctlz_i64($279 | 0, $281 | 0, 0) | 0;
    $l$0$i = $291;
    label = 64;
   } while (0);
   do if ((label | 0) == 64) {
    $sub$i = $l$0$i + -1 | 0;
    if (($l$0$i | 0) <= 0) ___assert_fail(1104, 1064, 201, 1120);
    $sub3$i = $r_exp$1 - $sub$i | 0;
    if (!$sub$i) {
     $313 = (($284 | 0) != 0 | ($286 | 0) != 0) & 1 | $279;
     $314 = $281;
     $sub332$i = $sub3$i;
     break;
    }
    if (($l$0$i | 0) < 65) {
     $298 = _bitshift64Shl($279 | 0, $281 | 0, $sub$i | 0) | 0;
     $299 = tempRet0;
     $300 = _bitshift64Lshr($284 | 0, $286 | 0, 65 - $l$0$i | 0) | 0;
     $303 = $299 | tempRet0;
     $304 = _bitshift64Shl($284 | 0, $286 | 0, $sub$i | 0) | 0;
     $313 = $298 | $300 | (($304 | 0) != 0 | (tempRet0 | 0) != 0) & 1;
     $314 = $303;
     $sub332$i = $sub3$i;
    } else {
     $l$0263136$i = $l$0$i;
     $sub33335$i = $sub3$i;
     label = 70;
    }
   } while (0);
   if ((label | 0) == 70) {
    $311 = _bitshift64Shl($284 | 0, $286 | 0, $l$0263136$i + -65 | 0) | 0;
    $313 = $311;
    $314 = tempRet0;
    $sub332$i = $sub33335$i;
   }
   $315 = _roundpack_sf64($r_sign$2, $sub332$i, $313, $314, $rm, $pfflags) | 0;
   $317 = tempRet0;
   $318 = $315;
   tempRet0 = $317;
   STACKTOP = sp;
   return $318 | 0;
  } while (0);
  if (!(($conv12 | 0) == 0 & (($4 | 0) == 0 & ($20 | 0) == 0))) {
   $317 = $5;
   $318 = $4;
   tempRet0 = $317;
   STACKTOP = sp;
   return $318 | 0;
  }
  if (($6 | 0) == ($10 | 0)) $r_sign$0 = $6; else $r_sign$0 = ($rm | 0) == 2 & 1;
  $88 = _bitshift64Shl($r_sign$0 | 0, 0, 63) | 0;
  $317 = tempRet0;
  $318 = $88;
  tempRet0 = $317;
  STACKTOP = sp;
  return $318 | 0;
 }
 $27 = ($0 | 0) != 0 | ($18 | 0) != 0;
 if (!(0 == 0 & ($1 & 2146435072 | 0) == 2146435072 & $27)) if (!(0 == 0 & ($3 & 2146435072 | 0) == 2146435072 & (($2 | 0) != 0 | ($19 | 0) != 0))) if (!(0 == 0 & ($5 & 2146435072 | 0) == 2146435072 & (($4 | 0) != 0 | ($20 | 0) != 0))) {
  if ($cmp) {
   if (!(($conv9 | 0) == 0 & (($2 | 0) == 0 & ($19 | 0) == 0))) label = 12;
  } else label = 12;
  do if ((label | 0) == 12) {
   $cmp46 = ($conv9 | 0) == 2047;
   if ($cmp46) if (($conv6 | 0) == 0 & (($0 | 0) == 0 & ($18 | 0) == 0)) break; else label = 15; else if ($cmp | $cmp46) label = 15;
   if ((label | 0) == 15) if (!(($conv12 | 0) != 2047 | ($10 | 0) == ($6 | 0))) break;
   if (($conv12 | 0) == 2047) {
    $68 = _bitshift64Shl($6 | 0, $7 | 0, 63) | 0;
    $317 = tempRet0 | 2146435072;
    $318 = $68;
    tempRet0 = $317;
    STACKTOP = sp;
    return $318 | 0;
   } else {
    $71 = _bitshift64Shl($10 | 0, $11 | 0, 63) | 0;
    $317 = tempRet0 | 2146435072;
    $318 = $71;
    tempRet0 = $317;
    STACKTOP = sp;
    return $318 | 0;
   }
  } while (0);
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $317 = 2146959360;
  $318 = 0;
  tempRet0 = $317;
  STACKTOP = sp;
  return $318 | 0;
 }
 if (!(0 == 0 & ($1 & 2146959360 | 0) == 2146435072 & $27)) if (!(0 == 0 & ($3 & 2146959360 | 0) == 2146435072 & (($2 | 0) != 0 | ($19 | 0) != 0))) if (!(0 == 0 & ($5 & 2146959360 | 0) == 2146435072 & (($4 | 0) != 0 | ($20 | 0) != 0))) {
  $317 = 2146959360;
  $318 = 0;
  tempRet0 = $317;
  STACKTOP = sp;
  return $318 | 0;
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $317 = 2146959360;
 $318 = 0;
 tempRet0 = $317;
 STACKTOP = sp;
 return $318 | 0;
}
function _ide_mmio_write_u32($s, $offset, $val) {
 $s = $s | 0;
 $offset = $offset | 0;
 $val = $val | 0;
 var $$$conv$i$i$i = 0, $$$conv$i96$i$i = 0, $$conv$i$i$i = 0, $$conv$i93$i$i = 0, $0 = 0, $10 = 0, $11 = 0, $14 = 0, $15 = 0, $18 = 0, $19 = 0, $20 = 0, $21 = 0, $22 = 0, $24 = 0, $27 = 0, $29 = 0, $38 = 0, $4 = 0, $42 = 0, $43 = 0, $47 = 0, $5 = 0, $51 = 0, $52 = 0, $58 = 0, $59 = 0, $6 = 0, $61 = 0, $66 = 0, $69 = 0, $74 = 0, $76 = 0, $77 = 0, $79 = 0, $8 = 0, $add4$i = 0, $and4 = 0, $arraydecay$i$i$i = 0, $cmd$i = 0, $conv$i$i$i = 0, $conv$i$i15 = 0, $cur_drive$i = 0, $cylinders$i$i$i = 0, $data_index$i = 0, $heads$i$i$i = 0, $i$03$i$i$i$i = 0, $mul$i72$i$i = 0, $mul26$i$i$i = 0, $s$idx$val = 0, $s$idx$val$i$i = 0, $s$idx35$val$i$i = 0, $s$idx36$val$i$i = 0, $s$idx37$val$i$i = 0, $s$idx38$val$i$i = 0, $s$idx39$val$i$i = 0, $s$idx40$val$i$i = 0, $sectors$i$i$i = 0, $select$i$1$i = 0, $select$i$i = 0, $select$i$i$i = 0, $shr = 0, $src$addr$01$i$i$i$i = 0, $str$addr$02$i$i$i$i = 0, $tobool$i$i$i$i = 0, $tobool2$i = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $shr = $offset >>> 2;
 if (($shr | 0) == 8) {
  $cmd$i = $s + 20 | 0;
  $tobool2$i = ($val & 4 | 0) == 0;
  if (!(HEAP8[$cmd$i >> 0] & 4)) {
   if (!$tobool2$i) {
    $4 = HEAP32[$s + 12 >> 2] | 0;
    if ($4) {
     HEAP8[$4 + 40 >> 0] = -112;
     HEAP8[$4 + 33 >> 0] = 1;
    }
    $5 = HEAP32[$s + 16 >> 2] | 0;
    if ($5) {
     HEAP8[$5 + 40 >> 0] = -112;
     HEAP8[$5 + 33 >> 0] = 1;
    }
   }
  } else if ($tobool2$i) {
   $6 = HEAP32[$s + 12 >> 2] | 0;
   if ($6) {
    HEAP8[$6 + 40 >> 0] = 80;
    $select$i$i = $6 + 39 | 0;
    HEAP8[$select$i$i >> 0] = (HEAPU8[$select$i$i >> 0] | 0) & 240;
    HEAP16[$6 + 34 >> 1] = 1;
    HEAP8[$6 + 36 >> 0] = 1;
    HEAP8[$6 + 37 >> 0] = 0;
    HEAP8[$6 + 38 >> 0] = 0;
   }
   $8 = HEAP32[$s + 16 >> 2] | 0;
   if ($8) {
    HEAP8[$8 + 40 >> 0] = 80;
    $select$i$1$i = $8 + 39 | 0;
    HEAP8[$select$i$1$i >> 0] = (HEAPU8[$select$i$1$i >> 0] | 0) & 240;
    HEAP16[$8 + 34 >> 1] = 1;
    HEAP8[$8 + 36 >> 0] = 1;
    HEAP8[$8 + 37 >> 0] = 0;
    HEAP8[$8 + 38 >> 0] = 0;
   }
  }
  HEAP8[$cmd$i >> 0] = $val;
  STACKTOP = sp;
  return;
 } else if (!$shr) {
  $s$idx$val = HEAP32[$s + 8 >> 2] | 0;
  if (!$s$idx$val) {
   STACKTOP = sp;
   return;
  }
  $data_index$i = $s$idx$val + 56 | 0;
  $0 = HEAP32[$data_index$i >> 2] | 0;
  HEAP8[$s$idx$val + $0 + 64 >> 0] = $val;
  HEAP8[$s$idx$val + ($0 + 1) + 64 >> 0] = $val >>> 8;
  $add4$i = $0 + 2 | 0;
  HEAP32[$data_index$i >> 2] = $add4$i;
  if (($add4$i | 0) < (HEAP32[$s$idx$val + 60 >> 2] | 0)) {
   STACKTOP = sp;
   return;
  }
  FUNCTION_TABLE_vi[HEAP32[$s$idx$val + 52 >> 2] & 15]($s$idx$val);
  STACKTOP = sp;
  return;
 } else {
  $and4 = $val & 255;
  $cur_drive$i = $s + 8 | 0;
  $10 = HEAP32[$cur_drive$i >> 2] | 0;
  switch ($shr & 7 | 0) {
  case 1:
   {
    if (!$10) {
     STACKTOP = sp;
     return;
    }
    HEAP8[$10 + 32 >> 0] = $val;
    STACKTOP = sp;
    return;
   }
  case 4:
   {
    if (!$10) {
     STACKTOP = sp;
     return;
    }
    HEAP8[$10 + 37 >> 0] = $val;
    STACKTOP = sp;
    return;
   }
  case 2:
   {
    if (!$10) {
     STACKTOP = sp;
     return;
    }
    HEAP16[$10 + 34 >> 1] = $and4;
    STACKTOP = sp;
    return;
   }
  case 3:
   {
    if (!$10) {
     STACKTOP = sp;
     return;
    }
    HEAP8[$10 + 36 >> 0] = $val;
    STACKTOP = sp;
    return;
   }
  case 6:
   {
    $11 = HEAP32[$s + (($val >>> 4 & 1) << 2) + 12 >> 2] | 0;
    HEAP32[$cur_drive$i >> 2] = $11;
    if (!$11) {
     STACKTOP = sp;
     return;
    }
    HEAP8[$11 + 39 >> 0] = $val;
    STACKTOP = sp;
    return;
   }
  case 5:
   {
    if (!$10) {
     STACKTOP = sp;
     return;
    }
    HEAP8[$10 + 38 >> 0] = $val;
    STACKTOP = sp;
    return;
   }
  case 0:
   {
    STACKTOP = sp;
    return;
   }
  default:
   {
    if (!$10) {
     STACKTOP = sp;
     return;
    }
    switch ($and4 | 0) {
    case 49:
    case 48:
     {
      HEAP32[$10 + 48 >> 2] = 1;
      $42 = HEAP16[$10 + 34 >> 1] | 0;
      $$conv$i93$i$i = $42 << 16 >> 16 == 0 ? 256 : $42 & 65535;
      $$$conv$i96$i$i = $$conv$i93$i$i >>> 0 > 1 ? 1 : $$conv$i93$i$i;
      HEAP32[$10 + 44 >> 2] = $$$conv$i96$i$i;
      HEAP32[$10 + 52 >> 2] = 5;
      HEAP32[$10 + 56 >> 2] = 0;
      HEAP32[$10 + 60 >> 2] = $$$conv$i96$i$i << 9;
      HEAP8[$10 + 40 >> 0] = 88;
      STACKTOP = sp;
      return;
     }
    case 196:
     {
      $43 = HEAP32[$10 + 20 >> 2] | 0;
      if ($43) {
       HEAP32[$10 + 48 >> 2] = $43;
       _ide_sector_read($10);
       STACKTOP = sp;
       return;
      }
      HEAP8[$10 + 40 >> 0] = 65;
      HEAP8[$10 + 33 >> 0] = 4;
      $s$idx37$val$i$i = HEAP32[$10 >> 2] | 0;
      if (HEAP8[$s$idx37$val$i$i + 20 >> 0] & 2) {
       STACKTOP = sp;
       return;
      }
      FUNCTION_TABLE_vii[HEAP32[$s$idx37$val$i$i + 4 >> 2] & 1](HEAP32[$s$idx37$val$i$i >> 2] | 0, 1);
      STACKTOP = sp;
      return;
     }
    case 16:
    case 145:
     {
      HEAP8[$10 + 33 >> 0] = 0;
      HEAP8[$10 + 40 >> 0] = 80;
      $s$idx39$val$i$i = HEAP32[$10 >> 2] | 0;
      if (HEAP8[$s$idx39$val$i$i + 20 >> 0] & 2) {
       STACKTOP = sp;
       return;
      }
      FUNCTION_TABLE_vii[HEAP32[$s$idx39$val$i$i + 4 >> 2] & 1](HEAP32[$s$idx39$val$i$i >> 2] | 0, 1);
      STACKTOP = sp;
      return;
     }
    case 248:
     {
      $52 = $10 + 24 | 0;
      $58 = _i64Add(HEAP32[$52 >> 2] | 0, HEAP32[$52 + 4 >> 2] | 0, -1, -1) | 0;
      $59 = tempRet0;
      $select$i$i$i = $10 + 39 | 0;
      $conv$i$i$i = HEAPU8[$select$i$i$i >> 0] | 0;
      if (!($conv$i$i$i & 64)) {
       $74 = HEAP32[$10 + 16 >> 2] | 0;
       $mul$i72$i$i = Math_imul($74, HEAP32[$10 + 12 >> 2] | 0) | 0;
       $76 = (($mul$i72$i$i | 0) < 0) << 31 >> 31;
       $77 = ___divdi3($58 | 0, $59 | 0, $mul$i72$i$i | 0, $76 | 0) | 0;
       $79 = ___remdi3($58 | 0, $59 | 0, $mul$i72$i$i | 0, $76 | 0) | 0;
       HEAP8[$10 + 38 >> 0] = $77 >>> 8;
       HEAP8[$10 + 37 >> 0] = $77;
       HEAP8[$select$i$i$i >> 0] = (($79 >>> 0) / ($74 >>> 0) | 0) & 15 | $conv$i$i$i & 240;
       HEAP8[$10 + 36 >> 0] = (($79 >>> 0) % ($74 >>> 0) | 0) + 1;
      } else {
       $61 = _bitshift64Lshr($58 | 0, $59 | 0, 24) | 0;
       HEAP8[$select$i$i$i >> 0] = $conv$i$i$i & 240 | $61 & 15;
       $66 = _bitshift64Lshr($58 | 0, $59 | 0, 16) | 0;
       HEAP8[$10 + 38 >> 0] = $66;
       $69 = _bitshift64Lshr($58 | 0, $59 | 0, 8) | 0;
       HEAP8[$10 + 37 >> 0] = $69;
       HEAP8[$10 + 36 >> 0] = $58;
      }
      HEAP8[$10 + 40 >> 0] = 64;
      $s$idx35$val$i$i = HEAP32[$10 >> 2] | 0;
      if (HEAP8[$s$idx35$val$i$i + 20 >> 0] & 2) {
       STACKTOP = sp;
       return;
      }
      FUNCTION_TABLE_vii[HEAP32[$s$idx35$val$i$i + 4 >> 2] & 1](HEAP32[$s$idx35$val$i$i >> 2] | 0, 1);
      STACKTOP = sp;
      return;
     }
    case 197:
     {
      $47 = HEAP32[$10 + 20 >> 2] | 0;
      if ($47) {
       HEAP32[$10 + 48 >> 2] = $47;
       $51 = HEAP16[$10 + 34 >> 1] | 0;
       $$conv$i$i$i = $51 << 16 >> 16 == 0 ? 256 : $51 & 65535;
       $$$conv$i$i$i = ($$conv$i$i$i | 0) > ($47 | 0) ? $47 : $$conv$i$i$i;
       HEAP32[$10 + 44 >> 2] = $$$conv$i$i$i;
       HEAP32[$10 + 52 >> 2] = 5;
       HEAP32[$10 + 56 >> 2] = 0;
       HEAP32[$10 + 60 >> 2] = $$$conv$i$i$i << 9;
       HEAP8[$10 + 40 >> 0] = 88;
       STACKTOP = sp;
       return;
      }
      HEAP8[$10 + 40 >> 0] = 65;
      HEAP8[$10 + 33 >> 0] = 4;
      $s$idx36$val$i$i = HEAP32[$10 >> 2] | 0;
      if (HEAP8[$s$idx36$val$i$i + 20 >> 0] & 2) {
       STACKTOP = sp;
       return;
      }
      FUNCTION_TABLE_vii[HEAP32[$s$idx36$val$i$i + 4 >> 2] & 1](HEAP32[$s$idx36$val$i$i >> 2] | 0, 1);
      STACKTOP = sp;
      return;
     }
    case 236:
    case 161:
     {
      $arraydecay$i$i$i = $10 + 64 | 0;
      _memset($arraydecay$i$i$i | 0, 0, 1024) | 0;
      HEAP16[$arraydecay$i$i$i >> 1] = 64;
      $cylinders$i$i$i = $10 + 8 | 0;
      HEAP16[$10 + 66 >> 1] = HEAP32[$cylinders$i$i$i >> 2];
      $heads$i$i$i = $10 + 12 | 0;
      HEAP16[$10 + 70 >> 1] = HEAP32[$heads$i$i$i >> 2];
      $sectors$i$i$i = $10 + 16 | 0;
      $14 = HEAP32[$sectors$i$i$i >> 2] | 0;
      HEAP16[$10 + 72 >> 1] = $14 << 9;
      HEAP16[$10 + 74 >> 1] = 512;
      HEAP16[$10 + 76 >> 1] = $14;
      HEAP16[$10 + 104 >> 1] = 3;
      HEAP16[$10 + 106 >> 1] = 512;
      HEAP16[$10 + 108 >> 1] = 4;
      $i$03$i$i$i$i = 0;
      $src$addr$01$i$i$i$i = 1184;
      $str$addr$02$i$i$i$i = $10 + 118 | 0;
      while (1) {
       $15 = HEAP8[$src$addr$01$i$i$i$i >> 0] | 0;
       $tobool$i$i$i$i = $15 << 24 >> 24 == 0;
       HEAP8[($str$addr$02$i$i$i$i ^ 1) >> 0] = $tobool$i$i$i$i ? 32 : $15;
       $i$03$i$i$i$i = $i$03$i$i$i$i + 1 | 0;
       if (($i$03$i$i$i$i | 0) == 40) break; else {
        $src$addr$01$i$i$i$i = $tobool$i$i$i$i ? $src$addr$01$i$i$i$i : $src$addr$01$i$i$i$i + 1 | 0;
        $str$addr$02$i$i$i$i = $str$addr$02$i$i$i$i + 1 | 0;
       }
      }
      HEAP16[$10 + 158 >> 1] = -32640;
      HEAP16[$10 + 160 >> 1] = 0;
      HEAP16[$10 + 162 >> 1] = 512;
      HEAP16[$10 + 166 >> 1] = 512;
      HEAP16[$10 + 168 >> 1] = 512;
      $18 = HEAP32[$cylinders$i$i$i >> 2] | 0;
      HEAP16[$10 + 172 >> 1] = $18;
      $19 = HEAP32[$heads$i$i$i >> 2] | 0;
      HEAP16[$10 + 174 >> 1] = $19;
      $20 = HEAP32[$sectors$i$i$i >> 2] | 0;
      HEAP16[$10 + 176 >> 1] = $20;
      $mul26$i$i$i = Math_imul(Math_imul($19, $18) | 0, $20) | 0;
      HEAP16[$10 + 178 >> 1] = $mul26$i$i$i;
      HEAP16[$10 + 180 >> 1] = $mul26$i$i$i >>> 16;
      $21 = HEAP32[$10 + 20 >> 2] | 0;
      if ($21) HEAP16[$10 + 182 >> 1] = $21 | 256;
      $22 = $10 + 24 | 0;
      $24 = HEAP32[$22 >> 2] | 0;
      $27 = HEAP32[$22 + 4 >> 2] | 0;
      HEAP16[$10 + 184 >> 1] = $24;
      $29 = _bitshift64Lshr($24 | 0, $27 | 0, 16) | 0;
      HEAP16[$10 + 186 >> 1] = $29;
      HEAP16[$10 + 224 >> 1] = 6;
      HEAP16[$10 + 228 >> 1] = 16384;
      HEAP16[$10 + 230 >> 1] = 16384;
      HEAP16[$10 + 232 >> 1] = 16384;
      HEAP16[$10 + 234 >> 1] = 16384;
      HEAP16[$10 + 236 >> 1] = 0;
      HEAP16[$10 + 238 >> 1] = 16384;
      HEAP8[$10 + 40 >> 0] = 88;
      HEAP32[$10 + 52 >> 2] = 4;
      HEAP32[$10 + 56 >> 2] = 0;
      HEAP32[$10 + 60 >> 2] = 512;
      $s$idx40$val$i$i = HEAP32[$10 >> 2] | 0;
      if (HEAP8[$s$idx40$val$i$i + 20 >> 0] & 2) {
       STACKTOP = sp;
       return;
      }
      FUNCTION_TABLE_vii[HEAP32[$s$idx40$val$i$i + 4 >> 2] & 1](HEAP32[$s$idx40$val$i$i >> 2] | 0, 1);
      STACKTOP = sp;
      return;
     }
    case 33:
    case 32:
     {
      HEAP32[$10 + 48 >> 2] = 1;
      _ide_sector_read($10);
      STACKTOP = sp;
      return;
     }
    case 198:
     {
      $38 = HEAP16[$10 + 34 >> 1] | 0;
      $conv$i$i15 = $38 & 65535;
      if (($38 & 65535) > 128) label = 42; else if (!($conv$i$i15 + 65535 & $conv$i$i15)) {
       HEAP32[$10 + 20 >> 2] = $conv$i$i15;
       HEAP8[$10 + 40 >> 0] = 64;
      } else label = 42;
      if ((label | 0) == 42) {
       HEAP8[$10 + 40 >> 0] = 65;
       HEAP8[$10 + 33 >> 0] = 4;
      }
      $s$idx38$val$i$i = HEAP32[$10 >> 2] | 0;
      if (HEAP8[$s$idx38$val$i$i + 20 >> 0] & 2) {
       STACKTOP = sp;
       return;
      }
      FUNCTION_TABLE_vii[HEAP32[$s$idx38$val$i$i + 4 >> 2] & 1](HEAP32[$s$idx38$val$i$i >> 2] | 0, 1);
      STACKTOP = sp;
      return;
     }
    default:
     {
      HEAP8[$10 + 40 >> 0] = 65;
      HEAP8[$10 + 33 >> 0] = 4;
      $s$idx$val$i$i = HEAP32[$10 >> 2] | 0;
      if (HEAP8[$s$idx$val$i$i + 20 >> 0] & 2) {
       STACKTOP = sp;
       return;
      }
      FUNCTION_TABLE_vii[HEAP32[$s$idx$val$i$i + 4 >> 2] & 1](HEAP32[$s$idx$val$i$i >> 2] | 0, 1);
      STACKTOP = sp;
      return;
     }
    }
   }
  }
 }
}
function _get_phys_addr($s, $ppaddr, $0, $1, $access) {
 $s = $s | 0;
 $ppaddr = $ppaddr | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $access = $access | 0;
 var $104 = 0, $105 = 0, $106 = 0, $107 = 0, $108 = 0, $110 = 0, $113 = 0, $119 = 0, $12 = 0, $125 = 0, $126 = 0, $133 = 0, $134 = 0, $135 = 0, $137 = 0, $139 = 0, $142 = 0, $147 = 0, $15 = 0, $151 = 0, $156 = 0, $159 = 0, $17 = 0, $181 = 0, $182 = 0, $183 = 0, $184 = 0, $185 = 0, $186 = 0, $188 = 0, $19 = 0, $191 = 0, $193 = 0, $196 = 0, $199 = 0, $2 = 0, $205 = 0, $206 = 0, $213 = 0, $214 = 0, $215 = 0, $217 = 0, $219 = 0, $222 = 0, $228 = 0, $23 = 0, $234 = 0, $235 = 0, $242 = 0, $243 = 0, $244 = 0, $246 = 0, $25 = 0, $250 = 0, $251 = 0, $252 = 0, $253 = 0, $256 = 0, $257 = 0, $260 = 0, $262 = 0, $265 = 0, $269 = 0, $28 = 0, $29 = 0, $31 = 0, $36 = 0, $38 = 0, $4 = 0, $43 = 0, $49 = 0, $50 = 0, $51 = 0, $52 = 0, $57 = 0, $58 = 0, $59 = 0, $60 = 0, $61 = 0, $63 = 0, $66 = 0, $7 = 0, $72 = 0, $78 = 0, $79 = 0, $86 = 0, $87 = 0, $88 = 0, $90 = 0, $95 = 0, $99 = 0, $add = 0, $add44 = 0, $add44$us = 0, $cmp111 = 0, $cmp114128 = 0, $cmp53 = 0, $cmp8$i$i = 0, $conv21 = 0, $conv68 = 0, $conv68$lcssa = 0, $conv68$us = 0, $i$0149 = 0, $i$0149$us = 0, $i$09$i$i$us = 0, $i$09$i$i103 = 0, $i$09$i$i57 = 0, $i$09$i$i80 = 0, $inc$i$i$us = 0, $inc$i$i111 = 0, $inc$i$i65 = 0, $inc$i$i88 = 0, $levels$0191 = 0, $phys_mem$i = 0, $priv$0 = 0, $pte_size_log2$0190 = 0, $retval$0 = 0, $shl50 = 0, $shl50$us = 0, $shr66$tr$lcssa = 0, $shr66$us = 0, $sub26 = 0, $sub35192 = 0, $sub38 = 0, $sub41 = 0, $xwr$0 = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $2 = $s + 552 | 0;
 $4 = HEAP32[$2 >> 2] | 0;
 $7 = HEAP32[$2 + 4 >> 2] | 0;
 if (($4 & 131072 | 0) == 0 & 0 == 0 | ($access | 0) == 2) $priv$0 = HEAPU8[$s + 526 >> 0] | 0; else {
  $12 = _bitshift64Lshr($4 | 0, $7 | 0, 11) | 0;
  $priv$0 = $12 & 3;
 }
 if (($priv$0 | 0) == 3) {
  $15 = HEAP8[$s + 525 >> 0] | 0;
  if (($15 & 255) < 64) {
   $17 = _bitshift64Shl(1, 0, $15 & 255 | 0) | 0;
   $19 = _i64Add($17 | 0, tempRet0 | 0, -1, -1) | 0;
   $25 = $19 & $0;
   $28 = tempRet0 & $1;
  } else {
   $25 = $0;
   $28 = $1;
  }
  $23 = $ppaddr;
  HEAP32[$23 >> 2] = $25;
  HEAP32[$23 + 4 >> 2] = $28;
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 $29 = _bitshift64Lshr($4 | 0, $7 | 0, 24) | 0;
 $conv21 = $29 & 31;
 if (($conv21 | 0) == 8) {
  $levels$0191 = 2;
  $pte_size_log2$0190 = 2;
  $sub35192 = 10;
 } else if (($conv21 | 0) == 9 | ($conv21 | 0) == 10) {
  $add = $conv21 + -6 | 0;
  $sub26 = (Math_imul($add, -9) | 0) + 52 | 0;
  $36 = _bitshift64Shl($0 | 0, $1 | 0, $sub26 | 0) | 0;
  $38 = _bitshift64Ashr($36 | 0, tempRet0 | 0, $sub26 | 0) | 0;
  if (($38 | 0) == ($0 | 0) & (tempRet0 | 0) == ($1 | 0) & ($add | 0) > 0) {
   $levels$0191 = $add;
   $pte_size_log2$0190 = 3;
   $sub35192 = 9;
  } else {
   $retval$0 = -1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 } else {
  $31 = $ppaddr;
  HEAP32[$31 >> 2] = $0;
  HEAP32[$31 + 4 >> 2] = $1;
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 $43 = $s + 688 | 0;
 $49 = _bitshift64Shl(HEAP32[$43 >> 2] | 0, HEAP32[$43 + 4 >> 2] | 0, 12) | 0;
 $50 = tempRet0;
 $sub38 = (1 << $sub35192) + -1 | 0;
 $sub41 = $levels$0191 + -1 | 0;
 $cmp53 = ($pte_size_log2$0190 | 0) == 2;
 $51 = HEAP32[$s + 744 >> 2] | 0;
 $cmp8$i$i = ($51 | 0) > 0;
 $phys_mem$i = $s + 728 | 0;
 L18 : do if ($cmp53) {
  $57 = $49;
  $58 = $50;
  $i$0149$us = 0;
  L19 : while (1) {
   $add44$us = (Math_imul($sub41 - $i$0149$us | 0, $sub35192) | 0) + 12 | 0;
   $52 = _bitshift64Lshr($0 | 0, $1 | 0, $add44$us | 0) | 0;
   $shl50$us = ($52 & $sub38) << 2;
   $59 = _i64Add($shl50$us | 0, (($shl50$us | 0) < 0) << 31 >> 31 | 0, $57 | 0, $58 | 0) | 0;
   $60 = tempRet0;
   if ($cmp8$i$i) $i$09$i$i$us = 0; else {
    $retval$0 = -1;
    label = 53;
    break;
   }
   while (1) {
    $61 = $s + ($i$09$i$i$us * 40 | 0) + 752 | 0;
    $63 = HEAP32[$61 >> 2] | 0;
    $66 = HEAP32[$61 + 4 >> 2] | 0;
    if (!($66 >>> 0 > $60 >>> 0 | ($66 | 0) == ($60 | 0) & $63 >>> 0 > $59 >>> 0)) {
     $72 = $s + ($i$09$i$i$us * 40 | 0) + 760 | 0;
     $78 = _i64Add(HEAP32[$72 >> 2] | 0, HEAP32[$72 + 4 >> 2] | 0, $63 | 0, $66 | 0) | 0;
     $79 = tempRet0;
     if ($79 >>> 0 > $60 >>> 0 | ($79 | 0) == ($60 | 0) & $78 >>> 0 > $59 >>> 0) break;
    }
    $inc$i$i$us = $i$09$i$i$us + 1 | 0;
    if (($inc$i$i$us | 0) < ($51 | 0)) $i$09$i$i$us = $inc$i$i$us; else {
     $retval$0 = -1;
     label = 53;
     break L19;
    }
   }
   if (!(HEAP32[$s + ($i$09$i$i$us * 40 | 0) + 768 >> 2] | 0)) {
    $retval$0 = -1;
    label = 53;
    break;
   }
   $86 = HEAP32[$phys_mem$i >> 2] | 0;
   $87 = HEAP32[$s + ($i$09$i$i$us * 40 | 0) + 772 >> 2] | 0;
   $88 = _i64Subtract($59 | 0, $60 | 0, $63 | 0, $66 | 0) | 0;
   $90 = HEAP32[$86 + ($87 + $88) >> 2] | 0;
   if (($90 & 1 | 0) == 0 & 0 == 0) {
    $retval$0 = -1;
    label = 53;
    break;
   }
   $95 = _bitshift64Lshr($90 | 0, 0, 10) | 0;
   $57 = _bitshift64Shl($95 | 0, tempRet0 | 0, 12) | 0;
   $58 = tempRet0;
   $shr66$us = $90 >>> 1;
   $conv68$us = $shr66$us & 7;
   $i$0149$us = $i$0149$us + 1 | 0;
   if ($conv68$us) {
    $156 = $90;
    $184 = 0;
    $193 = $60;
    $196 = $59;
    $250 = $add44$us;
    $260 = $57;
    $262 = $58;
    $269 = 0;
    $conv68$lcssa = $conv68$us;
    $shr66$tr$lcssa = $shr66$us;
    break L18;
   }
   if (($i$0149$us | 0) >= ($levels$0191 | 0)) {
    $retval$0 = -1;
    label = 53;
    break;
   }
  }
  if ((label | 0) == 53) {
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 } else {
  $104 = $49;
  $105 = $50;
  $i$0149 = 0;
  L36 : while (1) {
   $add44 = (Math_imul($sub41 - $i$0149 | 0, $sub35192) | 0) + 12 | 0;
   $99 = _bitshift64Lshr($0 | 0, $1 | 0, $add44 | 0) | 0;
   $shl50 = ($99 & $sub38) << $pte_size_log2$0190;
   $106 = _i64Add($shl50 | 0, (($shl50 | 0) < 0) << 31 >> 31 | 0, $104 | 0, $105 | 0) | 0;
   $107 = tempRet0;
   if ($cmp8$i$i) $i$09$i$i103 = 0; else {
    $retval$0 = -1;
    label = 53;
    break;
   }
   while (1) {
    $108 = $s + ($i$09$i$i103 * 40 | 0) + 752 | 0;
    $110 = HEAP32[$108 >> 2] | 0;
    $113 = HEAP32[$108 + 4 >> 2] | 0;
    if (!($113 >>> 0 > $107 >>> 0 | ($113 | 0) == ($107 | 0) & $110 >>> 0 > $106 >>> 0)) {
     $119 = $s + ($i$09$i$i103 * 40 | 0) + 760 | 0;
     $125 = _i64Add(HEAP32[$119 >> 2] | 0, HEAP32[$119 + 4 >> 2] | 0, $110 | 0, $113 | 0) | 0;
     $126 = tempRet0;
     if ($126 >>> 0 > $107 >>> 0 | ($126 | 0) == ($107 | 0) & $125 >>> 0 > $106 >>> 0) break;
    }
    $inc$i$i111 = $i$09$i$i103 + 1 | 0;
    if (($inc$i$i111 | 0) < ($51 | 0)) $i$09$i$i103 = $inc$i$i111; else {
     $retval$0 = -1;
     label = 53;
     break L36;
    }
   }
   if (!(HEAP32[$s + ($i$09$i$i103 * 40 | 0) + 768 >> 2] | 0)) {
    $retval$0 = -1;
    label = 53;
    break;
   }
   $133 = HEAP32[$phys_mem$i >> 2] | 0;
   $134 = HEAP32[$s + ($i$09$i$i103 * 40 | 0) + 772 >> 2] | 0;
   $135 = _i64Subtract($106 | 0, $107 | 0, $110 | 0, $113 | 0) | 0;
   $137 = $133 + ($134 + $135) | 0;
   $139 = HEAP32[$137 >> 2] | 0;
   $142 = HEAP32[$137 + 4 >> 2] | 0;
   if (($139 & 1 | 0) == 0 & 0 == 0) {
    $retval$0 = -1;
    label = 53;
    break;
   }
   $147 = _bitshift64Lshr($139 | 0, $142 | 0, 10) | 0;
   $104 = _bitshift64Shl($147 | 0, tempRet0 | 0, 12) | 0;
   $105 = tempRet0;
   $151 = _bitshift64Lshr($139 | 0, $142 | 0, 1) | 0;
   $conv68 = $151 & 7;
   $i$0149 = $i$0149 + 1 | 0;
   if ($conv68) {
    $156 = $139;
    $184 = $142;
    $193 = $107;
    $196 = $106;
    $250 = $add44;
    $260 = $104;
    $262 = $105;
    $269 = 0;
    $conv68$lcssa = $conv68;
    $shr66$tr$lcssa = $151;
    break L18;
   }
   if (($i$0149 | 0) >= ($levels$0191 | 0)) {
    $retval$0 = -1;
    label = 53;
    break;
   }
  }
  if ((label | 0) == 53) {
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 } while (0);
 if (($shr66$tr$lcssa & 3 | 0) == 2) {
  $retval$0 = -1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 $159 = ($156 & 16 | 0) != 0 | 0 != 0;
 if (($priv$0 | 0) == 1) {
  if ($159) if (!(($4 & 262144 | 0) == 0 & 0 == 0)) {
   $retval$0 = -1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 } else if (!$159) {
  $retval$0 = -1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 if (($4 & 524288 | 0) == 0 & 0 == 0) $xwr$0 = $conv68$lcssa; else $xwr$0 = $conv68$lcssa >>> 2 | $conv68$lcssa;
 if (!($xwr$0 & 1 << $access)) {
  $retval$0 = -1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 if (($156 & 64 | 0) == 0 & 0 == 0) {
  $cmp114128 = ($access | 0) == 1;
  $182 = $cmp114128 ? 192 : 64;
  $185 = $cmp114128 ? 0 : 0;
  label = 39;
 } else {
  $cmp111 = ($access | 0) == 1;
  if (($156 & 128 | 0) == 0 & 0 == 0 & $cmp111) {
   $182 = $cmp111 ? 192 : 64;
   $185 = $cmp111 ? 0 : 0;
   label = 39;
  }
 }
 L73 : do if ((label | 0) == 39) {
  $181 = $182 | $156;
  $183 = $185 | $184;
  if ($cmp53) {
   if ($cmp8$i$i) $i$09$i$i80 = 0; else break;
   while (1) {
    $186 = $s + ($i$09$i$i80 * 40 | 0) + 752 | 0;
    $188 = HEAP32[$186 >> 2] | 0;
    $191 = HEAP32[$186 + 4 >> 2] | 0;
    if (!($191 >>> 0 > $193 >>> 0 | ($191 | 0) == ($193 | 0) & $188 >>> 0 > $196 >>> 0)) {
     $199 = $s + ($i$09$i$i80 * 40 | 0) + 760 | 0;
     $205 = _i64Add(HEAP32[$199 >> 2] | 0, HEAP32[$199 + 4 >> 2] | 0, $188 | 0, $191 | 0) | 0;
     $206 = tempRet0;
     if ($206 >>> 0 > $193 >>> 0 | ($206 | 0) == ($193 | 0) & $205 >>> 0 > $196 >>> 0) break;
    }
    $inc$i$i88 = $i$09$i$i80 + 1 | 0;
    if (($inc$i$i88 | 0) < ($51 | 0)) $i$09$i$i80 = $inc$i$i88; else break L73;
   }
   if (!(HEAP32[$s + ($i$09$i$i80 * 40 | 0) + 768 >> 2] | 0)) break;
   $213 = HEAP32[$phys_mem$i >> 2] | 0;
   $214 = HEAP32[$s + ($i$09$i$i80 * 40 | 0) + 772 >> 2] | 0;
   $215 = _i64Subtract($196 | 0, $193 | 0, $188 | 0, $191 | 0) | 0;
   HEAP32[$213 + ($214 + $215) >> 2] = $181;
   break;
  } else {
   if ($cmp8$i$i) $i$09$i$i57 = 0; else break;
   while (1) {
    $217 = $s + ($i$09$i$i57 * 40 | 0) + 752 | 0;
    $219 = HEAP32[$217 >> 2] | 0;
    $222 = HEAP32[$217 + 4 >> 2] | 0;
    if (!($222 >>> 0 > $193 >>> 0 | ($222 | 0) == ($193 | 0) & $219 >>> 0 > $196 >>> 0)) {
     $228 = $s + ($i$09$i$i57 * 40 | 0) + 760 | 0;
     $234 = _i64Add(HEAP32[$228 >> 2] | 0, HEAP32[$228 + 4 >> 2] | 0, $219 | 0, $222 | 0) | 0;
     $235 = tempRet0;
     if ($235 >>> 0 > $193 >>> 0 | ($235 | 0) == ($193 | 0) & $234 >>> 0 > $196 >>> 0) break;
    }
    $inc$i$i65 = $i$09$i$i57 + 1 | 0;
    if (($inc$i$i65 | 0) < ($51 | 0)) $i$09$i$i57 = $inc$i$i65; else break L73;
   }
   if (!(HEAP32[$s + ($i$09$i$i57 * 40 | 0) + 768 >> 2] | 0)) break;
   $242 = HEAP32[$phys_mem$i >> 2] | 0;
   $243 = HEAP32[$s + ($i$09$i$i57 * 40 | 0) + 772 >> 2] | 0;
   $244 = _i64Subtract($196 | 0, $193 | 0, $219 | 0, $222 | 0) | 0;
   $246 = $242 + ($243 + $244) | 0;
   HEAP32[$246 >> 2] = $181;
   HEAP32[$246 + 4 >> 2] = $183;
   break;
  }
 } while (0);
 $251 = _bitshift64Shl(1, 0, $250 | 0) | 0;
 $252 = tempRet0;
 $253 = _i64Add($251 | 0, $252 | 0, -1, -1) | 0;
 $256 = tempRet0 & $1;
 $257 = _i64Subtract(0, 0, $251 | 0, $252 | 0) | 0;
 $265 = $ppaddr;
 HEAP32[$265 >> 2] = $260 & $257 | $253 & $0;
 HEAP32[$265 + 4 >> 2] = $262 & tempRet0 | $256;
 $retval$0 = 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _csr_write($s, $csr, $0, $1) {
 $s = $s | 0;
 $csr = $csr | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 var $102 = 0, $106 = 0, $11 = 0, $110 = 0, $114 = 0, $116 = 0, $119 = 0, $120 = 0, $133 = 0, $134 = 0, $140 = 0, $145 = 0, $149 = 0, $151 = 0, $155 = 0, $16 = 0, $168 = 0, $17 = 0, $172 = 0, $176 = 0, $18 = 0, $180 = 0, $185 = 0, $192 = 0, $194 = 0, $200 = 0, $201 = 0, $209 = 0, $214 = 0, $218 = 0, $222 = 0, $227 = 0, $231 = 0, $235 = 0, $240 = 0, $244 = 0, $249 = 0, $253 = 0, $258 = 0, $262 = 0, $266 = 0, $270 = 0, $275 = 0, $279 = 0, $284 = 0, $3 = 0, $31 = 0, $35 = 0, $39 = 0, $43 = 0, $48 = 0, $55 = 0, $57 = 0, $6 = 0, $63 = 0, $64 = 0, $68 = 0, $70 = 0, $73 = 0, $74 = 0, $8 = 0, $87 = 0, $88 = 0, $93 = 0, $97 = 0, $conv$i78 = 0, $conv$i98 = 0, $conv3 = 0, $conv41 = 0, $conv44 = 0, $conv6 = 0, $cur_xlen40 = 0, $i$07$i$i$i = 0, $i$07$i$i$i89 = 0, $medeleg = 0, $mideleg60 = 0, $mie = 0, $mie67 = 0, $mip = 0, $mip81 = 0, $mstatus = 0, $mstatus$i = 0, $phitmp$i = 0, $phitmp$i106 = 0, $retval$0 = 0, $shl = 0, label = 0, sp = 0;
 sp = STACKTOP;
 do switch ($csr | 0) {
 case 832:
  {
   $253 = $s + 576 | 0;
   HEAP32[$253 >> 2] = $0;
   HEAP32[$253 + 4 >> 2] = $1;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 835:
  {
   $266 = $s + 600 | 0;
   HEAP32[$266 >> 2] = $0;
   HEAP32[$266 + 4 >> 2] = $1;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 801:
 case 800:
  {
   $284 = $s + (($csr & 3) << 3) + 696 | 0;
   HEAP32[$284 >> 2] = $0 & 7;
   HEAP32[$284 + 4 >> 2] = 0;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 320:
  {
   $97 = $s + 656 | 0;
   HEAP32[$97 >> 2] = $0;
   HEAP32[$97 + 4 >> 2] = $1;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 769:
  {
   $cur_xlen40 = $s + 525 | 0;
   $conv41 = HEAPU8[$cur_xlen40 >> 0] | 0;
   $conv44 = (_bitshift64Lshr($0 | 0, $1 | 0, $conv41 + -2 | 0) | 0) & 3;
   $shl = ($conv44 + -1 | 0) >>> 0 > 1 ? 64 : 1 << ($conv44 | 4);
   if (($conv41 | 0) == ($shl | 0)) {
    $retval$0 = 0;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
   HEAP8[$cur_xlen40 >> 0] = $shl;
   $retval$0 = 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 2:
  {
   $conv3 = $0 & 7;
   HEAP8[$s + 524 >> 0] = $conv3 >>> 0 > 4 ? 0 : $conv3 & 255;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 260:
  {
   $68 = $s + 640 | 0;
   $70 = HEAP32[$68 >> 2] | 0;
   $73 = HEAP32[$68 + 4 >> 2] | 0;
   $mie = $s + 560 | 0;
   $74 = $mie;
   $87 = HEAP32[$74 + 4 >> 2] & ~$73 | $73 & $1;
   $88 = $mie;
   HEAP32[$88 >> 2] = HEAP32[$74 >> 2] & ~$70 | $70 & $0;
   HEAP32[$88 + 4 >> 2] = $87;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 768:
  {
   $mstatus$i = $s + 552 | 0;
   $149 = $mstatus$i;
   $151 = HEAP32[$149 >> 2] | 0;
   $155 = $151 ^ $0;
   HEAP32[$149 + 4 >> 2] ^ $1;
   if (($155 & 521011200 | 0) == 0 & 0 == 0) {
    if (!(($151 & 131072 | 0) == 0 & 0 == 0)) if (!(($155 & 6144 | 0) == 0 & 0 == 0)) {
     $i$07$i$i$i = 0;
     label = 25;
    }
   } else {
    $i$07$i$i$i = 0;
    label = 25;
   }
   if ((label | 0) == 25) while (1) {
    label = 0;
    $168 = $s + ($i$07$i$i$i << 4) + 1400 | 0;
    HEAP32[$168 >> 2] = -1;
    HEAP32[$168 + 4 >> 2] = -1;
    $172 = $s + ($i$07$i$i$i << 4) + 5496 | 0;
    HEAP32[$172 >> 2] = -1;
    HEAP32[$172 + 4 >> 2] = -1;
    $176 = $s + ($i$07$i$i$i << 4) + 9592 | 0;
    HEAP32[$176 >> 2] = -1;
    HEAP32[$176 + 4 >> 2] = -1;
    $i$07$i$i$i = $i$07$i$i$i + 1 | 0;
    if (($i$07$i$i$i | 0) == 256) break; else label = 25;
   }
   $180 = _bitshift64Lshr($0 | 0, $1 | 0, 24) | 0;
   $conv$i78 = $180 & 31;
   if (!$conv$i78) {
    $192 = 521140667;
    $194 = 17476;
   } else {
    $phitmp$i = $conv$i78 >>> 0 < 8 ? 1 : ((HEAP8[$s + 525 >> 0] | 0) == 32 ? 8 : 10) >>> 0 < $conv$i78 >>> 0;
    $192 = $phitmp$i ? 1046971 : 521140667;
    $194 = $phitmp$i ? 17476 : 17476;
   }
   $185 = $mstatus$i;
   $200 = HEAP32[$185 + 4 >> 2] & ~$194 | $194 & $1;
   $201 = $mstatus$i;
   HEAP32[$201 >> 2] = HEAP32[$185 >> 2] & ~$192 | $192 & $0;
   HEAP32[$201 + 4 >> 2] = $200;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 1:
  {
   HEAP32[$s + 520 >> 2] = $0 & 31;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 773:
  {
   $249 = $s + 568 | 0;
   HEAP32[$249 >> 2] = $0 & -4;
   HEAP32[$249 + 4 >> 2] = $1;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 772:
  {
   $mie67 = $s + 560 | 0;
   $235 = $mie67;
   $240 = HEAP32[$235 + 4 >> 2] | 0;
   $244 = $mie67;
   HEAP32[$244 >> 2] = HEAP32[$235 >> 2] & -683 | $0 & 682;
   HEAP32[$244 + 4 >> 2] = $240;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 3:
  {
   $3 = _bitshift64Lshr($0 | 0, $1 | 0, 5) | 0;
   $conv6 = $3 & 7;
   HEAP8[$s + 524 >> 0] = $conv6 >>> 0 > 4 ? 0 : $conv6 & 255;
   HEAP32[$s + 520 >> 2] = $0 & 31;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 834:
  {
   $262 = $s + 592 | 0;
   HEAP32[$262 >> 2] = $0;
   HEAP32[$262 + 4 >> 2] = $1;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 833:
  {
   $258 = $s + 584 | 0;
   HEAP32[$258 >> 2] = $0 & -2;
   HEAP32[$258 + 4 >> 2] = $1;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 771:
  {
   $mideleg60 = $s + 640 | 0;
   $222 = $mideleg60;
   $227 = HEAP32[$222 + 4 >> 2] | 0;
   $231 = $mideleg60;
   HEAP32[$231 >> 2] = HEAP32[$222 >> 2] & -547 | $0 & 546;
   HEAP32[$231 + 4 >> 2] = $227;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 261:
  {
   $93 = $s + 648 | 0;
   HEAP32[$93 >> 2] = $0 & -4;
   HEAP32[$93 + 4 >> 2] = $1;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 322:
  {
   $106 = $s + 672 | 0;
   HEAP32[$106 >> 2] = $0;
   HEAP32[$106 + 4 >> 2] = $1;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 256:
  {
   $mstatus = $s + 552 | 0;
   $6 = $mstatus;
   $8 = HEAP32[$6 >> 2] | 0;
   $11 = HEAP32[$6 + 4 >> 2] | 0;
   $16 = $8 & -385332 | $0 & 385331;
   $17 = $11 & -1029 | $1 & 1028;
   $18 = $16 ^ $8;
   $17 ^ $11;
   if (($18 & 521011200 | 0) == 0 & 0 == 0) {
    if (!(($8 & 131072 | 0) == 0 & 0 == 0)) if (!(($18 & 6144 | 0) == 0 & 0 == 0)) {
     $i$07$i$i$i89 = 0;
     label = 8;
    }
   } else {
    $i$07$i$i$i89 = 0;
    label = 8;
   }
   if ((label | 0) == 8) while (1) {
    label = 0;
    $31 = $s + ($i$07$i$i$i89 << 4) + 1400 | 0;
    HEAP32[$31 >> 2] = -1;
    HEAP32[$31 + 4 >> 2] = -1;
    $35 = $s + ($i$07$i$i$i89 << 4) + 5496 | 0;
    HEAP32[$35 >> 2] = -1;
    HEAP32[$35 + 4 >> 2] = -1;
    $39 = $s + ($i$07$i$i$i89 << 4) + 9592 | 0;
    HEAP32[$39 >> 2] = -1;
    HEAP32[$39 + 4 >> 2] = -1;
    $i$07$i$i$i89 = $i$07$i$i$i89 + 1 | 0;
    if (($i$07$i$i$i89 | 0) == 256) break; else label = 8;
   }
   $43 = _bitshift64Lshr($8 | 0, $11 | 0, 24) | 0;
   $conv$i98 = $43 & 31;
   if (!$conv$i98) {
    $55 = 521140667;
    $57 = 17476;
   } else {
    $phitmp$i106 = $conv$i98 >>> 0 < 8 ? 1 : ((HEAP8[$s + 525 >> 0] | 0) == 32 ? 8 : 10) >>> 0 < $conv$i98 >>> 0;
    $55 = $phitmp$i106 ? 1046971 : 521140667;
    $57 = $phitmp$i106 ? 17476 : 17476;
   }
   $48 = $mstatus;
   $63 = HEAP32[$48 + 4 >> 2] & ~$57 | $57 & $17;
   $64 = $mstatus;
   HEAP32[$64 >> 2] = HEAP32[$48 >> 2] & ~$55 | $55 & $16;
   HEAP32[$64 + 4 >> 2] = $63;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 836:
  {
   $mip81 = $s + 608 | 0;
   $270 = $mip81;
   $275 = HEAP32[$270 + 4 >> 2] | 0;
   $279 = $mip81;
   HEAP32[$279 >> 2] = HEAP32[$270 >> 2] & -35 | $0 & 34;
   HEAP32[$279 + 4 >> 2] = $275;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 321:
  {
   $102 = $s + 664 | 0;
   HEAP32[$102 >> 2] = $0 & -2;
   HEAP32[$102 + 4 >> 2] = $1;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 384:
  {
   if ((HEAP8[$s + 525 >> 0] | 0) == 32) {
    $140 = $s + 688 | 0;
    HEAP32[$140 >> 2] = $0 & 4194303;
    HEAP32[$140 + 4 >> 2] = 0;
    $retval$0 = 0;
    STACKTOP = sp;
    return $retval$0 | 0;
   } else {
    $145 = $s + 688 | 0;
    HEAP32[$145 >> 2] = $0;
    HEAP32[$145 + 4 >> 2] = $1 & 63;
    $retval$0 = 0;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
   break;
  }
 case 324:
  {
   $114 = $s + 640 | 0;
   $116 = HEAP32[$114 >> 2] | 0;
   $119 = HEAP32[$114 + 4 >> 2] | 0;
   $mip = $s + 608 | 0;
   $120 = $mip;
   $133 = HEAP32[$120 + 4 >> 2] & ~$119 | $119 & $1;
   $134 = $mip;
   HEAP32[$134 >> 2] = HEAP32[$120 >> 2] & ~$116 | $116 & $0;
   HEAP32[$134 + 4 >> 2] = $133;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 323:
  {
   $110 = $s + 680 | 0;
   HEAP32[$110 >> 2] = $0;
   HEAP32[$110 + 4 >> 2] = $1;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 case 770:
  {
   $medeleg = $s + 632 | 0;
   $209 = $medeleg;
   $214 = HEAP32[$209 + 4 >> 2] | 0;
   $218 = $medeleg;
   HEAP32[$218 >> 2] = HEAP32[$209 >> 2] & -4096 | $0 & 4095;
   HEAP32[$218 + 4 >> 2] = $214;
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 default:
  {
   $retval$0 = -1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 } while (0);
 return 0;
}
function _target_read_slow($s, $pval, $0, $1, $size_log2) {
 $s = $s | 0;
 $pval = $pval | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $size_log2 = $size_log2 | 0;
 var $103 = 0, $104 = 0, $105 = 0, $107 = 0, $119 = 0, $120 = 0, $122 = 0, $125 = 0, $126 = 0, $127 = 0, $128 = 0, $130 = 0, $142 = 0, $143 = 0, $145 = 0, $148 = 0, $149 = 0, $150 = 0, $151 = 0, $156 = 0, $158 = 0, $161 = 0, $162 = 0, $163 = 0, $165 = 0, $168 = 0, $174 = 0, $18 = 0, $180 = 0, $181 = 0, $188 = 0, $190 = 0, $191 = 0, $192 = 0, $195 = 0, $2 = 0, $200 = 0, $207 = 0, $213 = 0, $214 = 0, $215 = 0, $218 = 0, $222 = 0, $223 = 0, $224 = 0, $225 = 0, $226 = 0, $228 = 0, $231 = 0, $233 = 0, $236 = 0, $26 = 0, $27 = 0, $28 = 0, $3 = 0, $30 = 0, $43 = 0, $5 = 0, $53 = 0, $54 = 0, $55 = 0, $57 = 0, $70 = 0, $77 = 0, $78 = 0, $79 = 0, $81 = 0, $94 = 0, $add$ptr68 = 0, $conv$i = 0, $conv$i110 = 0, $conv$i130 = 0, $conv$i149 = 0, $conv$i75 = 0, $conv$i94 = 0, $conv64 = 0, $i$09$i = 0, $inc$i = 0, $mul = 0, $mul45 = 0, $opaque101 = 0, $paddr = 0, $read_func100 = 0, $retval$0 = 0, $shl = 0, $storemerge$i105168$ph = 0, $storemerge$i123169$ph = 0, $storemerge$i143170$ph = 0, $storemerge$i162171$ph = 0, $storemerge$in$i = 0, $storemerge$in$i86 = 0, $val$i = 0, $val$i107 = 0, $val$i127 = 0, $val$i146 = 0, $val$i72 = 0, $val$i91 = 0, label = 0, sp = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 64 | 0;
 $val$i146 = sp + 48 | 0;
 $val$i127 = sp + 40 | 0;
 $val$i107 = sp + 32 | 0;
 $val$i91 = sp + 24 | 0;
 $val$i72 = sp + 16 | 0;
 $val$i = sp + 8 | 0;
 $paddr = sp;
 $shl = 1 << $size_log2;
 $2 = $shl + -1 & $0;
 do if (!$2) {
  if (_get_phys_addr($s, $paddr, $0, $1, 0) | 0) {
   _raise_exception2($s, 5, $0, $1);
   $retval$0 = -1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  $156 = $paddr;
  $158 = HEAP32[$156 >> 2] | 0;
  $161 = HEAP32[$156 + 4 >> 2] | 0;
  $162 = HEAP32[$s + 744 >> 2] | 0;
  if (($162 | 0) > 0) $i$09$i = 0; else {
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  while (1) {
   $163 = $s + ($i$09$i * 40 | 0) + 752 | 0;
   $165 = HEAP32[$163 >> 2] | 0;
   $168 = HEAP32[$163 + 4 >> 2] | 0;
   if (!($168 >>> 0 > $161 >>> 0 | ($168 | 0) == ($161 | 0) & $165 >>> 0 > $158 >>> 0)) {
    $174 = $s + ($i$09$i * 40 | 0) + 760 | 0;
    $180 = _i64Add(HEAP32[$174 >> 2] | 0, HEAP32[$174 + 4 >> 2] | 0, $165 | 0, $168 | 0) | 0;
    $181 = tempRet0;
    if ($181 >>> 0 > $161 >>> 0 | ($181 | 0) == ($161 | 0) & $180 >>> 0 > $158 >>> 0) break;
   }
   $inc$i = $i$09$i + 1 | 0;
   if (($inc$i | 0) < ($162 | 0)) $i$09$i = $inc$i; else {
    $retval$0 = 0;
    label = 47;
    break;
   }
  }
  if ((label | 0) == 47) {
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if (!(HEAP32[$s + ($i$09$i * 40 | 0) + 768 >> 2] | 0)) {
   $213 = _i64Subtract($158 | 0, $161 | 0, $165 | 0, $168 | 0) | 0;
   $214 = tempRet0;
   $215 = HEAP32[$s + ($i$09$i * 40 | 0) + 788 >> 2] | 0;
   if ($215 & $shl) {
    $218 = FUNCTION_TABLE_iiiii[HEAP32[$s + ($i$09$i * 40 | 0) + 780 >> 2] & 7](HEAP32[$s + ($i$09$i * 40 | 0) + 776 >> 2] | 0, $213, $214, $size_log2) | 0;
    $233 = $218;
    $236 = tempRet0;
    break;
   }
   if (!(($215 & 4 | 0) != 0 & ($size_log2 | 0) == 3)) {
    $233 = 0;
    $236 = 0;
    break;
   }
   $read_func100 = $s + ($i$09$i * 40 | 0) + 780 | 0;
   $opaque101 = $s + ($i$09$i * 40 | 0) + 776 | 0;
   $222 = FUNCTION_TABLE_iiiii[HEAP32[$read_func100 >> 2] & 7](HEAP32[$opaque101 >> 2] | 0, $213, $214, 2) | 0;
   $223 = tempRet0;
   $224 = HEAP32[$read_func100 >> 2] | 0;
   $225 = HEAP32[$opaque101 >> 2] | 0;
   $226 = _i64Add($213 | 0, $214 | 0, 4, 0) | 0;
   $228 = FUNCTION_TABLE_iiiii[$224 & 7]($225, $226, tempRet0, 2) | 0;
   $233 = $222;
   $236 = $228 | $223;
   break;
  }
  $188 = _bitshift64Lshr($0 | 0, $1 | 0, 12) | 0;
  $conv64 = $188 & 255;
  $190 = HEAP32[$s + 728 >> 2] | 0;
  $191 = HEAP32[$s + ($i$09$i * 40 | 0) + 772 >> 2] | 0;
  $192 = _i64Subtract($158 | 0, $161 | 0, $165 | 0, $168 | 0) | 0;
  $add$ptr68 = $190 + ($192 + $191) | 0;
  $195 = $s + ($conv64 << 4) + 1400 | 0;
  HEAP32[$195 >> 2] = $0 & -4096;
  HEAP32[$195 + 4 >> 2] = $1;
  $200 = _i64Subtract($add$ptr68 | 0, 0, $0 | 0, $1 | 0) | 0;
  HEAP32[$s + ($conv64 << 4) + 1408 >> 2] = $200;
  if (($size_log2 | 0) == 2) {
   $233 = HEAP32[$add$ptr68 >> 2] | 0;
   $236 = 0;
   break;
  } else if (($size_log2 | 0) == 3) {
   $207 = $add$ptr68;
   $233 = HEAP32[$207 >> 2] | 0;
   $236 = HEAP32[$207 + 4 >> 2] | 0;
   break;
  } else if (($size_log2 | 0) == 1) {
   $233 = HEAPU16[$add$ptr68 >> 1] | 0;
   $236 = 0;
   break;
  } else if (!$size_log2) {
   $233 = HEAPU8[$add$ptr68 >> 0] | 0;
   $236 = 0;
   break;
  } else _abort();
 } else if (($size_log2 | 0) == 2) {
  $53 = _i64Subtract($0 | 0, $1 | 0, $2 | 0, (($2 | 0) < 0) << 31 >> 31 | 0) | 0;
  $54 = tempRet0;
  $55 = _bitshift64Lshr($53 | 0, $54 | 0, 12) | 0;
  $conv$i110 = $55 & 255;
  $57 = $s + ($conv$i110 << 4) + 1400 | 0;
  do if ((HEAP32[$57 >> 2] | 0) == ($53 & -4065 | 0) ? (HEAP32[$57 + 4 >> 2] | 0) == ($54 | 0) : 0) $storemerge$i123169$ph = HEAP32[(HEAP32[$s + ($conv$i110 << 4) + 1408 >> 2] | 0) + $53 >> 2] | 0; else {
   $70 = _target_read_slow($s, $val$i107, $53, $54, 2) | 0;
   if (!$70) {
    $storemerge$i123169$ph = HEAP32[$val$i107 >> 2] | 0;
    break;
   } else {
    $retval$0 = $70;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
  } while (0);
  $77 = _i64Add($53 | 0, $54 | 0, 4, 0) | 0;
  $78 = tempRet0;
  $79 = _bitshift64Lshr($77 | 0, $78 | 0, 12) | 0;
  $conv$i94 = $79 & 255;
  $81 = $s + ($conv$i94 << 4) + 1400 | 0;
  do if ((HEAP32[$81 >> 2] | 0) == ($77 & -4065 | 0) ? (HEAP32[$81 + 4 >> 2] | 0) == ($78 | 0) : 0) $storemerge$i105168$ph = HEAP32[(HEAP32[$s + ($conv$i94 << 4) + 1408 >> 2] | 0) + $77 >> 2] | 0; else {
   $94 = _target_read_slow($s, $val$i91, $77, $78, 2) | 0;
   if (!$94) {
    $storemerge$i105168$ph = HEAP32[$val$i91 >> 2] | 0;
    break;
   } else {
    $retval$0 = $94;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
  } while (0);
  $mul = $2 << 3;
  $233 = $storemerge$i105168$ph << 32 - $mul | $storemerge$i123169$ph >>> $mul;
  $236 = 0;
  break;
 } else if (($size_log2 | 0) == 1) {
  $3 = _bitshift64Lshr($0 | 0, $1 | 0, 12) | 0;
  $conv$i149 = $3 & 255;
  $5 = $s + ($conv$i149 << 4) + 1400 | 0;
  do if ((HEAP32[$5 >> 2] | 0) == ($0 & -4089 | 0) ? (HEAP32[$5 + 4 >> 2] | 0) == ($1 | 0) : 0) $storemerge$i162171$ph = HEAP8[(HEAP32[$s + ($conv$i149 << 4) + 1408 >> 2] | 0) + $0 >> 0] | 0; else {
   $18 = _target_read_slow($s, $val$i146, $0, $1, 0) | 0;
   if (!$18) {
    $storemerge$i162171$ph = HEAP32[$val$i146 >> 2] & 255;
    break;
   } else {
    $retval$0 = $18;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
  } while (0);
  $26 = _i64Add($0 | 0, $1 | 0, 1, 0) | 0;
  $27 = tempRet0;
  $28 = _bitshift64Lshr($26 | 0, $27 | 0, 12) | 0;
  $conv$i130 = $28 & 255;
  $30 = $s + ($conv$i130 << 4) + 1400 | 0;
  do if ((HEAP32[$30 >> 2] | 0) == ($26 & -4089 | 0) ? (HEAP32[$30 + 4 >> 2] | 0) == ($27 | 0) : 0) $storemerge$i143170$ph = HEAP8[(HEAP32[$s + ($conv$i130 << 4) + 1408 >> 2] | 0) + $26 >> 0] | 0; else {
   $43 = _target_read_slow($s, $val$i127, $26, $27, 0) | 0;
   if (!$43) {
    $storemerge$i143170$ph = HEAP32[$val$i127 >> 2] & 255;
    break;
   } else {
    $retval$0 = $43;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
  } while (0);
  $233 = ($storemerge$i143170$ph & 255) << 8 | $storemerge$i162171$ph & 255;
  $236 = 0;
  break;
 } else if (($size_log2 | 0) == 3) {
  $103 = _i64Subtract($0 | 0, $1 | 0, $2 | 0, (($2 | 0) < 0) << 31 >> 31 | 0) | 0;
  $104 = tempRet0;
  $105 = _bitshift64Lshr($103 | 0, $104 | 0, 12) | 0;
  $conv$i75 = $105 & 255;
  $107 = $s + ($conv$i75 << 4) + 1400 | 0;
  if ((HEAP32[$107 >> 2] | 0) == ($103 & -4033 | 0) ? (HEAP32[$107 + 4 >> 2] | 0) == ($104 | 0) : 0) $storemerge$in$i86 = (HEAP32[$s + ($conv$i75 << 4) + 1408 >> 2] | 0) + $103 | 0; else {
   $119 = _target_read_slow($s, $val$i72, $103, $104, 3) | 0;
   if (!$119) $storemerge$in$i86 = $val$i72; else {
    $retval$0 = $119;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
  }
  $120 = $storemerge$in$i86;
  $122 = HEAP32[$120 >> 2] | 0;
  $125 = HEAP32[$120 + 4 >> 2] | 0;
  $126 = _i64Add($103 | 0, $104 | 0, 8, 0) | 0;
  $127 = tempRet0;
  $128 = _bitshift64Lshr($126 | 0, $127 | 0, 12) | 0;
  $conv$i = $128 & 255;
  $130 = $s + ($conv$i << 4) + 1400 | 0;
  if ((HEAP32[$130 >> 2] | 0) == ($126 & -4033 | 0) ? (HEAP32[$130 + 4 >> 2] | 0) == ($127 | 0) : 0) $storemerge$in$i = (HEAP32[$s + ($conv$i << 4) + 1408 >> 2] | 0) + $126 | 0; else {
   $142 = _target_read_slow($s, $val$i, $126, $127, 3) | 0;
   if (!$142) $storemerge$in$i = $val$i; else {
    $retval$0 = $142;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
  }
  $143 = $storemerge$in$i;
  $145 = HEAP32[$143 >> 2] | 0;
  $148 = HEAP32[$143 + 4 >> 2] | 0;
  $mul45 = $2 << 3;
  $149 = _bitshift64Lshr($122 | 0, $125 | 0, $mul45 | 0) | 0;
  $150 = tempRet0;
  $151 = _bitshift64Shl($145 | 0, $148 | 0, 64 - $mul45 | 0) | 0;
  $233 = $151 | $149;
  $236 = tempRet0 | $150;
  break;
 } else _abort(); while (0);
 $231 = $pval;
 HEAP32[$231 >> 2] = $233;
 HEAP32[$231 + 4 >> 2] = $236;
 $retval$0 = 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function ___udivmoddi4($a$0, $a$1, $b$0, $b$1, $rem) {
 $a$0 = $a$0 | 0;
 $a$1 = $a$1 | 0;
 $b$0 = $b$0 | 0;
 $b$1 = $b$1 | 0;
 $rem = $rem | 0;
 var $n_sroa_0_0_extract_trunc = 0, $n_sroa_1_4_extract_shift$0 = 0, $n_sroa_1_4_extract_trunc = 0, $d_sroa_0_0_extract_trunc = 0, $d_sroa_1_4_extract_shift$0 = 0, $d_sroa_1_4_extract_trunc = 0, $4 = 0, $17 = 0, $37 = 0, $51 = 0, $57 = 0, $58 = 0, $66 = 0, $78 = 0, $88 = 0, $89 = 0, $91 = 0, $92 = 0, $95 = 0, $105 = 0, $119 = 0, $125 = 0, $126 = 0, $130 = 0, $q_sroa_1_1_ph = 0, $q_sroa_0_1_ph = 0, $r_sroa_1_1_ph = 0, $r_sroa_0_1_ph = 0, $sr_1_ph = 0, $d_sroa_0_0_insert_insert99$0 = 0, $d_sroa_0_0_insert_insert99$1 = 0, $137$0 = 0, $137$1 = 0, $carry_0203 = 0, $sr_1202 = 0, $r_sroa_0_1201 = 0, $r_sroa_1_1200 = 0, $q_sroa_0_1199 = 0, $q_sroa_1_1198 = 0, $r_sroa_0_0_insert_insert42$0 = 0, $r_sroa_0_0_insert_insert42$1 = 0, $150$1 = 0, $151$0 = 0, $carry_0_lcssa$0 = 0, $carry_0_lcssa$1 = 0, $r_sroa_0_1_lcssa = 0, $r_sroa_1_1_lcssa = 0, $q_sroa_0_1_lcssa = 0, $q_sroa_1_1_lcssa = 0, $q_sroa_0_0_insert_ext75$0 = 0, $q_sroa_0_0_insert_ext75$1 = 0, $_0$0 = 0, $_0$1 = 0, $q_sroa_1_1198$looptemp = 0;
 $n_sroa_0_0_extract_trunc = $a$0;
 $n_sroa_1_4_extract_shift$0 = $a$1;
 $n_sroa_1_4_extract_trunc = $n_sroa_1_4_extract_shift$0;
 $d_sroa_0_0_extract_trunc = $b$0;
 $d_sroa_1_4_extract_shift$0 = $b$1;
 $d_sroa_1_4_extract_trunc = $d_sroa_1_4_extract_shift$0;
 if (!$n_sroa_1_4_extract_trunc) {
  $4 = ($rem | 0) != 0;
  if (!$d_sroa_1_4_extract_trunc) {
   if ($4) {
    HEAP32[$rem >> 2] = ($n_sroa_0_0_extract_trunc >>> 0) % ($d_sroa_0_0_extract_trunc >>> 0);
    HEAP32[$rem + 4 >> 2] = 0;
   }
   $_0$1 = 0;
   $_0$0 = ($n_sroa_0_0_extract_trunc >>> 0) / ($d_sroa_0_0_extract_trunc >>> 0) >>> 0;
   return (tempRet0 = $_0$1, $_0$0) | 0;
  } else {
   if (!$4) {
    $_0$1 = 0;
    $_0$0 = 0;
    return (tempRet0 = $_0$1, $_0$0) | 0;
   }
   HEAP32[$rem >> 2] = $a$0 | 0;
   HEAP32[$rem + 4 >> 2] = $a$1 & 0;
   $_0$1 = 0;
   $_0$0 = 0;
   return (tempRet0 = $_0$1, $_0$0) | 0;
  }
 }
 $17 = ($d_sroa_1_4_extract_trunc | 0) == 0;
 do if (!$d_sroa_0_0_extract_trunc) {
  if ($17) {
   if ($rem) {
    HEAP32[$rem >> 2] = ($n_sroa_1_4_extract_trunc >>> 0) % ($d_sroa_0_0_extract_trunc >>> 0);
    HEAP32[$rem + 4 >> 2] = 0;
   }
   $_0$1 = 0;
   $_0$0 = ($n_sroa_1_4_extract_trunc >>> 0) / ($d_sroa_0_0_extract_trunc >>> 0) >>> 0;
   return (tempRet0 = $_0$1, $_0$0) | 0;
  }
  if (!$n_sroa_0_0_extract_trunc) {
   if ($rem) {
    HEAP32[$rem >> 2] = 0;
    HEAP32[$rem + 4 >> 2] = ($n_sroa_1_4_extract_trunc >>> 0) % ($d_sroa_1_4_extract_trunc >>> 0);
   }
   $_0$1 = 0;
   $_0$0 = ($n_sroa_1_4_extract_trunc >>> 0) / ($d_sroa_1_4_extract_trunc >>> 0) >>> 0;
   return (tempRet0 = $_0$1, $_0$0) | 0;
  }
  $37 = $d_sroa_1_4_extract_trunc - 1 | 0;
  if (!($37 & $d_sroa_1_4_extract_trunc)) {
   if ($rem) {
    HEAP32[$rem >> 2] = $a$0 | 0;
    HEAP32[$rem + 4 >> 2] = $37 & $n_sroa_1_4_extract_trunc | $a$1 & 0;
   }
   $_0$1 = 0;
   $_0$0 = $n_sroa_1_4_extract_trunc >>> ((_llvm_cttz_i32($d_sroa_1_4_extract_trunc | 0) | 0) >>> 0);
   return (tempRet0 = $_0$1, $_0$0) | 0;
  }
  $51 = (_llvm_ctlz_i32($d_sroa_1_4_extract_trunc | 0) | 0) - (_llvm_ctlz_i32($n_sroa_1_4_extract_trunc | 0) | 0) | 0;
  if ($51 >>> 0 <= 30) {
   $57 = $51 + 1 | 0;
   $58 = 31 - $51 | 0;
   $sr_1_ph = $57;
   $r_sroa_0_1_ph = $n_sroa_1_4_extract_trunc << $58 | $n_sroa_0_0_extract_trunc >>> ($57 >>> 0);
   $r_sroa_1_1_ph = $n_sroa_1_4_extract_trunc >>> ($57 >>> 0);
   $q_sroa_0_1_ph = 0;
   $q_sroa_1_1_ph = $n_sroa_0_0_extract_trunc << $58;
   break;
  }
  if (!$rem) {
   $_0$1 = 0;
   $_0$0 = 0;
   return (tempRet0 = $_0$1, $_0$0) | 0;
  }
  HEAP32[$rem >> 2] = $a$0 | 0;
  HEAP32[$rem + 4 >> 2] = $n_sroa_1_4_extract_shift$0 | $a$1 & 0;
  $_0$1 = 0;
  $_0$0 = 0;
  return (tempRet0 = $_0$1, $_0$0) | 0;
 } else {
  if (!$17) {
   $119 = (_llvm_ctlz_i32($d_sroa_1_4_extract_trunc | 0) | 0) - (_llvm_ctlz_i32($n_sroa_1_4_extract_trunc | 0) | 0) | 0;
   if ($119 >>> 0 <= 31) {
    $125 = $119 + 1 | 0;
    $126 = 31 - $119 | 0;
    $130 = $119 - 31 >> 31;
    $sr_1_ph = $125;
    $r_sroa_0_1_ph = $n_sroa_0_0_extract_trunc >>> ($125 >>> 0) & $130 | $n_sroa_1_4_extract_trunc << $126;
    $r_sroa_1_1_ph = $n_sroa_1_4_extract_trunc >>> ($125 >>> 0) & $130;
    $q_sroa_0_1_ph = 0;
    $q_sroa_1_1_ph = $n_sroa_0_0_extract_trunc << $126;
    break;
   }
   if (!$rem) {
    $_0$1 = 0;
    $_0$0 = 0;
    return (tempRet0 = $_0$1, $_0$0) | 0;
   }
   HEAP32[$rem >> 2] = $a$0 | 0;
   HEAP32[$rem + 4 >> 2] = $n_sroa_1_4_extract_shift$0 | $a$1 & 0;
   $_0$1 = 0;
   $_0$0 = 0;
   return (tempRet0 = $_0$1, $_0$0) | 0;
  }
  $66 = $d_sroa_0_0_extract_trunc - 1 | 0;
  if ($66 & $d_sroa_0_0_extract_trunc) {
   $88 = (_llvm_ctlz_i32($d_sroa_0_0_extract_trunc | 0) | 0) + 33 - (_llvm_ctlz_i32($n_sroa_1_4_extract_trunc | 0) | 0) | 0;
   $89 = 64 - $88 | 0;
   $91 = 32 - $88 | 0;
   $92 = $91 >> 31;
   $95 = $88 - 32 | 0;
   $105 = $95 >> 31;
   $sr_1_ph = $88;
   $r_sroa_0_1_ph = $91 - 1 >> 31 & $n_sroa_1_4_extract_trunc >>> ($95 >>> 0) | ($n_sroa_1_4_extract_trunc << $91 | $n_sroa_0_0_extract_trunc >>> ($88 >>> 0)) & $105;
   $r_sroa_1_1_ph = $105 & $n_sroa_1_4_extract_trunc >>> ($88 >>> 0);
   $q_sroa_0_1_ph = $n_sroa_0_0_extract_trunc << $89 & $92;
   $q_sroa_1_1_ph = ($n_sroa_1_4_extract_trunc << $89 | $n_sroa_0_0_extract_trunc >>> ($95 >>> 0)) & $92 | $n_sroa_0_0_extract_trunc << $91 & $88 - 33 >> 31;
   break;
  }
  if ($rem) {
   HEAP32[$rem >> 2] = $66 & $n_sroa_0_0_extract_trunc;
   HEAP32[$rem + 4 >> 2] = 0;
  }
  if (($d_sroa_0_0_extract_trunc | 0) == 1) {
   $_0$1 = $n_sroa_1_4_extract_shift$0 | $a$1 & 0;
   $_0$0 = $a$0 | 0 | 0;
   return (tempRet0 = $_0$1, $_0$0) | 0;
  } else {
   $78 = _llvm_cttz_i32($d_sroa_0_0_extract_trunc | 0) | 0;
   $_0$1 = $n_sroa_1_4_extract_trunc >>> ($78 >>> 0) | 0;
   $_0$0 = $n_sroa_1_4_extract_trunc << 32 - $78 | $n_sroa_0_0_extract_trunc >>> ($78 >>> 0) | 0;
   return (tempRet0 = $_0$1, $_0$0) | 0;
  }
 } while (0);
 if (!$sr_1_ph) {
  $q_sroa_1_1_lcssa = $q_sroa_1_1_ph;
  $q_sroa_0_1_lcssa = $q_sroa_0_1_ph;
  $r_sroa_1_1_lcssa = $r_sroa_1_1_ph;
  $r_sroa_0_1_lcssa = $r_sroa_0_1_ph;
  $carry_0_lcssa$1 = 0;
  $carry_0_lcssa$0 = 0;
 } else {
  $d_sroa_0_0_insert_insert99$0 = $b$0 | 0 | 0;
  $d_sroa_0_0_insert_insert99$1 = $d_sroa_1_4_extract_shift$0 | $b$1 & 0;
  $137$0 = _i64Add($d_sroa_0_0_insert_insert99$0, $d_sroa_0_0_insert_insert99$1, -1, -1) | 0;
  $137$1 = tempRet0;
  $q_sroa_1_1198 = $q_sroa_1_1_ph;
  $q_sroa_0_1199 = $q_sroa_0_1_ph;
  $r_sroa_1_1200 = $r_sroa_1_1_ph;
  $r_sroa_0_1201 = $r_sroa_0_1_ph;
  $sr_1202 = $sr_1_ph;
  $carry_0203 = 0;
  do {
   $q_sroa_1_1198$looptemp = $q_sroa_1_1198;
   $q_sroa_1_1198 = $q_sroa_0_1199 >>> 31 | $q_sroa_1_1198 << 1;
   $q_sroa_0_1199 = $carry_0203 | $q_sroa_0_1199 << 1;
   $r_sroa_0_0_insert_insert42$0 = $r_sroa_0_1201 << 1 | $q_sroa_1_1198$looptemp >>> 31 | 0;
   $r_sroa_0_0_insert_insert42$1 = $r_sroa_0_1201 >>> 31 | $r_sroa_1_1200 << 1 | 0;
   _i64Subtract($137$0, $137$1, $r_sroa_0_0_insert_insert42$0, $r_sroa_0_0_insert_insert42$1) | 0;
   $150$1 = tempRet0;
   $151$0 = $150$1 >> 31 | (($150$1 | 0) < 0 ? -1 : 0) << 1;
   $carry_0203 = $151$0 & 1;
   $r_sroa_0_1201 = _i64Subtract($r_sroa_0_0_insert_insert42$0, $r_sroa_0_0_insert_insert42$1, $151$0 & $d_sroa_0_0_insert_insert99$0, ((($150$1 | 0) < 0 ? -1 : 0) >> 31 | (($150$1 | 0) < 0 ? -1 : 0) << 1) & $d_sroa_0_0_insert_insert99$1) | 0;
   $r_sroa_1_1200 = tempRet0;
   $sr_1202 = $sr_1202 - 1 | 0;
  } while (($sr_1202 | 0) != 0);
  $q_sroa_1_1_lcssa = $q_sroa_1_1198;
  $q_sroa_0_1_lcssa = $q_sroa_0_1199;
  $r_sroa_1_1_lcssa = $r_sroa_1_1200;
  $r_sroa_0_1_lcssa = $r_sroa_0_1201;
  $carry_0_lcssa$1 = 0;
  $carry_0_lcssa$0 = $carry_0203;
 }
 $q_sroa_0_0_insert_ext75$0 = $q_sroa_0_1_lcssa;
 $q_sroa_0_0_insert_ext75$1 = 0;
 if ($rem) {
  HEAP32[$rem >> 2] = $r_sroa_0_1_lcssa;
  HEAP32[$rem + 4 >> 2] = $r_sroa_1_1_lcssa;
 }
 $_0$1 = ($q_sroa_0_0_insert_ext75$0 | 0) >>> 31 | ($q_sroa_1_1_lcssa | $q_sroa_0_0_insert_ext75$1) << 1 | ($q_sroa_0_0_insert_ext75$1 << 1 | $q_sroa_0_0_insert_ext75$0 >>> 31) & 0 | $carry_0_lcssa$1;
 $_0$0 = ($q_sroa_0_0_insert_ext75$0 << 1 | 0 >>> 31) & -2 | $carry_0_lcssa$0;
 return (tempRet0 = $_0$1, $_0$0) | 0;
}
function _fma_sf32($a, $b, $c, $rm, $pfflags) {
 $a = $a | 0;
 $b = $b | 0;
 $c = $c | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $10 = 0, $11 = 0, $12 = 0, $14 = 0, $15 = 0, $17 = 0, $6 = 0, $9 = 0, $a_mant$0 = 0, $a_mant1$addr$0$i = 0, $add = 0, $add165 = 0, $and = 0, $and10 = 0, $and5 = 0, $and7 = 0, $and8 = 0, $and9 = 0, $b_mant$0 = 0, $c_mant$0 = 0, $c_mant0$0 = 0, $c_mant0$1 = 0, $c_mant1$0 = 0, $c_mant1$1 = 0, $c_sign$0 = 0, $cmp = 0, $cmp2$i = 0, $cmp35 = 0, $conv2$i182 = 0, $conv2$i183 = 0, $conv2$i184 = 0, $inc = 0, $or$cond85 = 0, $or104 = 0, $r_exp$0 = 0, $r_exp$1 = 0, $r_mant1$0 = 0, $r_mant1$1 = 0, $r_mant1$2 = 0, $r_sign$0 = 0, $r_sign$1 = 0, $r_sign$2 = 0, $retval$0 = 0, $shl111 = 0, $shr2 = 0, $sub123 = 0, $sub134 = 0, $sub173 = 0, $sub177 = 0, $sub2$i139188 = 0, $sub2$i148189 = 0, $sub2$i185 = 0, $sub2$i186 = 0, $sub26$i = 0, $sub26$in$i = 0, $sub26$in3036$i = 0, $sub3$i = 0, $sub332$i = 0, $sub33335$i = 0, $sub8$i = 0, $xor = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $shr2 = $c >>> 31;
 $xor = ($b ^ $a) >>> 31;
 $and = $a >>> 23 & 255;
 $and5 = $b >>> 23 & 255;
 $and7 = $c >>> 23 & 255;
 $and8 = $a & 8388607;
 $and9 = $b & 8388607;
 $and10 = $c & 8388607;
 $cmp = ($and | 0) == 255;
 if (!$cmp) if (!(($and5 | 0) == 255 | ($and7 | 0) == 255)) {
  if (!$and) {
   if ($and8) {
    $6 = _llvm_ctlz_i32($and8 | 0) | 0;
    $a_mant$0 = $and8 << $6 + -8;
    $sub2$i148189 = 9 - $6 | 0;
    label = 24;
   }
  } else {
   $a_mant$0 = $and8 | 8388608;
   $sub2$i148189 = $and;
   label = 24;
  }
  do if ((label | 0) == 24) {
   if (!$and5) {
    if (!$and9) break;
    $9 = _llvm_ctlz_i32($and9 | 0) | 0;
    $b_mant$0 = $and9 << $9 + -8;
    $sub2$i139188 = 9 - $9 | 0;
   } else {
    $b_mant$0 = $and9 | 8388608;
    $sub2$i139188 = $and5;
   }
   $add = $sub2$i139188 + $sub2$i148189 | 0;
   $10 = ___muldi3($b_mant$0 << 7 | 0, 0, $a_mant$0 << 7 | 0, 0) | 0;
   $11 = tempRet0;
   if ($11 >>> 0 < 536870912) {
    $12 = _bitshift64Shl($11 | 0, 0, 1) | 0;
    $conv2$i184 = $10 << 1;
    $r_exp$0 = $add + -126 | 0;
    $r_mant1$0 = $12 | $10 >>> 31;
   } else {
    $conv2$i184 = $10;
    $r_exp$0 = $add + -125 | 0;
    $r_mant1$0 = $11;
   }
   do if (!$and7) {
    if ($and10) {
     $15 = _llvm_ctlz_i32($and10 | 0) | 0;
     $c_mant$0 = $and10 << $15 + -8;
     $sub2$i186 = 9 - $15 | 0;
     break;
    }
    $or104 = ($conv2$i184 | 0) != 0 | $r_mant1$0;
    if (!$or104) $sub8$i = 31; else {
     $14 = _llvm_ctlz_i32($or104 | 0) | 0;
     if (!$14) ___assert_fail(1104, 1064, 183, 1168); else $sub8$i = $14 + -1 | 0;
    }
    $retval$0 = _roundpack_sf32($xor, $r_exp$0 - $sub8$i | 0, $or104 << $sub8$i, $rm, $pfflags) | 0;
    STACKTOP = sp;
    return $retval$0 | 0;
   } else {
    $c_mant$0 = $and10 | 8388608;
    $sub2$i186 = $and7;
   } while (0);
   $inc = $sub2$i186 + 1 | 0;
   $shl111 = $c_mant$0 << 6;
   if (($r_exp$0 | 0) > ($inc | 0)) {
    $c_mant0$0 = 0;
    $c_mant1$0 = $shl111;
    $c_sign$0 = $shr2;
    $conv2$i183 = $conv2$i184;
    $r_exp$1 = $r_exp$0;
    $r_mant1$1 = $r_mant1$0;
    $r_sign$1 = $xor;
    $sub2$i185 = $inc;
   } else {
    $or$cond85 = ($r_exp$0 | 0) != ($inc | 0) | $r_mant1$0 >>> 0 < $shl111 >>> 0;
    $c_mant0$0 = $or$cond85 ? $conv2$i184 : 0;
    $c_mant1$0 = $or$cond85 ? $r_mant1$0 : $shl111;
    $c_sign$0 = $or$cond85 ? $xor : $shr2;
    $conv2$i183 = $or$cond85 ? 0 : $conv2$i184;
    $r_exp$1 = $or$cond85 ? $inc : $r_exp$0;
    $r_mant1$1 = $or$cond85 ? $shl111 : $r_mant1$0;
    $r_sign$1 = $or$cond85 ? $shr2 : $xor;
    $sub2$i185 = $or$cond85 ? $r_exp$0 : $inc;
   }
   $sub123 = $r_exp$1 - $sub2$i185 | 0;
   do if (($sub123 | 0) > 63) {
    $c_mant0$1 = ($c_mant0$0 | $c_mant1$0 | 0) != 0 & 1;
    $c_mant1$1 = 0;
   } else if (($sub123 | 0) > 32) {
    $sub134 = $sub123 + -32 | 0;
    if (!$sub134) {
     $c_mant0$1 = $c_mant1$0;
     $c_mant1$1 = 0;
     break;
    }
    if (($sub134 | 0) > 31) {
     $c_mant0$1 = ($c_mant1$0 | 0) != 0 & 1;
     $c_mant1$1 = 0;
     break;
    } else {
     $c_mant0$1 = ((1 << $sub134) + -1 & $c_mant1$0 | 0) != 0 | $c_mant1$0 >>> $sub134;
     $c_mant1$1 = 0;
     break;
    }
   } else {
    if (($sub123 | 0) == 32) {
     $c_mant0$1 = ($c_mant0$0 | 0) != 0 | $c_mant1$0;
     $c_mant1$1 = 0;
     break;
    }
    if (($r_exp$1 | 0) == ($sub2$i185 | 0)) {
     $c_mant0$1 = $c_mant0$0;
     $c_mant1$1 = $c_mant1$0;
     break;
    }
    $c_mant0$1 = $c_mant1$0 << 32 - $sub123 | $c_mant0$0 >>> $sub123 | ((1 << $sub123) + -1 & $c_mant0$0 | 0) != 0;
    $c_mant1$1 = $c_mant1$0 >>> $sub123;
    break;
   } while (0);
   if (($r_sign$1 | 0) == ($c_sign$0 | 0)) {
    $add165 = $c_mant0$1 + $conv2$i183 | 0;
    $conv2$i182 = $add165;
    $r_mant1$2 = $c_mant1$1 + $r_mant1$1 + ($add165 >>> 0 < $c_mant0$1 >>> 0 & 1) | 0;
    $r_sign$2 = $r_sign$1;
   } else {
    $sub173 = $conv2$i183 - $c_mant0$1 | 0;
    $sub177 = (($sub173 >>> 0 > $conv2$i183 >>> 0) << 31 >> 31) + ($r_mant1$1 - $c_mant1$1) | 0;
    if (!($sub177 | $sub173)) {
     $conv2$i182 = $sub173;
     $r_mant1$2 = $sub177;
     $r_sign$2 = ($rm | 0) == 2 & 1;
    } else {
     $conv2$i182 = $sub173;
     $r_mant1$2 = $sub177;
     $r_sign$2 = $r_sign$1;
    }
   }
   do if (!$r_mant1$2) if (!$conv2$i182) {
    $sub26$in3036$i = 64;
    $sub33335$i = $r_exp$1 + -63 | 0;
    label = 69;
    break;
   } else {
    $sub26$in$i = (_llvm_ctlz_i32($conv2$i182 | 0) | 0) + 32 | 0;
    label = 65;
    break;
   } else {
    $17 = _llvm_ctlz_i32($r_mant1$2 | 0) | 0;
    if (!$17) ___assert_fail(1104, 1064, 201, 1152); else {
     $sub26$in$i = $17;
     label = 65;
    }
   } while (0);
   do if ((label | 0) == 65) {
    $sub26$i = $sub26$in$i + -1 | 0;
    $sub3$i = $r_exp$1 - $sub26$i | 0;
    if (!$sub26$i) {
     $a_mant1$addr$0$i = ($conv2$i182 | 0) != 0 | $r_mant1$2;
     $sub332$i = $sub3$i;
     break;
    }
    if (($sub26$in$i | 0) < 33) {
     $a_mant1$addr$0$i = $r_mant1$2 << $sub26$i | $conv2$i182 >>> (33 - $sub26$in$i | 0) | ($conv2$i182 << $sub26$i | 0) != 0;
     $sub332$i = $sub3$i;
    } else {
     $sub26$in3036$i = $sub26$in$i;
     $sub33335$i = $sub3$i;
     label = 69;
    }
   } while (0);
   if ((label | 0) == 69) {
    $a_mant1$addr$0$i = $conv2$i182 << $sub26$in3036$i + -33;
    $sub332$i = $sub33335$i;
   }
   $retval$0 = _roundpack_sf32($r_sign$2, $sub332$i, $a_mant1$addr$0$i, $rm, $pfflags) | 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  } while (0);
  if ($and7 | $and10) {
   $retval$0 = $c;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if (($shr2 | 0) == ($xor | 0)) $r_sign$0 = $shr2; else $r_sign$0 = ($rm | 0) == 2 & 1;
  $retval$0 = $r_sign$0 << 31;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 $cmp2$i = ($and8 | 0) != 0;
 if (!(($a & 2139095040 | 0) == 2139095040 & $cmp2$i)) if (!(($b & 2139095040 | 0) == 2139095040 & ($and9 | 0) != 0)) if (!(($c & 2139095040 | 0) == 2139095040 & ($and10 | 0) != 0)) {
  if ($cmp) {
   if ($and5 | $and9) label = 12;
  } else label = 12;
  do if ((label | 0) == 12) {
   $cmp35 = ($and5 | 0) == 255;
   if ($cmp35) if (!($and | $and8)) break; else label = 15; else if ($cmp | $cmp35) label = 15;
   if ((label | 0) == 15) if (!(($and7 | 0) != 255 | ($xor | 0) == ($shr2 | 0))) break;
   if (($and7 | 0) == 255) {
    $retval$0 = $shr2 << 31 | 2139095040;
    STACKTOP = sp;
    return $retval$0 | 0;
   } else {
    $retval$0 = $xor << 31 | 2139095040;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
  } while (0);
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $retval$0 = 2143289344;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 if (!(($a & 2143289344 | 0) == 2139095040 & $cmp2$i)) if (!(($b & 2143289344 | 0) == 2139095040 & ($and9 | 0) != 0)) if (!(($c & 2143289344 | 0) == 2139095040 & ($and10 | 0) != 0)) {
  $retval$0 = 2143289344;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $retval$0 = 2143289344;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _csr_read($s, $pval, $csr, $will_write) {
 $s = $s | 0;
 $pval = $pval | 0;
 $csr = $csr | 0;
 $will_write = $will_write | 0;
 var $0 = 0, $104 = 0, $11 = 0, $110 = 0, $116 = 0, $12 = 0, $124 = 0, $130 = 0, $132 = 0, $135 = 0, $145 = 0, $149 = 0, $151 = 0, $154 = 0, $156 = 0, $157 = 0, $162 = 0, $168 = 0, $174 = 0, $180 = 0, $186 = 0, $19 = 0, $192 = 0, $198 = 0, $204 = 0, $210 = 0, $216 = 0, $222 = 0, $235 = 0, $241 = 0, $245 = 0, $247 = 0, $250 = 0, $26 = 0, $28 = 0, $31 = 0, $32 = 0, $45 = 0, $47 = 0, $51 = 0, $52 = 0, $6 = 0, $62 = 0, $66 = 0, $72 = 0, $8 = 0, $80 = 0, $86 = 0, $92 = 0, $98 = 0, $conv = 0, $conv69 = 0, $retval$0 = 0, label = 0, sp = 0;
 sp = STACKTOP;
 if (!(($csr & 3072 | 0) != 3072 | ($will_write | 0) == 0)) {
  $retval$0 = -1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 $0 = HEAP8[$s + 526 >> 0] | 0;
 $conv = $0 & 255;
 if ($conv >>> 0 < ($csr >>> 8 & 3) >>> 0) {
  $retval$0 = -1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 L7 : do switch ($csr | 0) {
 case 3074:
 case 3072:
  {
   if (($0 & 255) < 3) {
    $6 = $s + ($conv << 3) + 696 | 0;
    $8 = HEAP32[$6 >> 2] | 0;
    $11 = HEAP32[$6 + 4 >> 2] | 0;
    $12 = _bitshift64Shl(1, 0, $csr & 31 | 0) | 0;
    if (($8 & $12 | 0) == 0 & ($11 & tempRet0 | 0) == 0) {
     label = 44;
     break L7;
    }
   }
   $19 = $s + 528 | 0;
   $247 = HEAP32[$19 >> 2] | 0;
   $250 = HEAP32[$19 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 832:
  {
   $192 = $s + 576 | 0;
   $247 = HEAP32[$192 >> 2] | 0;
   $250 = HEAP32[$192 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 768:
  {
   $130 = $s + 552 | 0;
   $132 = HEAP32[$130 >> 2] | 0;
   $135 = HEAP32[$130 + 4 >> 2] | 0;
   if (!(($132 & 24576 | 0) == 24576 & 0 == 0 & 1 | ($132 & 98304 | 0) == 98304 & 0 == 0 & 1)) {
    $247 = $132;
    $250 = $135;
    label = 45;
   } else {
    $145 = _bitshift64Shl(1, 0, (HEAPU8[$s + 525 >> 0] | 0) + -1 | 0) | 0;
    $247 = $145 | $132;
    $250 = tempRet0 | $135;
    label = 45;
   }
   break;
  }
 case 256:
  {
   $45 = $s + 552 | 0;
   $47 = HEAP32[$45 >> 2] | 0;
   $51 = $47 & 385331;
   $52 = HEAP32[$45 + 4 >> 2] & 1028;
   if (!(($47 & 24576 | 0) == 24576 & 0 == 0 & 1 | ($47 & 98304 | 0) == 98304 & 0 == 0 & 1)) {
    $247 = $51;
    $250 = $52;
    label = 45;
   } else {
    $62 = _bitshift64Shl(1, 0, (HEAPU8[$s + 525 >> 0] | 0) + -1 | 0) | 0;
    $247 = $62 | $51;
    $250 = tempRet0 | $52;
    label = 45;
   }
   break;
  }
 case 3:
  {
   $247 = HEAPU8[$s + 524 >> 0] << 5 | HEAP32[$s + 520 >> 2];
   $250 = 0;
   label = 45;
   break;
  }
 case 321:
  {
   $92 = $s + 664 | 0;
   $247 = HEAP32[$92 >> 2] | 0;
   $250 = HEAP32[$92 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 2818:
 case 2816:
  {
   $222 = $s + 528 | 0;
   $247 = HEAP32[$222 >> 2] | 0;
   $250 = HEAP32[$222 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 835:
  {
   $210 = $s + 600 | 0;
   $247 = HEAP32[$210 >> 2] | 0;
   $250 = HEAP32[$210 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 770:
  {
   $162 = $s + 632 | 0;
   $247 = HEAP32[$162 >> 2] | 0;
   $250 = HEAP32[$162 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 3860:
  {
   $235 = $s + 616 | 0;
   $247 = HEAP32[$235 >> 2] | 0;
   $250 = HEAP32[$235 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 834:
  {
   $204 = $s + 592 | 0;
   $247 = HEAP32[$204 >> 2] | 0;
   $250 = HEAP32[$204 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 1:
  {
   $247 = HEAP32[$s + 520 >> 2] | 0;
   $250 = 0;
   label = 45;
   break;
  }
 case 2946:
 case 2944:
  {
   if ((HEAP8[$s + 525 >> 0] | 0) == 32) {
    $247 = HEAP32[$s + 532 >> 2] | 0;
    $250 = 0;
    label = 45;
   } else label = 44;
   break;
  }
 case 260:
  {
   $66 = $s + 560 | 0;
   $72 = $s + 640 | 0;
   $247 = HEAP32[$72 >> 2] & HEAP32[$66 >> 2];
   $250 = HEAP32[$72 + 4 >> 2] & HEAP32[$66 + 4 >> 2];
   label = 45;
   break;
  }
 case 771:
  {
   $168 = $s + 640 | 0;
   $247 = HEAP32[$168 >> 2] | 0;
   $250 = HEAP32[$168 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 3202:
 case 3200:
  {
   if ((HEAP8[$s + 525 >> 0] | 0) == 32) {
    if (($0 & 255) < 3) {
     $26 = $s + ($conv << 3) + 696 | 0;
     $28 = HEAP32[$26 >> 2] | 0;
     $31 = HEAP32[$26 + 4 >> 2] | 0;
     $32 = _bitshift64Shl(1, 0, $csr & 31 | 0) | 0;
     if (($28 & $32 | 0) == 0 & ($31 & tempRet0 | 0) == 0) {
      label = 44;
      break L7;
     }
    }
    $247 = HEAP32[$s + 532 >> 2] | 0;
    $250 = 0;
    label = 45;
   } else label = 44;
   break;
  }
 case 2:
  {
   $247 = HEAPU8[$s + 524 >> 0] | 0;
   $250 = 0;
   label = 45;
   break;
  }
 case 833:
  {
   $198 = $s + 584 | 0;
   $247 = HEAP32[$198 >> 2] | 0;
   $250 = HEAP32[$198 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 323:
  {
   $104 = $s + 680 | 0;
   $247 = HEAP32[$104 >> 2] | 0;
   $250 = HEAP32[$104 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 322:
  {
   $98 = $s + 672 | 0;
   $247 = HEAP32[$98 >> 2] | 0;
   $250 = HEAP32[$98 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 261:
  {
   $80 = $s + 648 | 0;
   $247 = HEAP32[$80 >> 2] | 0;
   $250 = HEAP32[$80 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 320:
  {
   $86 = $s + 656 | 0;
   $247 = HEAP32[$86 >> 2] | 0;
   $250 = HEAP32[$86 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 773:
  {
   $180 = $s + 568 | 0;
   $247 = HEAP32[$180 >> 2] | 0;
   $250 = HEAP32[$180 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 324:
  {
   $110 = $s + 608 | 0;
   $116 = $s + 640 | 0;
   $247 = HEAP32[$116 >> 2] & HEAP32[$110 >> 2];
   $250 = HEAP32[$116 + 4 >> 2] & HEAP32[$110 + 4 >> 2];
   label = 45;
   break;
  }
 case 801:
 case 800:
  {
   $186 = $s + (($csr & 3) << 3) + 696 | 0;
   $247 = HEAP32[$186 >> 2] | 0;
   $250 = HEAP32[$186 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 772:
  {
   $174 = $s + 560 | 0;
   $247 = HEAP32[$174 >> 2] | 0;
   $250 = HEAP32[$174 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 836:
  {
   $216 = $s + 608 | 0;
   $247 = HEAP32[$216 >> 2] | 0;
   $250 = HEAP32[$216 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 case 769:
  {
   $149 = $s + 624 | 0;
   $151 = HEAP32[$149 >> 2] | 0;
   $154 = HEAP32[$149 + 4 >> 2] | 0;
   $conv69 = HEAPU8[$s + 525 >> 0] | 0;
   if (($conv69 | 0) == 32) {
    $156 = 1;
    $157 = 0;
   } else if (($conv69 | 0) == 64) {
    $156 = 2;
    $157 = 0;
   } else {
    $156 = 3;
    $157 = 0;
   }
   $247 = _bitshift64Shl($156 | 0, $157 | 0, $conv69 + -2 | 0) | 0 | $151;
   $250 = tempRet0 | $154;
   label = 45;
   break;
  }
 case 384:
  {
   $124 = $s + 688 | 0;
   $247 = HEAP32[$124 >> 2] | 0;
   $250 = HEAP32[$124 + 4 >> 2] | 0;
   label = 45;
   break;
  }
 default:
  label = 44;
 } while (0);
 if ((label | 0) == 44) {
  $241 = $pval;
  HEAP32[$241 >> 2] = 0;
  HEAP32[$241 + 4 >> 2] = 0;
  $retval$0 = -1;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else if ((label | 0) == 45) {
  $245 = $pval;
  HEAP32[$245 >> 2] = $247;
  HEAP32[$245 + 4 >> 2] = $250;
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 return 0;
}
function _load_image_onload($opaque, $data, $size) {
 $opaque = $opaque | 0;
 $data = $data | 0;
 $size = $size | 0;
 var $$pr$i = 0, $$pr80$pr$i = 0, $105 = 0, $106 = 0, $107 = 0, $109 = 0, $110 = 0, $111 = 0, $113 = 0, $116 = 0, $122 = 0, $128 = 0, $129 = 0, $13 = 0, $136 = 0, $137 = 0, $138 = 0, $17 = 0, $21 = 0, $22 = 0, $24 = 0, $27 = 0, $3 = 0, $33 = 0, $39 = 0, $4 = 0, $40 = 0, $47 = 0, $48 = 0, $49 = 0, $5 = 0, $51 = 0, $53 = 0, $56 = 0, $62 = 0, $68 = 0, $69 = 0, $76 = 0, $77 = 0, $78 = 0, $80 = 0, $82 = 0, $85 = 0, $9 = 0, $91 = 0, $97 = 0, $98 = 0, $add$i = 0, $buf$i = 0, $call2$i = 0, $i$086$i = 0, $i$09$i$i$i = 0, $i$09$i$i10$i = 0, $i$09$i$i33$i = 0, $i$09$i$i57$i = 0, $inc$i$i$i = 0, $inc$i$i18$i = 0, $inc$i$i41$i = 0, $inc$i$i65$i = 0, $n_phys_mem_range$i$i$i = 0, $phys_mem$i24$i = 0, $vararg_buffer = 0, label = 0, sp = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 1056 | 0;
 $vararg_buffer = sp;
 $buf$i = sp + 32 | 0;
 if ((HEAP32[122] | 0) >>> 0 < $size >>> 0) {
  _puts(992) | 0;
  STACKTOP = sp;
  return;
 }
 _memcpy(HEAP32[(HEAP32[$opaque >> 2] | 0) + 728 >> 2] | 0, $data | 0, $size | 0) | 0;
 $3 = HEAP32[$opaque >> 2] | 0;
 $4 = HEAP32[122] | 0;
 $5 = $vararg_buffer;
 HEAP32[$5 >> 2] = 1073741824;
 HEAP32[$5 + 4 >> 2] = 0;
 $9 = $vararg_buffer + 8 | 0;
 HEAP32[$9 >> 2] = -2147483648;
 HEAP32[$9 + 4 >> 2] = 0;
 $13 = $vararg_buffer + 16 | 0;
 HEAP32[$13 >> 2] = $4;
 HEAP32[$13 + 4 >> 2] = 0;
 $17 = $vararg_buffer + 24 | 0;
 HEAP32[$17 >> 2] = 1073741832;
 HEAP32[$17 + 4 >> 2] = 0;
 _snprintf($buf$i, 1024, 512, $vararg_buffer) | 0;
 $n_phys_mem_range$i$i$i = $3 + 744 | 0;
 $21 = HEAP32[$n_phys_mem_range$i$i$i >> 2] | 0;
 L5 : do if (($21 | 0) > 0) {
  $i$09$i$i$i = 0;
  while (1) {
   $22 = $3 + ($i$09$i$i$i * 40 | 0) + 752 | 0;
   $24 = HEAP32[$22 >> 2] | 0;
   $27 = HEAP32[$22 + 4 >> 2] | 0;
   if (!($27 >>> 0 > 0 | ($27 | 0) == 0 & $24 >>> 0 > 4096)) {
    $33 = $3 + ($i$09$i$i$i * 40 | 0) + 760 | 0;
    $39 = _i64Add(HEAP32[$33 >> 2] | 0, HEAP32[$33 + 4 >> 2] | 0, $24 | 0, $27 | 0) | 0;
    $40 = tempRet0;
    if ($40 >>> 0 > 0 | ($40 | 0) == 0 & $39 >>> 0 > 4096) {
     label = 7;
     break;
    }
   }
   $inc$i$i$i = $i$09$i$i$i + 1 | 0;
   if (($inc$i$i$i | 0) < ($21 | 0)) $i$09$i$i$i = $inc$i$i$i; else {
    $$pr$i = $21;
    break;
   }
  }
  if ((label | 0) == 7) if (!(HEAP32[$3 + ($i$09$i$i$i * 40 | 0) + 768 >> 2] | 0)) $$pr$i = $21; else {
   $47 = HEAP32[$3 + 728 >> 2] | 0;
   $48 = HEAP32[$3 + ($i$09$i$i$i * 40 | 0) + 772 >> 2] | 0;
   $49 = _i64Subtract(4096, 0, $24 | 0, $27 | 0) | 0;
   HEAP32[$47 + ($48 + $49) >> 2] = 2147480215;
   $$pr$i = HEAP32[$n_phys_mem_range$i$i$i >> 2] | 0;
  }
  if (($$pr$i | 0) > 0) {
   $i$09$i$i57$i = 0;
   while (1) {
    $51 = $3 + ($i$09$i$i57$i * 40 | 0) + 752 | 0;
    $53 = HEAP32[$51 >> 2] | 0;
    $56 = HEAP32[$51 + 4 >> 2] | 0;
    if (!($56 >>> 0 > 0 | ($56 | 0) == 0 & $53 >>> 0 > 4100)) {
     $62 = $3 + ($i$09$i$i57$i * 40 | 0) + 760 | 0;
     $68 = _i64Add(HEAP32[$62 >> 2] | 0, HEAP32[$62 + 4 >> 2] | 0, $53 | 0, $56 | 0) | 0;
     $69 = tempRet0;
     if ($69 >>> 0 > 0 | ($69 | 0) == 0 & $68 >>> 0 > 4100) {
      label = 13;
      break;
     }
    }
    $inc$i$i65$i = $i$09$i$i57$i + 1 | 0;
    if (($inc$i$i65$i | 0) < ($$pr$i | 0)) $i$09$i$i57$i = $inc$i$i65$i; else {
     $$pr80$pr$i = $$pr$i;
     break;
    }
   }
   if ((label | 0) == 13) if (!(HEAP32[$3 + ($i$09$i$i57$i * 40 | 0) + 768 >> 2] | 0)) $$pr80$pr$i = $$pr$i; else {
    $76 = HEAP32[$3 + 728 >> 2] | 0;
    $77 = HEAP32[$3 + ($i$09$i$i57$i * 40 | 0) + 772 >> 2] | 0;
    $78 = _i64Subtract(4100, 0, $53 | 0, $56 | 0) | 0;
    HEAP32[$76 + ($77 + $78) >> 2] = 163943;
    $$pr80$pr$i = HEAP32[$n_phys_mem_range$i$i$i >> 2] | 0;
   }
   if (($$pr80$pr$i | 0) > 0) {
    $i$09$i$i33$i = 0;
    while (1) {
     $80 = $3 + ($i$09$i$i33$i * 40 | 0) + 752 | 0;
     $82 = HEAP32[$80 >> 2] | 0;
     $85 = HEAP32[$80 + 4 >> 2] | 0;
     if (!($85 >>> 0 > 0 | ($85 | 0) == 0 & $82 >>> 0 > 4108)) {
      $91 = $3 + ($i$09$i$i33$i * 40 | 0) + 760 | 0;
      $97 = _i64Add(HEAP32[$91 >> 2] | 0, HEAP32[$91 + 4 >> 2] | 0, $82 | 0, $85 | 0) | 0;
      $98 = tempRet0;
      if ($98 >>> 0 > 0 | ($98 | 0) == 0 & $97 >>> 0 > 4108) break;
     }
     $inc$i$i41$i = $i$09$i$i33$i + 1 | 0;
     if (($inc$i$i41$i | 0) < ($$pr80$pr$i | 0)) $i$09$i$i33$i = $inc$i$i41$i; else break L5;
    }
    if (HEAP32[$3 + ($i$09$i$i33$i * 40 | 0) + 768 >> 2] | 0) {
     $105 = HEAP32[$3 + 728 >> 2] | 0;
     $106 = HEAP32[$3 + ($i$09$i$i33$i * 40 | 0) + 772 >> 2] | 0;
     $107 = _i64Subtract(4108, 0, $82 | 0, $85 | 0) | 0;
     HEAP32[$105 + ($106 + $107) >> 2] = 4128;
    }
   }
  }
 } while (0);
 $call2$i = _strlen($buf$i | 0) | 0;
 if (($call2$i | 0) > 0) {
  $phys_mem$i24$i = $3 + 728 | 0;
  $i$086$i = 0;
  do {
   $add$i = $i$086$i + 4128 | 0;
   $109 = HEAP8[$buf$i + $i$086$i >> 0] | 0;
   $110 = HEAP32[$n_phys_mem_range$i$i$i >> 2] | 0;
   L36 : do if (($110 | 0) > 0) {
    $i$09$i$i10$i = 0;
    while (1) {
     $111 = $3 + ($i$09$i$i10$i * 40 | 0) + 752 | 0;
     $113 = HEAP32[$111 >> 2] | 0;
     $116 = HEAP32[$111 + 4 >> 2] | 0;
     if (!($116 >>> 0 > 0 | ($116 | 0) == 0 & $113 >>> 0 > $add$i >>> 0)) {
      $122 = $3 + ($i$09$i$i10$i * 40 | 0) + 760 | 0;
      $128 = _i64Add(HEAP32[$122 >> 2] | 0, HEAP32[$122 + 4 >> 2] | 0, $113 | 0, $116 | 0) | 0;
      $129 = tempRet0;
      if ($129 >>> 0 > 0 | ($129 | 0) == 0 & $128 >>> 0 > $add$i >>> 0) break;
     }
     $inc$i$i18$i = $i$09$i$i10$i + 1 | 0;
     if (($inc$i$i18$i | 0) < ($110 | 0)) $i$09$i$i10$i = $inc$i$i18$i; else break L36;
    }
    if (HEAP32[$3 + ($i$09$i$i10$i * 40 | 0) + 768 >> 2] | 0) {
     $136 = HEAP32[$phys_mem$i24$i >> 2] | 0;
     $137 = HEAP32[$3 + ($i$09$i$i10$i * 40 | 0) + 772 >> 2] | 0;
     $138 = _i64Subtract($add$i | 0, 0, $113 | 0, $116 | 0) | 0;
     HEAP8[$136 + ($137 + $138) >> 0] = $109;
    }
   } while (0);
   $i$086$i = $i$086$i + 1 | 0;
  } while (($i$086$i | 0) != ($call2$i | 0));
 }
 _emscripten_async_call(2, $opaque | 0, 0);
 STACKTOP = sp;
 return;
}
function _raise_exception2($s, $cause, $0, $1) {
 $s = $s | 0;
 $cause = $cause | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 var $101 = 0, $105 = 0, $11 = 0, $110 = 0, $111 = 0, $115 = 0, $119 = 0, $121 = 0, $124 = 0, $127 = 0, $129 = 0, $13 = 0, $133 = 0, $134 = 0, $138 = 0, $139 = 0, $142 = 0, $144 = 0, $145 = 0, $149 = 0, $153 = 0, $157 = 0, $161 = 0, $165 = 0, $170 = 0, $171 = 0, $175 = 0, $19 = 0, $22 = 0, $25 = 0, $27 = 0, $30 = 0, $31 = 0, $36 = 0, $37 = 0, $4 = 0, $41 = 0, $45 = 0, $47 = 0, $5 = 0, $50 = 0, $53 = 0, $55 = 0, $59 = 0, $60 = 0, $64 = 0, $65 = 0, $68 = 0, $70 = 0, $71 = 0, $75 = 0, $79 = 0, $83 = 0, $87 = 0, $91 = 0, $96 = 0, $97 = 0, $and21 = 0, $conv100 = 0, $conv109 = 0, $conv57 = 0, $conv65 = 0, $cur_xlen56 = 0, $cur_xlen99 = 0, $deleg$0 = 0, $deleg$083 = 0, $i$07$i$i$i = 0, $i$07$i$i$i69 = 0, $mstatus = 0, $mstatus76 = 0, $priv = 0, label = 0, sp = 0;
 sp = STACKTOP;
 if ($cause >>> 0 < 8) $175 = ((-13 & 255) >>> ($cause & 255) & 1) != 0; else $175 = 0;
 $priv = $s + 526 | 0;
 $4 = HEAP8[$priv >> 0] | 0;
 do if (($4 & 255) < 2) if (($cause | 0) < 0) {
  $5 = $s + 640 | 0;
  $11 = _bitshift64Lshr(HEAP32[$5 >> 2] | 0, HEAP32[$5 + 4 >> 2] | 0, $cause & 63 | 0) | 0;
  $deleg$0 = $11 & 1;
  label = 7;
  break;
 } else {
  $13 = $s + 632 | 0;
  $19 = _bitshift64Lshr(HEAP32[$13 >> 2] | 0, HEAP32[$13 + 4 >> 2] | 0, $cause | 0) | 0;
  $27 = $cause & 2147483647;
  $30 = 0;
  $deleg$083 = $19 & 1;
  break;
 } else {
  $deleg$0 = 0;
  label = 7;
 } while (0);
 if ((label | 0) == 7) {
  $and21 = $cause & 2147483647;
  if (($cause | 0) < 0) {
   $22 = _bitshift64Shl(1, 0, (HEAPU8[$s + 525 >> 0] | 0) + -1 | 0) | 0;
   $27 = $22 | $and21;
   $30 = tempRet0;
   $deleg$083 = $deleg$0;
  } else {
   $27 = $and21;
   $30 = 0;
   $deleg$083 = $deleg$0;
  }
 }
 if (!$deleg$083) {
  $101 = $s + 592 | 0;
  HEAP32[$101 >> 2] = $27;
  HEAP32[$101 + 4 >> 2] = $30;
  $105 = $s;
  $110 = HEAP32[$105 + 4 >> 2] | 0;
  $111 = $s + 584 | 0;
  HEAP32[$111 >> 2] = HEAP32[$105 >> 2];
  HEAP32[$111 + 4 >> 2] = $110;
  if ($175) {
   $115 = $s + 600 | 0;
   HEAP32[$115 >> 2] = $0;
   HEAP32[$115 + 4 >> 2] = $1;
  }
  $mstatus76 = $s + 552 | 0;
  $119 = $mstatus76;
  $121 = HEAP32[$119 >> 2] | 0;
  $124 = HEAP32[$119 + 4 >> 2] | 0;
  $127 = _bitshift64Lshr($121 | 0, $124 | 0, $4 & 255 | 0) | 0;
  $129 = _bitshift64Shl($127 | 0, tempRet0 | 0, 7) | 0;
  $133 = $129 & 128 | $121 & -6281 | ($4 & 255) << 11;
  $134 = $mstatus76;
  HEAP32[$134 >> 2] = $133;
  HEAP32[$134 + 4 >> 2] = $124;
  $138 = $133 & -9;
  $139 = $124 & -16385;
  $cur_xlen99 = $s + 525 | 0;
  $conv100 = HEAPU8[$cur_xlen99 >> 0] | 0;
  if (($conv100 | 0) == 32) {
   $142 = 0;
   $144 = 16384;
  } else if (($conv100 | 0) == 64) {
   $142 = 0;
   $144 = 32768;
  } else {
   $142 = 0;
   $144 = 49152;
  }
  $145 = $mstatus76;
  HEAP32[$145 >> 2] = $142 | $138;
  HEAP32[$145 + 4 >> 2] = $144 | $139;
  $149 = _bitshift64Lshr($121 | 0, $124 | 0, 38) | 0;
  $conv109 = $149 & 3;
  HEAP8[$cur_xlen99 >> 0] = ($conv109 + -1 | 0) >>> 0 > 1 ? 64 : 1 << ($conv109 | 4) & 255;
  if ($4 << 24 >> 24 != 3) {
   $i$07$i$i$i = 0;
   do {
    $153 = $s + ($i$07$i$i$i << 4) + 1400 | 0;
    HEAP32[$153 >> 2] = -1;
    HEAP32[$153 + 4 >> 2] = -1;
    $157 = $s + ($i$07$i$i$i << 4) + 5496 | 0;
    HEAP32[$157 >> 2] = -1;
    HEAP32[$157 + 4 >> 2] = -1;
    $161 = $s + ($i$07$i$i$i << 4) + 9592 | 0;
    HEAP32[$161 >> 2] = -1;
    HEAP32[$161 + 4 >> 2] = -1;
    $i$07$i$i$i = $i$07$i$i$i + 1 | 0;
   } while (($i$07$i$i$i | 0) != 256);
   HEAP8[$priv >> 0] = 3;
  }
  $165 = $s + 568 | 0;
  $170 = HEAP32[$165 + 4 >> 2] | 0;
  $171 = $s;
  HEAP32[$171 >> 2] = HEAP32[$165 >> 2];
  HEAP32[$171 + 4 >> 2] = $170;
  STACKTOP = sp;
  return;
 } else {
  $25 = $s + 672 | 0;
  HEAP32[$25 >> 2] = $27;
  HEAP32[$25 + 4 >> 2] = $30;
  $31 = $s;
  $36 = HEAP32[$31 + 4 >> 2] | 0;
  $37 = $s + 664 | 0;
  HEAP32[$37 >> 2] = HEAP32[$31 >> 2];
  HEAP32[$37 + 4 >> 2] = $36;
  if ($175) {
   $41 = $s + 680 | 0;
   HEAP32[$41 >> 2] = $0;
   HEAP32[$41 + 4 >> 2] = $1;
  }
  $mstatus = $s + 552 | 0;
  $45 = $mstatus;
  $47 = HEAP32[$45 >> 2] | 0;
  $50 = HEAP32[$45 + 4 >> 2] | 0;
  $53 = _bitshift64Lshr($47 | 0, $50 | 0, $4 & 255 | 0) | 0;
  $55 = _bitshift64Shl($53 | 0, tempRet0 | 0, 5) | 0;
  $59 = $55 & 32 | $47 & -291 | ($4 & 255) << 8;
  $60 = $mstatus;
  HEAP32[$60 >> 2] = $59;
  HEAP32[$60 + 4 >> 2] = $50;
  $64 = $59 & -3;
  $65 = $50 & -1025;
  $cur_xlen56 = $s + 525 | 0;
  $conv57 = HEAPU8[$cur_xlen56 >> 0] | 0;
  if (($conv57 | 0) == 64) {
   $68 = 0;
   $70 = 2048;
  } else if (($conv57 | 0) == 32) {
   $68 = 0;
   $70 = 1024;
  } else {
   $68 = 0;
   $70 = 3072;
  }
  $71 = $mstatus;
  HEAP32[$71 >> 2] = $68 | $64;
  HEAP32[$71 + 4 >> 2] = $70 | $65;
  $75 = _bitshift64Lshr($47 | 0, $50 | 0, 34) | 0;
  $conv65 = $75 & 3;
  HEAP8[$cur_xlen56 >> 0] = ($conv65 + -1 | 0) >>> 0 > 1 ? 64 : 1 << ($conv65 | 4) & 255;
  if ($4 << 24 >> 24 != 1) {
   $i$07$i$i$i69 = 0;
   do {
    $79 = $s + ($i$07$i$i$i69 << 4) + 1400 | 0;
    HEAP32[$79 >> 2] = -1;
    HEAP32[$79 + 4 >> 2] = -1;
    $83 = $s + ($i$07$i$i$i69 << 4) + 5496 | 0;
    HEAP32[$83 >> 2] = -1;
    HEAP32[$83 + 4 >> 2] = -1;
    $87 = $s + ($i$07$i$i$i69 << 4) + 9592 | 0;
    HEAP32[$87 >> 2] = -1;
    HEAP32[$87 + 4 >> 2] = -1;
    $i$07$i$i$i69 = $i$07$i$i$i69 + 1 | 0;
   } while (($i$07$i$i$i69 | 0) != 256);
   HEAP8[$priv >> 0] = 1;
  }
  $91 = $s + 648 | 0;
  $96 = HEAP32[$91 + 4 >> 2] | 0;
  $97 = $s;
  HEAP32[$97 >> 2] = HEAP32[$91 >> 2];
  HEAP32[$97 + 4 >> 2] = $96;
  STACKTOP = sp;
  return;
 }
}
function _sqrt_sf64($0, $1, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $100 = 0, $101 = 0, $102 = 0, $103 = 0, $105 = 0, $106 = 0, $118 = 0, $119 = 0, $120 = 0, $122 = 0, $123 = 0, $124 = 0, $126 = 0, $128 = 0, $129 = 0, $2 = 0, $22 = 0, $24 = 0, $27 = 0, $28 = 0, $29 = 0, $31 = 0, $32 = 0, $33 = 0, $34 = 0, $38 = 0, $4 = 0, $40 = 0, $42 = 0, $44 = 0, $47 = 0, $51 = 0, $52 = 0, $53 = 0, $54 = 0, $55 = 0, $56 = 0, $57 = 0, $59 = 0, $6 = 0, $60 = 0, $76 = 0, $80 = 0, $82 = 0, $83 = 0, $89 = 0, $90 = 0, $91 = 0, $92 = 0, $93 = 0, $94 = 0, $95 = 0, $96 = 0, $97 = 0, $98 = 0, $add = 0, $cmp15 = 0, $conv2 = 0, $i$02$i$i = 0, $or$cond$i$i = 0, $sub = 0, $sub2$i32 = 0, $sub2$i33 = 0, $sub8$i = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $2 = _bitshift64Lshr($0 | 0, $1 | 0, 63) | 0;
 $4 = _bitshift64Lshr($0 | 0, $1 | 0, 52) | 0;
 $conv2 = $4 & 2047;
 $6 = $1 & 1048575;
 do if (($conv2 | 0) == 2047) {
  if (($0 | 0) == 0 & ($6 | 0) == 0) {
   if (!$2) {
    $128 = $1;
    $129 = $0;
   } else break;
   tempRet0 = $128;
   STACKTOP = sp;
   return $129 | 0;
  }
  if (!(0 == 0 & ($1 & 2146959360 | 0) == 2146435072)) {
   $128 = 2146959360;
   $129 = 0;
   tempRet0 = $128;
   STACKTOP = sp;
   return $129 | 0;
  }
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $128 = 2146959360;
  $129 = 0;
  tempRet0 = $128;
  STACKTOP = sp;
  return $129 | 0;
 } else {
  $cmp15 = ($conv2 | 0) == 0;
  if ($2) {
   if ($cmp15 & (($0 | 0) == 0 & ($6 | 0) == 0)) {
    $128 = $1;
    $129 = $0;
   } else break;
   tempRet0 = $128;
   STACKTOP = sp;
   return $129 | 0;
  }
  do if ($cmp15) if (($0 | 0) == 0 & ($6 | 0) == 0) {
   $128 = 0;
   $129 = 0;
   tempRet0 = $128;
   STACKTOP = sp;
   return $129 | 0;
  } else {
   $22 = _llvm_ctlz_i64($0 | 0, $6 | 0, 0) | 0;
   $24 = _bitshift64Shl($0 | 0, $6 | 0, $22 + -11 | 0) | 0;
   $27 = $24;
   $28 = tempRet0;
   $sub2$i33 = 12 - $22 | 0;
   break;
  } else {
   $27 = $0;
   $28 = $6 | 1048576;
   $sub2$i33 = $conv2;
  } while (0);
  $sub = $sub2$i33 + -1023 | 0;
  if (!($sub & 1)) {
   $31 = $27;
   $32 = $28;
   $sub2$i32 = $sub;
  } else {
   $29 = _bitshift64Shl($27 | 0, $28 | 0, 1) | 0;
   $31 = $29;
   $32 = tempRet0;
   $sub2$i32 = $sub2$i33 + -1024 | 0;
  }
  $add = ($sub2$i32 >> 1) + 1023 | 0;
  $33 = _bitshift64Shl($31 | 0, $32 | 0, 8) | 0;
  $34 = tempRet0;
  do if (($33 | 0) == 0 & ($34 | 0) == 0) {
   $122 = 0;
   $123 = 0;
   $sub8$i = 63;
  } else {
   $38 = _i64Add($33 | 0, $34 | 0, -1, -1) | 0;
   $40 = _llvm_ctlz_i64($38 | 0, tempRet0 | 0, 0) | 0;
   $42 = _bitshift64Shl(1, 0, (129 - $40 | 0) >>> 1 | 0) | 0;
   $44 = tempRet0;
   $47 = $42;
   while (1) {
    if ($44 >>> 0 > $34 >>> 0 | ($44 | 0) == ($34 | 0) & $47 >>> 0 > $33 >>> 0) {
     $51 = $33;
     $52 = $34;
     $55 = 0;
     $56 = 0;
     $i$02$i$i = 0;
    } else {
     label = 18;
     break;
    }
    do {
     $53 = _bitshift64Shl($51 | 0, $52 | 0, 1) | 0;
     $54 = tempRet0;
     $57 = _bitshift64Lshr($55 | 0, $56 | 0, 63) | 0;
     $59 = $57 | $53;
     $60 = tempRet0 | $54;
     $or$cond$i$i = (($52 | 0) > -1 | ($52 | 0) == -1 & $51 >>> 0 > 4294967295) & ($60 >>> 0 < $44 >>> 0 | ($60 | 0) == ($44 | 0) & $59 >>> 0 < $47 >>> 0);
     $51 = _i64Subtract($59 | 0, $60 | 0, ($or$cond$i$i ? 0 : $47) | 0, ($or$cond$i$i ? 0 : $44) | 0) | 0;
     $52 = tempRet0;
     $76 = _bitshift64Shl($55 | 0, $56 | 0, 1) | 0;
     $56 = tempRet0;
     $55 = ($or$cond$i$i & 1 | $76) ^ 1;
     $i$02$i$i = $i$02$i$i + 1 | 0;
    } while (($i$02$i$i | 0) != 64);
    $80 = _i64Add($55 | 0, $56 | 0, $47 | 0, $44 | 0) | 0;
    $82 = _bitshift64Lshr($80 | 0, tempRet0 | 0, 1) | 0;
    $83 = tempRet0;
    if ($83 >>> 0 < $44 >>> 0 | ($83 | 0) == ($44 | 0) & $82 >>> 0 < $47 >>> 0) {
     $44 = $83;
     $47 = $82;
    } else break;
   }
   if ((label | 0) == 18) ___assert_fail(1056, 1064, 571, 1088);
   $89 = ___muldi3($47 | 0, 0, $47 | 0, 0) | 0;
   $90 = tempRet0;
   $91 = ___muldi3($44 | 0, 0, $47 | 0, 0) | 0;
   $92 = tempRet0;
   $93 = ___muldi3($44 | 0, 0, $44 | 0, 0) | 0;
   $94 = tempRet0;
   $95 = _i64Add($90 | 0, 0, $91 | 0, 0) | 0;
   $96 = tempRet0;
   _i64Add($95 | 0, $96 | 0, $91 | 0, 0) | 0;
   $97 = tempRet0;
   $98 = _bitshift64Shl($92 | 0, 0, 1) | 0;
   $100 = _i64Add($97 | 0, 0, $98 | 0, tempRet0 | 0) | 0;
   $101 = tempRet0;
   _i64Add($100 | 0, $101 | 0, $93 | 0, 0) | 0;
   $102 = tempRet0;
   $103 = _i64Add($95 | 0, $96 | 0, $91 | 0, $92 | 0) | 0;
   _i64Add(0, $102 | 0, $93 | 0, $94 | 0) | 0;
   $105 = tempRet0;
   $106 = _i64Add($100 | 0, $101 | 0, $93 | 0, $94 | 0) | 0;
   if (($106 | 0) != ($33 | 0) | ($105 | 0) != ($34 | 0) | (($89 | 0) != 0 | ($103 | 0) != 0)) {
    $118 = $47 | 1;
    $119 = $44;
   } else if (($47 | 0) == 0 & ($44 | 0) == 0) {
    $122 = 0;
    $123 = 0;
    $sub8$i = 63;
    break;
   } else {
    $118 = $47;
    $119 = $44;
   }
   $120 = _llvm_ctlz_i64($118 | 0, $119 | 0, 0) | 0;
   if (!$120) ___assert_fail(1104, 1064, 183, 1136); else {
    $122 = $118;
    $123 = $119;
    $sub8$i = $120 + -1 | 0;
   }
  } while (0);
  $124 = _bitshift64Shl($122 | 0, $123 | 0, $sub8$i | 0) | 0;
  $126 = _roundpack_sf64(0, $add - $sub8$i | 0, $124, tempRet0, $rm, $pfflags) | 0;
  $128 = tempRet0;
  $129 = $126;
  tempRet0 = $128;
  STACKTOP = sp;
  return $129 | 0;
 } while (0);
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $128 = 2146959360;
 $129 = 0;
 tempRet0 = $128;
 STACKTOP = sp;
 return $129 | 0;
}
function _div_sf64($0, $1, $2, $3, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $10 = 0, $101 = 0, $102 = 0, $114 = 0, $115 = 0, $118 = 0, $12 = 0, $124 = 0, $126 = 0, $127 = 0, $13 = 0, $131 = 0, $133 = 0, $135 = 0, $137 = 0, $138 = 0, $37 = 0, $55 = 0, $6 = 0, $63 = 0, $64 = 0, $67 = 0, $69 = 0, $7 = 0, $75 = 0, $77 = 0, $79 = 0, $8 = 0, $82 = 0, $83 = 0, $84 = 0, $85 = 0, $86 = 0, $89 = 0, $93 = 0, $94 = 0, $95 = 0, $96 = 0, $97 = 0, $98 = 0, $99 = 0, $conv4 = 0, $conv7 = 0, $i$02$i = 0, $or$cond$i = 0, $sub2$i6491 = 0, $sub2$i92 = 0, $sub8$i = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $6 = _bitshift64Lshr($2 ^ $0 | 0, $3 ^ $1 | 0, 63) | 0;
 $7 = tempRet0;
 $8 = _bitshift64Lshr($0 | 0, $1 | 0, 52) | 0;
 $conv4 = $8 & 2047;
 $10 = _bitshift64Lshr($2 | 0, $3 | 0, 52) | 0;
 $conv7 = $10 & 2047;
 $12 = $1 & 1048575;
 $13 = $3 & 1048575;
 if (($conv4 | 0) == 2047) {
  if (($0 | 0) == 0 & ($12 | 0) == 0) if (0 == 0 & ($3 & 2146435072 | 0) == 2146435072 & (($2 | 0) != 0 | ($13 | 0) != 0)) label = 5; else if (($conv7 | 0) == 2047) {
   HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
   $137 = 2146959360;
   $138 = 0;
   tempRet0 = $137;
   STACKTOP = sp;
   return $138 | 0;
  } else {
   $37 = _bitshift64Shl($6 | 0, $7 | 0, 63) | 0;
   $137 = tempRet0 | 2146435072;
   $138 = $37;
   tempRet0 = $137;
   STACKTOP = sp;
   return $138 | 0;
  } else if (!(0 == 0 & ($1 & 2146959360 | 0) == 2146435072)) label = 5;
  if ((label | 0) == 5) if (!(0 == 0 & ($3 & 2146959360 | 0) == 2146435072 & (($2 | 0) != 0 | ($13 | 0) != 0))) {
   $137 = 2146959360;
   $138 = 0;
   tempRet0 = $137;
   STACKTOP = sp;
   return $138 | 0;
  }
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $137 = 2146959360;
  $138 = 0;
  tempRet0 = $137;
  STACKTOP = sp;
  return $138 | 0;
 }
 do if (!$conv7) {
  if (!(($2 | 0) == 0 & ($13 | 0) == 0)) {
   $67 = _llvm_ctlz_i64($2 | 0, $13 | 0, 0) | 0;
   $69 = _bitshift64Shl($2 | 0, $13 | 0, $67 + -11 | 0) | 0;
   $82 = $69;
   $83 = tempRet0;
   $sub2$i6491 = 12 - $67 | 0;
   break;
  }
  $63 = HEAP32[$pfflags >> 2] | 0;
  if (($conv4 | 0) == 0 & (($0 | 0) == 0 & ($12 | 0) == 0)) {
   HEAP32[$pfflags >> 2] = $63 | 1;
   $137 = 2146959360;
   $138 = 0;
   tempRet0 = $137;
   STACKTOP = sp;
   return $138 | 0;
  } else {
   HEAP32[$pfflags >> 2] = $63 | 8;
   $64 = _bitshift64Shl($6 | 0, $7 | 0, 63) | 0;
   $137 = tempRet0 | 2146435072;
   $138 = $64;
   tempRet0 = $137;
   STACKTOP = sp;
   return $138 | 0;
  }
 } else if (($conv7 | 0) == 2047) {
  if (($2 | 0) == 0 & ($13 | 0) == 0) {
   $55 = _bitshift64Shl($6 | 0, $7 | 0, 63) | 0;
   $137 = tempRet0;
   $138 = $55;
   tempRet0 = $137;
   STACKTOP = sp;
   return $138 | 0;
  }
  if (!(0 == 0 & ($1 & 2146959360 | 0) == 2146435072 & (($0 | 0) != 0 | ($12 | 0) != 0))) if (!(0 == 0 & ($3 & 2146959360 | 0) == 2146435072)) {
   $137 = 2146959360;
   $138 = 0;
   tempRet0 = $137;
   STACKTOP = sp;
   return $138 | 0;
  }
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $137 = 2146959360;
  $138 = 0;
  tempRet0 = $137;
  STACKTOP = sp;
  return $138 | 0;
 } else {
  $82 = $2;
  $83 = $13 | 1048576;
  $sub2$i6491 = $conv7;
 } while (0);
 do if (!$conv4) {
  if (!(($0 | 0) == 0 & ($12 | 0) == 0)) {
   $77 = _llvm_ctlz_i64($0 | 0, $12 | 0, 0) | 0;
   $79 = _bitshift64Shl($0 | 0, $12 | 0, $77 + -11 | 0) | 0;
   $86 = tempRet0;
   $89 = $79;
   $sub2$i92 = 12 - $77 | 0;
   break;
  }
  $75 = _bitshift64Shl($6 | 0, $7 | 0, 63) | 0;
  $137 = tempRet0;
  $138 = $75;
  tempRet0 = $137;
  STACKTOP = sp;
  return $138 | 0;
 } else {
  $86 = $12 | 1048576;
  $89 = $0;
  $sub2$i92 = $conv4;
 } while (0);
 $84 = _bitshift64Shl($82 | 0, $83 | 0, 2) | 0;
 $85 = tempRet0;
 if ($86 >>> 0 < $85 >>> 0 | ($86 | 0) == ($85 | 0) & $89 >>> 0 < $84 >>> 0) {
  $93 = $89;
  $94 = $86;
  $97 = 0;
  $98 = 0;
  $i$02$i = 0;
 } else ___assert_fail(1056, 1064, 571, 1088);
 do {
  $95 = _bitshift64Shl($93 | 0, $94 | 0, 1) | 0;
  $96 = tempRet0;
  $99 = _bitshift64Lshr($97 | 0, $98 | 0, 63) | 0;
  $101 = $99 | $95;
  $102 = tempRet0 | $96;
  $or$cond$i = (($94 | 0) > -1 | ($94 | 0) == -1 & $93 >>> 0 > 4294967295) & ($102 >>> 0 < $85 >>> 0 | ($102 | 0) == ($85 | 0) & $101 >>> 0 < $84 >>> 0);
  $114 = $or$cond$i ? 0 : $84;
  $115 = $or$cond$i ? 0 : $85;
  $93 = _i64Subtract($101 | 0, $102 | 0, $114 | 0, $115 | 0) | 0;
  $94 = tempRet0;
  $118 = _bitshift64Shl($97 | 0, $98 | 0, 1) | 0;
  $98 = tempRet0;
  $97 = ($or$cond$i & 1 | $118) ^ 1;
  $i$02$i = $i$02$i + 1 | 0;
 } while (($i$02$i | 0) != 64);
 $124 = ($101 | 0) == ($114 | 0) & ($102 | 0) == ($115 | 0);
 $126 = $124 ? $97 : $118 | 1;
 $127 = $124 ? $98 : $98;
 if (($126 | 0) == 0 & ($127 | 0) == 0) $sub8$i = 63; else {
  $131 = _llvm_ctlz_i64($126 | 0, $127 | 0, 0) | 0;
  if (!$131) ___assert_fail(1104, 1064, 183, 1136); else $sub8$i = $131 + -1 | 0;
 }
 $133 = _bitshift64Shl($126 | 0, $127 | 0, $sub8$i | 0) | 0;
 $135 = _roundpack_sf64($6, 1023 - $sub2$i6491 + $sub2$i92 - $sub8$i | 0, $133, tempRet0, $rm, $pfflags) | 0;
 $137 = tempRet0;
 $138 = $135;
 tempRet0 = $137;
 STACKTOP = sp;
 return $138 | 0;
}
function _target_write_slow($s, $0, $1, $2, $3, $size_log2) {
 $s = $s | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $size_log2 = $size_log2 | 0;
 var $13 = 0, $14 = 0, $15 = 0, $17 = 0, $19 = 0, $33 = 0, $35 = 0, $37 = 0, $40 = 0, $41 = 0, $42 = 0, $44 = 0, $47 = 0, $53 = 0, $59 = 0, $60 = 0, $67 = 0, $69 = 0, $70 = 0, $71 = 0, $74 = 0, $79 = 0, $83 = 0, $87 = 0, $88 = 0, $89 = 0, $94 = 0, $95 = 0, $96 = 0, $add$ptr24 = 0, $conv$i = 0, $conv20 = 0, $i$060 = 0, $i$09$i = 0, $inc$i = 0, $opaque53 = 0, $paddr = 0, $retval$0 = 0, $shl = 0, $sub = 0, $write_func52 = 0, label = 0, sp = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 16 | 0;
 $paddr = sp;
 $shl = 1 << $size_log2;
 $sub = $shl + -1 | 0;
 if (!(($sub & $0 | 0) == 0 & ((($sub | 0) < 0) << 31 >> 31 & $1 | 0) == 0)) {
  if (($shl | 0) > 0) $i$060 = 0; else {
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  while (1) {
   $13 = _i64Add($i$060 | 0, (($i$060 | 0) < 0) << 31 >> 31 | 0, $0 | 0, $1 | 0) | 0;
   $14 = tempRet0;
   $15 = _bitshift64Lshr($2 | 0, $3 | 0, $i$060 << 3 | 0) | 0;
   $17 = _bitshift64Lshr($13 | 0, $14 | 0, 12) | 0;
   $conv$i = $17 & 255;
   $19 = $s + ($conv$i << 4) + 5496 | 0;
   if ((HEAP32[$19 >> 2] | 0) == ($13 & -4089 | 0) ? (HEAP32[$19 + 4 >> 2] | 0) == ($14 | 0) : 0) HEAP8[(HEAP32[$s + ($conv$i << 4) + 5504 >> 2] | 0) + $13 >> 0] = $15; else {
    $33 = _target_write_slow($s, $13, $14, $15 & 255, 0, 0) | 0;
    if ($33) {
     $retval$0 = $33;
     label = 24;
     break;
    }
   }
   $i$060 = $i$060 + 1 | 0;
   if (($i$060 | 0) >= ($shl | 0)) {
    $retval$0 = 0;
    label = 24;
    break;
   }
  }
  if ((label | 0) == 24) {
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 }
 if (_get_phys_addr($s, $paddr, $0, $1, 1) | 0) {
  _raise_exception2($s, 7, $0, $1);
  $retval$0 = -1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 $35 = $paddr;
 $37 = HEAP32[$35 >> 2] | 0;
 $40 = HEAP32[$35 + 4 >> 2] | 0;
 $41 = HEAP32[$s + 744 >> 2] | 0;
 if (($41 | 0) > 0) $i$09$i = 0; else {
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 while (1) {
  $42 = $s + ($i$09$i * 40 | 0) + 752 | 0;
  $44 = HEAP32[$42 >> 2] | 0;
  $47 = HEAP32[$42 + 4 >> 2] | 0;
  if (!($47 >>> 0 > $40 >>> 0 | ($47 | 0) == ($40 | 0) & $44 >>> 0 > $37 >>> 0)) {
   $53 = $s + ($i$09$i * 40 | 0) + 760 | 0;
   $59 = _i64Add(HEAP32[$53 >> 2] | 0, HEAP32[$53 + 4 >> 2] | 0, $44 | 0, $47 | 0) | 0;
   $60 = tempRet0;
   if ($60 >>> 0 > $40 >>> 0 | ($60 | 0) == ($40 | 0) & $59 >>> 0 > $37 >>> 0) break;
  }
  $inc$i = $i$09$i + 1 | 0;
  if (($inc$i | 0) < ($41 | 0)) $i$09$i = $inc$i; else {
   $retval$0 = 0;
   label = 24;
   break;
  }
 }
 if ((label | 0) == 24) {
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 if (!(HEAP32[$s + ($i$09$i * 40 | 0) + 768 >> 2] | 0)) {
  $87 = _i64Subtract($37 | 0, $40 | 0, $44 | 0, $47 | 0) | 0;
  $88 = tempRet0;
  $89 = HEAP32[$s + ($i$09$i * 40 | 0) + 788 >> 2] | 0;
  if ($89 & $shl) {
   FUNCTION_TABLE_viiiiii[HEAP32[$s + ($i$09$i * 40 | 0) + 784 >> 2] & 7](HEAP32[$s + ($i$09$i * 40 | 0) + 776 >> 2] | 0, $87, $88, $2, $3, $size_log2);
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if (!(($89 & 4 | 0) != 0 & ($size_log2 | 0) == 3)) {
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  $write_func52 = $s + ($i$09$i * 40 | 0) + 784 | 0;
  $opaque53 = $s + ($i$09$i * 40 | 0) + 776 | 0;
  FUNCTION_TABLE_viiiiii[HEAP32[$write_func52 >> 2] & 7](HEAP32[$opaque53 >> 2] | 0, $87, $88, $2, 0, 2);
  $94 = HEAP32[$write_func52 >> 2] | 0;
  $95 = HEAP32[$opaque53 >> 2] | 0;
  $96 = _i64Add($87 | 0, $88 | 0, 4, 0) | 0;
  FUNCTION_TABLE_viiiiii[$94 & 7]($95, $96, tempRet0, $3, 0, 2);
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 $67 = _bitshift64Lshr($0 | 0, $1 | 0, 12) | 0;
 $conv20 = $67 & 255;
 $69 = HEAP32[$s + 728 >> 2] | 0;
 $70 = HEAP32[$s + ($i$09$i * 40 | 0) + 772 >> 2] | 0;
 $71 = _i64Subtract($37 | 0, $40 | 0, $44 | 0, $47 | 0) | 0;
 $add$ptr24 = $69 + ($71 + $70) | 0;
 $74 = $s + ($conv20 << 4) + 5496 | 0;
 HEAP32[$74 >> 2] = $0 & -4096;
 HEAP32[$74 + 4 >> 2] = $1;
 $79 = _i64Subtract($add$ptr24 | 0, 0, $0 | 0, $1 | 0) | 0;
 HEAP32[$s + ($conv20 << 4) + 5504 >> 2] = $79;
 if (!$size_log2) {
  HEAP8[$add$ptr24 >> 0] = $2;
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else if (($size_log2 | 0) == 2) {
  HEAP32[$add$ptr24 >> 2] = $2;
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else if (($size_log2 | 0) == 1) {
  HEAP16[$add$ptr24 >> 1] = $2;
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else if (($size_log2 | 0) == 3) {
  $83 = $add$ptr24;
  HEAP32[$83 >> 2] = $2;
  HEAP32[$83 + 4 >> 2] = $3;
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else _abort();
 return 0;
}
function _mul_sf64($0, $1, $2, $3, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $10 = 0, $100 = 0, $101 = 0, $102 = 0, $105 = 0, $106 = 0, $112 = 0, $116 = 0, $118 = 0, $12 = 0, $120 = 0, $122 = 0, $123 = 0, $13 = 0, $20 = 0, $47 = 0, $53 = 0, $55 = 0, $57 = 0, $6 = 0, $63 = 0, $65 = 0, $67 = 0, $7 = 0, $70 = 0, $71 = 0, $72 = 0, $74 = 0, $75 = 0, $76 = 0, $78 = 0, $8 = 0, $80 = 0, $82 = 0, $83 = 0, $84 = 0, $85 = 0, $86 = 0, $87 = 0, $88 = 0, $89 = 0, $90 = 0, $91 = 0, $93 = 0, $94 = 0, $96 = 0, $97 = 0, $99 = 0, $cmp = 0, $cmp11 = 0, $conv4 = 0, $conv7 = 0, $sub2$i5377 = 0, $sub2$i76 = 0, $sub8$i = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $6 = _bitshift64Lshr($2 ^ $0 | 0, $3 ^ $1 | 0, 63) | 0;
 $7 = tempRet0;
 $8 = _bitshift64Lshr($0 | 0, $1 | 0, 52) | 0;
 $conv4 = $8 & 2047;
 $10 = _bitshift64Lshr($2 | 0, $3 | 0, 52) | 0;
 $conv7 = $10 & 2047;
 $12 = $1 & 1048575;
 $13 = $3 & 1048575;
 $cmp = ($conv4 | 0) == 2047;
 $cmp11 = ($conv7 | 0) == 2047;
 if ($cmp | $cmp11) {
  $20 = ($0 | 0) != 0 | ($12 | 0) != 0;
  if (!(0 == 0 & ($1 & 2146435072 | 0) == 2146435072 & $20)) if (!(0 == 0 & ($3 & 2146435072 | 0) == 2146435072 & (($2 | 0) != 0 | ($13 | 0) != 0))) {
   if ($cmp) {
    if (!(($conv7 | 0) == 0 & (($2 | 0) == 0 & ($13 | 0) == 0))) label = 9;
   } else label = 9;
   do if ((label | 0) == 9) {
    if ($cmp11) if (($conv4 | 0) == 0 & (($0 | 0) == 0 & ($12 | 0) == 0)) break;
    $47 = _bitshift64Shl($6 | 0, $7 | 0, 63) | 0;
    $122 = tempRet0 | 2146435072;
    $123 = $47;
    tempRet0 = $122;
    STACKTOP = sp;
    return $123 | 0;
   } while (0);
   HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
   $122 = 2146959360;
   $123 = 0;
   tempRet0 = $122;
   STACKTOP = sp;
   return $123 | 0;
  }
  if (!(0 == 0 & ($1 & 2146959360 | 0) == 2146435072 & $20)) if (!(0 == 0 & ($3 & 2146959360 | 0) == 2146435072 & (($2 | 0) != 0 | ($13 | 0) != 0))) {
   $122 = 2146959360;
   $123 = 0;
   tempRet0 = $122;
   STACKTOP = sp;
   return $123 | 0;
  }
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $122 = 2146959360;
  $123 = 0;
  tempRet0 = $122;
  STACKTOP = sp;
  return $123 | 0;
 }
 do if (!$conv4) {
  if (!(($0 | 0) == 0 & ($12 | 0) == 0)) {
   $55 = _llvm_ctlz_i64($0 | 0, $12 | 0, 0) | 0;
   $57 = _bitshift64Shl($0 | 0, $12 | 0, $55 + -11 | 0) | 0;
   $70 = $57;
   $71 = tempRet0;
   $sub2$i5377 = 12 - $55 | 0;
   break;
  }
  $53 = _bitshift64Shl($6 | 0, $7 | 0, 63) | 0;
  $122 = tempRet0;
  $123 = $53;
  tempRet0 = $122;
  STACKTOP = sp;
  return $123 | 0;
 } else {
  $70 = $0;
  $71 = $12 | 1048576;
  $sub2$i5377 = $conv4;
 } while (0);
 do if (!$conv7) {
  if (!(($2 | 0) == 0 & ($13 | 0) == 0)) {
   $65 = _llvm_ctlz_i64($2 | 0, $13 | 0, 0) | 0;
   $67 = _bitshift64Shl($2 | 0, $13 | 0, $65 + -11 | 0) | 0;
   $74 = $67;
   $75 = tempRet0;
   $sub2$i76 = 12 - $65 | 0;
   break;
  }
  $63 = _bitshift64Shl($6 | 0, $7 | 0, 63) | 0;
  $122 = tempRet0;
  $123 = $63;
  tempRet0 = $122;
  STACKTOP = sp;
  return $123 | 0;
 } else {
  $74 = $2;
  $75 = $13 | 1048576;
  $sub2$i76 = $conv7;
 } while (0);
 $72 = _bitshift64Shl($70 | 0, $71 | 0, 10) | 0;
 $76 = _bitshift64Shl($74 | 0, $75 | 0, 11) | 0;
 $78 = _bitshift64Lshr($70 | 0, $71 | 0, 22) | 0;
 $80 = _bitshift64Lshr($74 | 0, $75 | 0, 21) | 0;
 $82 = $72 & -1024;
 $83 = $76 & -2048;
 $84 = ___muldi3($83 | 0, 0, $82 | 0, 0) | 0;
 $85 = tempRet0;
 $86 = ___muldi3($80 | 0, 0, $82 | 0, 0) | 0;
 $87 = tempRet0;
 $88 = ___muldi3($83 | 0, 0, $78 | 0, 0) | 0;
 $89 = tempRet0;
 $90 = ___muldi3($80 | 0, 0, $78 | 0, 0) | 0;
 $91 = tempRet0;
 $93 = _i64Add($85 | 0, 0, $86 & -1024 | 0, 0) | 0;
 $94 = tempRet0;
 _i64Add($93 | 0, $94 | 0, $88 & -2048 | 0, 0) | 0;
 $96 = tempRet0;
 $97 = _i64Add($89 | 0, 0, $87 | 0, 0) | 0;
 $99 = _i64Add($97 | 0, tempRet0 | 0, $96 | 0, 0) | 0;
 $100 = tempRet0;
 _i64Add($99 | 0, $100 | 0, $90 | 0, 0) | 0;
 $101 = tempRet0;
 $102 = _i64Add($93 | 0, $94 | 0, $88 | 0, $89 | 0) | 0;
 _i64Add(0, $101 | 0, $90 | 0, $91 | 0) | 0;
 $105 = tempRet0;
 $106 = _i64Add($99 | 0, $100 | 0, $90 | 0, $91 | 0) | 0;
 $112 = (($84 & -2097152 | 0) != 0 | ($102 | 0) != 0) & 1 | $106;
 if (($112 | 0) == 0 & ($105 | 0) == 0) $sub8$i = 63; else {
  $116 = _llvm_ctlz_i64($112 | 0, $105 | 0, 0) | 0;
  if (!$116) ___assert_fail(1104, 1064, 183, 1136); else $sub8$i = $116 + -1 | 0;
 }
 $118 = _bitshift64Shl($112 | 0, $105 | 0, $sub8$i | 0) | 0;
 $120 = _roundpack_sf64($6, $sub2$i5377 + -1022 + $sub2$i76 - $sub8$i | 0, $118, tempRet0, $rm, $pfflags) | 0;
 $122 = tempRet0;
 $123 = $120;
 tempRet0 = $122;
 STACKTOP = sp;
 return $123 | 0;
}
function _riscv_machine_init($0, $1, $rtc_real_time, $console_dev, $drive) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rtc_real_time = $rtc_real_time | 0;
 $console_dev = $console_dev | 0;
 $drive = $drive | 0;
 var $10 = 0, $12 = 0, $16 = 0, $17 = 0, $18 = 0, $2 = 0, $22 = 0, $26 = 0, $27 = 0, $28 = 0, $32 = 0, $36 = 0, $37 = 0, $38 = 0, $42 = 0, $46 = 0, $47 = 0, $48 = 0, $5 = 0, $52 = 0, $call$i = 0, $call1 = 0, $call11 = 0, $div$i = 0, $drives = 0, $n_phys_mem_range$i = 0, $n_phys_mem_range$i22 = 0, $n_phys_mem_range$i34 = 0, $n_phys_mem_range$i46 = 0, $retval$0$i = 0, $ts$i = 0, dest = 0, sp = 0, stop = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 16 | 0;
 $ts$i = sp;
 $call$i = _malloc(64) | 0;
 if (!$call$i) $retval$0$i = 0; else {
  dest = $call$i + 0 | 0;
  stop = dest + 64 | 0;
  do {
   HEAP8[dest >> 0] = 0;
   dest = dest + 1 | 0;
  } while ((dest | 0) < (stop | 0));
  $retval$0$i = $call$i;
 }
 $call1 = _riscv_cpu_init($retval$0$i, $0) | 0;
 HEAP32[$retval$0$i >> 2] = $call1;
 HEAP32[$retval$0$i + 20 >> 2] = $rtc_real_time;
 if (!$rtc_real_time) $16 = $call1; else {
  _clock_gettime(1, $ts$i | 0) | 0;
  $2 = HEAP32[$ts$i >> 2] | 0;
  $5 = ___muldi3($2 | 0, (($2 | 0) < 0) << 31 >> 31 | 0, 1e7, 0) | 0;
  $div$i = (HEAP32[$ts$i + 4 >> 2] | 0) / 100 | 0;
  $10 = _i64Add($div$i | 0, (($div$i | 0) < 0) << 31 >> 31 | 0, $5 | 0, tempRet0 | 0) | 0;
  $12 = $retval$0$i + 24 | 0;
  HEAP32[$12 >> 2] = $10;
  HEAP32[$12 + 4 >> 2] = tempRet0;
  $16 = HEAP32[$retval$0$i >> 2] | 0;
 }
 $n_phys_mem_range$i = $16 + 744 | 0;
 $17 = HEAP32[$n_phys_mem_range$i >> 2] | 0;
 if (($17 | 0) >= 16) ___assert_fail(8, 56, 403, 96);
 HEAP32[$n_phys_mem_range$i >> 2] = $17 + 1;
 $18 = $16 + ($17 * 40 | 0) + 752 | 0;
 HEAP32[$18 >> 2] = 1073741824;
 HEAP32[$18 + 4 >> 2] = 0;
 $22 = $16 + ($17 * 40 | 0) + 760 | 0;
 HEAP32[$22 >> 2] = 16;
 HEAP32[$22 + 4 >> 2] = 0;
 HEAP32[$16 + ($17 * 40 | 0) + 768 >> 2] = 0;
 HEAP32[$16 + ($17 * 40 | 0) + 776 >> 2] = $16;
 HEAP32[$16 + ($17 * 40 | 0) + 780 >> 2] = 1;
 HEAP32[$16 + ($17 * 40 | 0) + 784 >> 2] = 1;
 HEAP32[$16 + ($17 * 40 | 0) + 788 >> 2] = 4;
 $26 = HEAP32[$retval$0$i >> 2] | 0;
 $n_phys_mem_range$i22 = $26 + 744 | 0;
 $27 = HEAP32[$n_phys_mem_range$i22 >> 2] | 0;
 if (($27 | 0) >= 16) ___assert_fail(8, 56, 403, 96);
 HEAP32[$n_phys_mem_range$i22 >> 2] = $27 + 1;
 $28 = $26 + ($27 * 40 | 0) + 752 | 0;
 HEAP32[$28 >> 2] = 1073750016;
 HEAP32[$28 + 4 >> 2] = 0;
 $32 = $26 + ($27 * 40 | 0) + 760 | 0;
 HEAP32[$32 >> 2] = 8;
 HEAP32[$32 + 4 >> 2] = 0;
 HEAP32[$26 + ($27 * 40 | 0) + 768 >> 2] = 0;
 HEAP32[$26 + ($27 * 40 | 0) + 776 >> 2] = $retval$0$i;
 HEAP32[$26 + ($27 * 40 | 0) + 780 >> 2] = 2;
 HEAP32[$26 + ($27 * 40 | 0) + 784 >> 2] = 2;
 HEAP32[$26 + ($27 * 40 | 0) + 788 >> 2] = 4;
 $36 = HEAP32[$retval$0$i >> 2] | 0;
 $n_phys_mem_range$i34 = $36 + 744 | 0;
 $37 = HEAP32[$n_phys_mem_range$i34 >> 2] | 0;
 if (($37 | 0) >= 16) ___assert_fail(8, 56, 403, 96);
 HEAP32[$n_phys_mem_range$i34 >> 2] = $37 + 1;
 $38 = $36 + ($37 * 40 | 0) + 752 | 0;
 HEAP32[$38 >> 2] = 1073774592;
 HEAP32[$38 + 4 >> 2] = 0;
 $42 = $36 + ($37 * 40 | 0) + 760 | 0;
 HEAP32[$42 >> 2] = 16;
 HEAP32[$42 + 4 >> 2] = 0;
 HEAP32[$36 + ($37 * 40 | 0) + 768 >> 2] = 0;
 HEAP32[$36 + ($37 * 40 | 0) + 776 >> 2] = $retval$0$i;
 HEAP32[$36 + ($37 * 40 | 0) + 780 >> 2] = 3;
 HEAP32[$36 + ($37 * 40 | 0) + 784 >> 2] = 3;
 HEAP32[$36 + ($37 * 40 | 0) + 788 >> 2] = 4;
 HEAP32[$retval$0$i + 40 >> 2] = $console_dev;
 $drives = $retval$0$i + 4 | 0;
 HEAP32[$drives >> 2] = $drive;
 HEAP32[$retval$0$i + 8 >> 2] = 0;
 $call11 = _ide_init($drives, 1, $retval$0$i) | 0;
 HEAP32[$retval$0$i + 16 >> 2] = $call11;
 $46 = HEAP32[$retval$0$i >> 2] | 0;
 $n_phys_mem_range$i46 = $46 + 744 | 0;
 $47 = HEAP32[$n_phys_mem_range$i46 >> 2] | 0;
 if (($47 | 0) < 16) {
  HEAP32[$n_phys_mem_range$i46 >> 2] = $47 + 1;
  $48 = $46 + ($47 * 40 | 0) + 752 | 0;
  HEAP32[$48 >> 2] = 1073778688;
  HEAP32[$48 + 4 >> 2] = 0;
  $52 = $46 + ($47 * 40 | 0) + 760 | 0;
  HEAP32[$52 >> 2] = 36;
  HEAP32[$52 + 4 >> 2] = 0;
  HEAP32[$46 + ($47 * 40 | 0) + 768 >> 2] = 0;
  HEAP32[$46 + ($47 * 40 | 0) + 776 >> 2] = $call11;
  HEAP32[$46 + ($47 * 40 | 0) + 780 >> 2] = 4;
  HEAP32[$46 + ($47 * 40 | 0) + 784 >> 2] = 4;
  HEAP32[$46 + ($47 * 40 | 0) + 788 >> 2] = 3;
  STACKTOP = sp;
  return $retval$0$i | 0;
 } else ___assert_fail(8, 56, 403, 96);
 return 0;
}
function _add_sf64($0, $1, $2, $3, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $10 = 0, $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $17 = 0, $19 = 0, $21 = 0, $23 = 0, $24 = 0, $25 = 0, $26 = 0, $27 = 0, $29 = 0, $30 = 0, $4 = 0, $5 = 0, $50 = 0, $51 = 0, $56 = 0, $58 = 0, $59 = 0, $60 = 0, $69 = 0, $70 = 0, $71 = 0, $72 = 0, $73 = 0, $75 = 0, $76 = 0, $80 = 0, $82 = 0, $85 = 0, $87 = 0, $89 = 0, $91 = 0, $92 = 0, $a_exp$0 = 0, $a_sign$0 = 0, $add60 = 0, $b_exp$0 = 0, $cmp41 = 0, $conv11 = 0, $conv8 = 0, $sub = 0, $sub8$i = 0, sp = 0;
 sp = STACKTOP;
 $4 = $1 & 2147483647;
 $5 = $3 & 2147483647;
 $10 = $4 >>> 0 < $5 >>> 0 | ($4 | 0) == ($5 | 0) & $0 >>> 0 < $2 >>> 0;
 $11 = $10 ? $0 : $2;
 $12 = $10 ? $1 : $3;
 $13 = $10 ? $2 : $0;
 $14 = $10 ? $3 : $1;
 $15 = _bitshift64Lshr($13 | 0, $14 | 0, 63) | 0;
 $17 = _bitshift64Lshr($11 | 0, $12 | 0, 63) | 0;
 $19 = _bitshift64Lshr($13 | 0, $14 | 0, 52) | 0;
 $conv8 = $19 & 2047;
 $21 = _bitshift64Lshr($11 | 0, $12 | 0, 52) | 0;
 $conv11 = $21 & 2047;
 $23 = _bitshift64Shl($13 | 0, $14 | 0, 3) | 0;
 $24 = tempRet0;
 $25 = $23 & -8;
 $26 = $24 & 8388607;
 $27 = _bitshift64Shl($11 | 0, $12 | 0, 3) | 0;
 $29 = $27 & -8;
 $30 = tempRet0 & 8388607;
 if (($conv8 | 0) == 2047) {
  if (($25 | 0) == 0 & ($26 | 0) == 0) {
   if (($conv11 | 0) != 2047 | ($15 | 0) == ($17 | 0)) {
    $91 = $14;
    $92 = $13;
    tempRet0 = $91;
    STACKTOP = sp;
    return $92 | 0;
   }
   HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
   $91 = 2146959360;
   $92 = 0;
   tempRet0 = $91;
   STACKTOP = sp;
   return $92 | 0;
  }
  if (!(0 == 0 & ($24 & 4194304 | 0) == 0)) if (!(0 == 0 & ($12 & 2146959360 | 0) == 2146435072 & (($11 | 0) != 0 | ($12 & 1048575 | 0) != 0))) {
   $91 = 2146959360;
   $92 = 0;
   tempRet0 = $91;
   STACKTOP = sp;
   return $92 | 0;
  }
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $91 = 2146959360;
  $92 = 0;
  tempRet0 = $91;
  STACKTOP = sp;
  return $92 | 0;
 } else if (!$conv8) {
  $71 = $25;
  $72 = $26;
  $a_exp$0 = 1;
 } else {
  $71 = $25;
  $72 = $26 | 8388608;
  $a_exp$0 = $conv8;
 }
 $cmp41 = ($conv11 | 0) == 0;
 $b_exp$0 = $cmp41 ? 1 : $conv11;
 $50 = $cmp41 ? $29 : $29;
 $51 = $cmp41 ? $30 : $30 | 8388608;
 $sub = $a_exp$0 - $b_exp$0 | 0;
 do if (($a_exp$0 | 0) == ($b_exp$0 | 0)) {
  $69 = $50;
  $70 = $51;
 } else if (($sub | 0) > 63) {
  $69 = (($50 | 0) != 0 | ($51 | 0) != 0) & 1;
  $70 = 0;
  break;
 } else {
  $56 = _bitshift64Shl(1, 0, $sub | 0) | 0;
  $58 = _i64Add($56 | 0, tempRet0 | 0, -1, 16777215) | 0;
  $59 = tempRet0;
  $60 = _bitshift64Lshr($50 | 0, $51 | 0, $sub | 0) | 0;
  $69 = (($58 & $50 | 0) != 0 | ($59 & $51 | 0) != 0) & 1 | $60;
  $70 = tempRet0;
  break;
 } while (0);
 if (($15 | 0) == ($17 | 0)) {
  $73 = _i64Add($69 | 0, $70 | 0, $71 | 0, $72 | 0) | 0;
  $80 = $73;
  $82 = tempRet0;
  $a_sign$0 = $15;
 } else {
  $75 = _i64Subtract($71 | 0, $72 | 0, $69 | 0, $70 | 0) | 0;
  $76 = tempRet0;
  if (($71 | 0) == ($69 | 0) & ($72 | 0) == ($70 | 0)) {
   $80 = $75;
   $82 = $76;
   $a_sign$0 = ($rm | 0) == 2 & 1;
  } else {
   $80 = $75;
   $82 = $76;
   $a_sign$0 = $15;
  }
 }
 $add60 = $a_exp$0 + 7 | 0;
 if (($80 | 0) == 0 & ($82 | 0) == 0) $sub8$i = 63; else {
  $85 = _llvm_ctlz_i64($80 | 0, $82 | 0, 0) | 0;
  if (!$85) ___assert_fail(1104, 1064, 183, 1136); else $sub8$i = $85 + -1 | 0;
 }
 $87 = _bitshift64Shl($80 | 0, $82 | 0, $sub8$i | 0) | 0;
 $89 = _roundpack_sf64($a_sign$0, $add60 - $sub8$i | 0, $87, tempRet0, $rm, $pfflags) | 0;
 $91 = tempRet0;
 $92 = $89;
 tempRet0 = $91;
 STACKTOP = sp;
 return $92 | 0;
}
function _ide_init($tab_bs, $set_irq_func, $opaque) {
 $tab_bs = $tab_bs | 0;
 $set_irq_func = $set_irq_func | 0;
 $opaque = $opaque | 0;
 var $1 = 0, $11 = 0, $12 = 0, $14 = 0, $16 = 0, $17 = 0, $18 = 0, $20 = 0, $24 = 0, $25 = 0, $27 = 0, $28 = 0, $3 = 0, $4 = 0, $5 = 0, $7 = 0, $call = 0, $call$i = 0, $call$i$1 = 0, $cur_drive = 0, $cylinders$0$i = 0, $cylinders$0$i$1 = 0, $drives = 0, sp = 0;
 sp = STACKTOP;
 $call = _malloc(24) | 0;
 HEAP32[$call + 0 >> 2] = 0;
 HEAP32[$call + 4 >> 2] = 0;
 HEAP32[$call + 8 >> 2] = 0;
 HEAP32[$call + 12 >> 2] = 0;
 HEAP32[$call + 16 >> 2] = 0;
 HEAP32[$call + 20 >> 2] = 0;
 HEAP32[$call >> 2] = $opaque;
 HEAP32[$call + 4 >> 2] = $set_irq_func;
 HEAP8[$call + 20 >> 0] = 0;
 $drives = $call + 12 | 0;
 $1 = HEAP32[$tab_bs >> 2] | 0;
 if (!$1) $28 = 0; else {
  $call$i = _malloc(65608) | 0;
  _memset($call$i | 0, 0, 65608) | 0;
  HEAP32[$call$i >> 2] = $call;
  HEAP32[$call$i + 4 >> 2] = $1;
  $3 = FUNCTION_TABLE_ii[HEAP32[$1 >> 2] & 1]($1) | 0;
  $4 = tempRet0;
  $5 = ___udivdi3($3 | 0, $4 | 0, 1008, 0) | 0;
  if (($5 | 0) > 16383) $cylinders$0$i = 16383; else $cylinders$0$i = ($5 | 0) < 2 ? 2 : $5;
  HEAP32[$call$i + 8 >> 2] = $cylinders$0$i;
  HEAP32[$call$i + 12 >> 2] = 16;
  HEAP32[$call$i + 16 >> 2] = 63;
  $7 = $call$i + 24 | 0;
  HEAP32[$7 >> 2] = $3;
  HEAP32[$7 + 4 >> 2] = $4;
  HEAP32[$call$i + 20 >> 2] = 128;
  $11 = $call$i + 32 | 0;
  $12 = $call$i + 39 | 0;
  HEAP8[$11 + 0 >> 0] = 0;
  HEAP8[$11 + 1 >> 0] = 0;
  HEAP8[$11 + 2 >> 0] = 0;
  HEAP8[$11 + 3 >> 0] = 0;
  HEAP8[$11 + 4 >> 0] = 0;
  HEAP8[$11 + 5 >> 0] = 0;
  HEAP8[$11 + 6 >> 0] = 0;
  HEAP8[$12 >> 0] = -96;
  HEAP8[$call$i + 40 >> 0] = 80;
  HEAP32[$call$i + 56 >> 2] = 0;
  HEAP32[$call$i + 60 >> 2] = 0;
  HEAP32[$call$i + 52 >> 2] = 6;
  HEAP32[$call$i + 48 >> 2] = 0;
  HEAP32[$call$i + 44 >> 2] = 0;
  HEAP32[$drives >> 2] = $call$i;
  $28 = $call$i;
 }
 $14 = HEAP32[$tab_bs + 4 >> 2] | 0;
 if (!$14) {
  $27 = $28;
  $cur_drive = $call + 8 | 0;
  HEAP32[$cur_drive >> 2] = $27;
  STACKTOP = sp;
  return $call | 0;
 }
 $call$i$1 = _malloc(65608) | 0;
 _memset($call$i$1 | 0, 0, 65608) | 0;
 HEAP32[$call$i$1 >> 2] = $call;
 HEAP32[$call$i$1 + 4 >> 2] = $14;
 $16 = FUNCTION_TABLE_ii[HEAP32[$14 >> 2] & 1]($14) | 0;
 $17 = tempRet0;
 $18 = ___udivdi3($16 | 0, $17 | 0, 1008, 0) | 0;
 if (($18 | 0) > 16383) $cylinders$0$i$1 = 16383; else $cylinders$0$i$1 = ($18 | 0) < 2 ? 2 : $18;
 HEAP32[$call$i$1 + 8 >> 2] = $cylinders$0$i$1;
 HEAP32[$call$i$1 + 12 >> 2] = 16;
 HEAP32[$call$i$1 + 16 >> 2] = 63;
 $20 = $call$i$1 + 24 | 0;
 HEAP32[$20 >> 2] = $16;
 HEAP32[$20 + 4 >> 2] = $17;
 HEAP32[$call$i$1 + 20 >> 2] = 128;
 $24 = $call$i$1 + 32 | 0;
 $25 = $call$i$1 + 39 | 0;
 HEAP8[$24 + 0 >> 0] = 0;
 HEAP8[$24 + 1 >> 0] = 0;
 HEAP8[$24 + 2 >> 0] = 0;
 HEAP8[$24 + 3 >> 0] = 0;
 HEAP8[$24 + 4 >> 0] = 0;
 HEAP8[$24 + 5 >> 0] = 0;
 HEAP8[$24 + 6 >> 0] = 0;
 HEAP8[$25 >> 0] = -96;
 HEAP8[$call$i$1 + 40 >> 0] = 80;
 HEAP32[$call$i$1 + 56 >> 2] = 0;
 HEAP32[$call$i$1 + 60 >> 2] = 0;
 HEAP32[$call$i$1 + 52 >> 2] = 6;
 HEAP32[$call$i$1 + 48 >> 2] = 0;
 HEAP32[$call$i$1 + 44 >> 2] = 0;
 HEAP32[$call + 16 >> 2] = $call$i$1;
 $27 = HEAP32[$drives >> 2] | 0;
 $cur_drive = $call + 8 | 0;
 HEAP32[$cur_drive >> 2] = $27;
 STACKTOP = sp;
 return $call | 0;
}
function _bf_read_async1($bs, $is_sync) {
 $bs = $bs | 0;
 $is_sync = $is_sync | 0;
 var $0 = 0, $1 = 0, $10 = 0, $11 = 0, $13 = 0, $14 = 0, $15 = 0, $16 = 0, $18 = 0, $2 = 0, $21 = 0, $22 = 0, $23 = 0, $25 = 0, $29 = 0, $3 = 0, $37 = 0, $9 = 0, $a$b$i = 0, $block_size = 0, $cached_blocks$i = 0, $el$0$i = 0, $el$011$i = 0, $el$013$i = 0, $filename = 0, $io_buf = 0, $next$i = 0, $next2$i$i = 0, $retval$0 = 0, $sector_count = 0, $sector_index = 0, $sector_num = 0, $sub = 0, $sub7 = 0, $vararg_buffer = 0, sp = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 1040 | 0;
 $vararg_buffer = sp;
 $filename = sp + 8 | 0;
 $0 = HEAP32[$bs + 12 >> 2] | 0;
 $sector_count = $0 + 1076 | 0;
 $1 = HEAP32[$sector_count >> 2] | 0;
 $sector_index = $0 + 1072 | 0;
 $2 = HEAP32[$sector_index >> 2] | 0;
 L1 : do if (($1 | 0) != ($2 | 0)) {
  $sector_num = $0 + 1064 | 0;
  $block_size = $0 + 16 | 0;
  $cached_blocks$i = $0 + 1048 | 0;
  $next$i = $0 + 1052 | 0;
  $io_buf = $0 + 1088 | 0;
  $3 = $sector_num;
  $10 = $1;
  $14 = HEAP32[$3 >> 2] | 0;
  $15 = HEAP32[$3 + 4 >> 2] | 0;
  $9 = $2;
  L3 : while (1) {
   $sub = $10 - $9 | 0;
   $11 = HEAP32[$block_size >> 2] | 0;
   $13 = (($11 | 0) < 0) << 31 >> 31;
   $16 = ___udivdi3($14 | 0, $15 | 0, $11 | 0, $13 | 0) | 0;
   $18 = ___uremdi3($14 | 0, $15 | 0, $11 | 0, $13 | 0) | 0;
   $sub7 = $11 - $18 | 0;
   $a$b$i = ($sub | 0) < ($sub7 | 0) ? $sub : $sub7;
   $el$011$i = HEAP32[$next$i >> 2] | 0;
   if (($el$011$i | 0) == ($cached_blocks$i | 0)) break; else $el$013$i = $el$011$i;
   while (1) {
    if ((HEAP32[$el$013$i + 8 >> 2] | 0) == ($16 | 0)) break;
    $el$0$i = HEAP32[$el$013$i + 4 >> 2] | 0;
    if (($el$0$i | 0) == ($cached_blocks$i | 0)) break L3; else $el$013$i = $el$0$i;
   }
   if (($el$011$i | 0) == ($el$013$i | 0)) if (!$el$011$i) break; else $25 = $9; else {
    $21 = HEAP32[$el$013$i >> 2] | 0;
    $next2$i$i = $el$013$i + 4 | 0;
    $22 = HEAP32[$next2$i$i >> 2] | 0;
    HEAP32[$21 + 4 >> 2] = $22;
    HEAP32[$22 >> 2] = $21;
    HEAP32[$el$013$i >> 2] = 0;
    HEAP32[$next2$i$i >> 2] = 0;
    $23 = HEAP32[$next$i >> 2] | 0;
    HEAP32[$next$i >> 2] = $el$013$i;
    HEAP32[$el$013$i >> 2] = $cached_blocks$i;
    HEAP32[$next2$i$i >> 2] = $23;
    HEAP32[$23 >> 2] = $el$013$i;
    $25 = HEAP32[$sector_index >> 2] | 0;
   }
   _memcpy((HEAP32[$io_buf >> 2] | 0) + ($25 << 9) | 0, $el$013$i + ($18 << 9) + 12 | 0, $a$b$i << 9 | 0) | 0;
   $9 = (HEAP32[$sector_index >> 2] | 0) + $a$b$i | 0;
   HEAP32[$sector_index >> 2] = $9;
   $29 = $sector_num;
   $14 = _i64Add(HEAP32[$29 >> 2] | 0, HEAP32[$29 + 4 >> 2] | 0, $a$b$i | 0, (($a$b$i | 0) < 0) << 31 >> 31 | 0) | 0;
   $15 = tempRet0;
   $37 = $sector_num;
   HEAP32[$37 >> 2] = $14;
   HEAP32[$37 + 4 >> 2] = $15;
   $10 = HEAP32[$sector_count >> 2] | 0;
   if (($10 | 0) == ($9 | 0)) break L1;
  }
  HEAP32[$vararg_buffer >> 2] = $16;
  _snprintf($filename, 1024, $0 + 24 | 0, $vararg_buffer) | 0;
  _emscripten_async_wget_data($filename | 0, $bs | 0, 3, 3);
  $retval$0 = 1;
  STACKTOP = sp;
  return $retval$0 | 0;
 } while (0);
 if ($is_sync) {
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 FUNCTION_TABLE_vi[HEAP32[$0 + 1080 >> 2] & 15](HEAP32[$0 + 1084 >> 2] | 0);
 $retval$0 = 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _target_read_insn_slow($s, $pinsn, $0, $1, $short_insn) {
 $s = $s | 0;
 $pinsn = $pinsn | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $short_insn = $short_insn | 0;
 var $10 = 0, $13 = 0, $15 = 0, $18 = 0, $19 = 0, $20 = 0, $22 = 0, $25 = 0, $31 = 0, $37 = 0, $38 = 0, $45 = 0, $47 = 0, $48 = 0, $49 = 0, $52 = 0, $57 = 0, $6 = 0, $61 = 0, $7 = 0, $8 = 0, $add$ptr$sum = 0, $add$ptr23 = 0, $conv = 0, $conv$i = 0, $i$09$i = 0, $inc$i = 0, $insn = 0, $or = 0, $or$i = 0, $paddr = 0, $retval$0 = 0, $tobool = 0, $val = 0, sp = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 16 | 0;
 $paddr = sp;
 $insn = sp + 12 | 0;
 $val = sp + 8 | 0;
 $tobool = ($short_insn | 0) == 0;
 L1 : do if (($0 & 4095 | 0) == 4094 & 0 == 0 & $tobool) {
  $6 = _target_read_insn_slow($s, $insn, $0, $1, 1) | 0;
  if ($6) {
   $retval$0 = $6;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  $7 = HEAP32[$insn >> 2] | 0;
  if (($7 & 3 | 0) == 3) {
   $8 = _i64Add($0 | 0, $1 | 0, 2, 0) | 0;
   $10 = _target_read_insn_slow($s, $val, $8, tempRet0, 1) | 0;
   if (!$10) {
    $or = $7 | HEAP32[$val >> 2] << 16;
    HEAP32[$insn >> 2] = $or;
    $61 = $or;
    break;
   } else {
    $retval$0 = $10;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
  } else $61 = $7;
 } else {
  if (_get_phys_addr($s, $paddr, $0, $1, 2) | 0) {
   _raise_exception2($s, 1, $0, $1);
   $retval$0 = -1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  $13 = $paddr;
  $15 = HEAP32[$13 >> 2] | 0;
  $18 = HEAP32[$13 + 4 >> 2] | 0;
  $19 = HEAP32[$s + 744 >> 2] | 0;
  L7 : do if (($19 | 0) > 0) {
   $i$09$i = 0;
   while (1) {
    $20 = $s + ($i$09$i * 40 | 0) + 752 | 0;
    $22 = HEAP32[$20 >> 2] | 0;
    $25 = HEAP32[$20 + 4 >> 2] | 0;
    if (!($25 >>> 0 > $18 >>> 0 | ($25 | 0) == ($18 | 0) & $22 >>> 0 > $15 >>> 0)) {
     $31 = $s + ($i$09$i * 40 | 0) + 760 | 0;
     $37 = _i64Add(HEAP32[$31 >> 2] | 0, HEAP32[$31 + 4 >> 2] | 0, $22 | 0, $25 | 0) | 0;
     $38 = tempRet0;
     if ($38 >>> 0 > $18 >>> 0 | ($38 | 0) == ($18 | 0) & $37 >>> 0 > $15 >>> 0) break;
    }
    $inc$i = $i$09$i + 1 | 0;
    if (($inc$i | 0) < ($19 | 0)) $i$09$i = $inc$i; else break L7;
   }
   if (HEAP32[$s + ($i$09$i * 40 | 0) + 768 >> 2] | 0) {
    $45 = _bitshift64Lshr($0 | 0, $1 | 0, 12) | 0;
    $conv = $45 & 255;
    $47 = HEAP32[$s + 728 >> 2] | 0;
    $48 = HEAP32[$s + ($i$09$i * 40 | 0) + 772 >> 2] | 0;
    $49 = _i64Subtract($15 | 0, $18 | 0, $22 | 0, $25 | 0) | 0;
    $add$ptr$sum = $49 + $48 | 0;
    $add$ptr23 = $47 + $add$ptr$sum | 0;
    $52 = $s + ($conv << 4) + 9592 | 0;
    HEAP32[$52 >> 2] = $0 & -4096;
    HEAP32[$52 + 4 >> 2] = $1;
    $57 = _i64Subtract($add$ptr23 | 0, 0, $0 | 0, $1 | 0) | 0;
    HEAP32[$s + ($conv << 4) + 9600 >> 2] = $57;
    $conv$i = HEAPU16[$add$ptr23 >> 1] | 0;
    if ($tobool) {
     $or$i = (HEAPU16[$47 + ($add$ptr$sum + 2) >> 1] | 0) << 16 | $conv$i;
     HEAP32[$insn >> 2] = $or$i;
     $61 = $or$i;
     break L1;
    } else {
     HEAP32[$insn >> 2] = $conv$i;
     $61 = $conv$i;
     break L1;
    }
   }
  } while (0);
  _raise_exception2($s, 1, $0, $1);
  $retval$0 = -1;
  STACKTOP = sp;
  return $retval$0 | 0;
 } while (0);
 HEAP32[$pinsn >> 2] = $61;
 $retval$0 = 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _riscv_cpu_init($machine_state, $ram_size) {
 $machine_state = $machine_state | 0;
 $ram_size = $ram_size | 0;
 var $0 = 0, $13 = 0, $19 = 0, $21 = 0, $25 = 0, $26 = 0, $30 = 0, $34 = 0, $4 = 0, $40 = 0, $42 = 0, $46 = 0, $5 = 0, $52 = 0, $57 = 0, $59 = 0, $63 = 0, $67 = 0, $71 = 0, $9 = 0, $call$i = 0, $call$i32 = 0, $i$07$i = 0, $misa = 0, $n_phys_mem_range$i = 0, $phys_mem_size = 0, $retval$0 = 0, $retval$0$i = 0, $retval$0$i35 = 0, sp = 0;
 sp = STACKTOP;
 if (!(($ram_size | 0) != 0 & ($ram_size & 4095 | 0) == 0)) {
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 $call$i = _malloc(13688) | 0;
 if (!$call$i) $retval$0$i = 0; else {
  _memset($call$i | 0, 0, 13688) | 0;
  $retval$0$i = $call$i;
 }
 HEAP32[$retval$0$i + 1392 >> 2] = $machine_state;
 $phys_mem_size = $retval$0$i + 736 | 0;
 $0 = $phys_mem_size;
 HEAP32[$0 >> 2] = 0;
 HEAP32[$0 + 4 >> 2] = 0;
 $n_phys_mem_range$i = $retval$0$i + 744 | 0;
 $4 = HEAP32[$n_phys_mem_range$i >> 2] | 0;
 if (($4 | 0) >= 16) ___assert_fail(8, 56, 389, 72);
 HEAP32[$n_phys_mem_range$i >> 2] = $4 + 1;
 $5 = $retval$0$i + ($4 * 40 | 0) + 752 | 0;
 HEAP32[$5 >> 2] = -2147483648;
 HEAP32[$5 + 4 >> 2] = 0;
 $9 = $retval$0$i + ($4 * 40 | 0) + 760 | 0;
 HEAP32[$9 >> 2] = $ram_size;
 HEAP32[$9 + 4 >> 2] = 0;
 HEAP32[$retval$0$i + ($4 * 40 | 0) + 768 >> 2] = 1;
 HEAP32[$retval$0$i + ($4 * 40 | 0) + 772 >> 2] = 0;
 $13 = $phys_mem_size;
 $19 = _i64Add(HEAP32[$13 >> 2] | 0, HEAP32[$13 + 4 >> 2] | 0, $ram_size | 0, 0) | 0;
 $21 = $phys_mem_size;
 HEAP32[$21 >> 2] = $19;
 HEAP32[$21 + 4 >> 2] = tempRet0;
 $25 = HEAP32[$n_phys_mem_range$i >> 2] | 0;
 if (($25 | 0) >= 16) ___assert_fail(8, 56, 389, 72);
 HEAP32[$n_phys_mem_range$i >> 2] = $25 + 1;
 $26 = $retval$0$i + ($25 * 40 | 0) + 752 | 0;
 HEAP32[$26 >> 2] = 0;
 HEAP32[$26 + 4 >> 2] = 0;
 $30 = $retval$0$i + ($25 * 40 | 0) + 760 | 0;
 HEAP32[$30 >> 2] = 1048576;
 HEAP32[$30 + 4 >> 2] = 0;
 HEAP32[$retval$0$i + ($25 * 40 | 0) + 768 >> 2] = 1;
 HEAP32[$retval$0$i + ($25 * 40 | 0) + 772 >> 2] = $19;
 $34 = $phys_mem_size;
 $40 = _i64Add(HEAP32[$34 >> 2] | 0, HEAP32[$34 + 4 >> 2] | 0, 1048576, 0) | 0;
 $42 = $phys_mem_size;
 HEAP32[$42 >> 2] = $40;
 HEAP32[$42 + 4 >> 2] = tempRet0;
 $call$i32 = _malloc($40) | 0;
 if (!$call$i32) $retval$0$i35 = 0; else {
  _memset($call$i32 | 0, 0, $40 | 0) | 0;
  $retval$0$i35 = $call$i32;
 }
 HEAP32[$retval$0$i + 728 >> 2] = $retval$0$i35;
 $46 = $retval$0$i;
 HEAP32[$46 >> 2] = 4096;
 HEAP32[$46 + 4 >> 2] = 0;
 HEAP8[$retval$0$i + 526 >> 0] = 3;
 HEAP8[$retval$0$i + 525 >> 0] = 64;
 $misa = $retval$0$i + 624 | 0;
 $52 = $misa;
 $57 = HEAP32[$52 + 4 >> 2] | 0;
 $59 = $misa;
 HEAP32[$59 >> 2] = HEAP32[$52 >> 2] | 1315117;
 HEAP32[$59 + 4 >> 2] = $57;
 $i$07$i = 0;
 do {
  $63 = $retval$0$i + ($i$07$i << 4) + 1400 | 0;
  HEAP32[$63 >> 2] = -1;
  HEAP32[$63 + 4 >> 2] = -1;
  $67 = $retval$0$i + ($i$07$i << 4) + 5496 | 0;
  HEAP32[$67 >> 2] = -1;
  HEAP32[$67 + 4 >> 2] = -1;
  $71 = $retval$0$i + ($i$07$i << 4) + 9592 | 0;
  HEAP32[$71 >> 2] = -1;
  HEAP32[$71 + 4 >> 2] = -1;
  $i$07$i = $i$07$i + 1 | 0;
 } while (($i$07$i | 0) != 256);
 $retval$0 = $retval$0$i;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _internal_cvt_sf64_i64($0, $1, $rm, $pfflags, $is_unsigned) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 $is_unsigned = $is_unsigned | 0;
 var $11 = 0, $12 = 0, $13 = 0, $14 = 0, $15 = 0, $17 = 0, $2 = 0, $20 = 0, $21 = 0, $23 = 0, $26 = 0, $34 = 0, $36 = 0, $37 = 0, $38 = 0, $4 = 0, $49 = 0, $50 = 0, $51 = 0, $52 = 0, $53 = 0, $55 = 0, $56 = 0, $59 = 0, $6 = 0, $60 = 0, $67 = 0, $68 = 0, $69 = 0, $73 = 0, $74 = 0, $a_exp$0 = 0, $a_sign$0 = 0, $conv2 = 0, $conv45 = 0, $or$cond29 = 0, $sub35 = 0, $tobool40 = 0, $tobool66 = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $2 = _bitshift64Lshr($0 | 0, $1 | 0, 63) | 0;
 $4 = _bitshift64Lshr($0 | 0, $1 | 0, 52) | 0;
 $conv2 = $4 & 2047;
 $6 = $1 & 1048575;
 $a_sign$0 = ($conv2 | 0) != 2047 | ($0 | 0) == 0 & ($6 | 0) == 0 ? $2 : 0;
 if (!$conv2) {
  $11 = $0;
  $12 = $6;
  $a_exp$0 = -1074;
 } else {
  $11 = $0;
  $12 = $6 | 1048576;
  $a_exp$0 = $conv2 + -1075 | 0;
 }
 $13 = _bitshift64Shl($11 | 0, $12 | 0, 10) | 0;
 $14 = tempRet0;
 if (!$is_unsigned) {
  $17 = _i64Subtract(0, -2147483648, $a_sign$0 ^ 1 | 0, 0) | 0;
  $23 = tempRet0;
  $26 = $17;
 } else {
  $15 = _i64Add($a_sign$0 | 0, 0, -1, -1) | 0;
  $23 = tempRet0;
  $26 = $15;
 }
 if (($a_exp$0 | 0) > -1) if (($a_exp$0 | 0) < 12) {
  $20 = _bitshift64Shl($11 | 0, $12 & 4194303 | 0, $a_exp$0 | 0) | 0;
  $21 = tempRet0;
  if ($21 >>> 0 > $23 >>> 0 | ($21 | 0) == ($23 | 0) & $20 >>> 0 > $26 >>> 0) label = 9; else {
   $67 = $20;
   $68 = $21;
   label = 19;
  }
 } else label = 9; else {
  $sub35 = 0 - $a_exp$0 | 0;
  if (($sub35 | 0) > 63) {
   $49 = (($11 | 0) != 0 | ($12 | 0) != 0) & 1;
   $52 = 0;
  } else {
   $34 = _bitshift64Shl(1, 0, $sub35 | 0) | 0;
   $36 = _i64Add($34 | 0, tempRet0 | 0, -1, -1) | 0;
   $37 = tempRet0;
   $38 = _bitshift64Lshr($13 | 0, $14 | 0, $sub35 | 0) | 0;
   $49 = (($36 & $13 | 0) != 0 | ($37 & $14 | 0) != 0) & 1 | $38;
   $52 = tempRet0;
  }
  if (($rm | 0) == 1) {
   $50 = 0;
   $51 = 0;
  } else if (($rm | 0) == 4 | ($rm | 0) == 0) {
   $50 = 512;
   $51 = 0;
  } else {
   $tobool40 = ($a_sign$0 | 0) == ($rm & 1 | 0);
   $50 = $tobool40 ? 0 : 1023;
   $51 = $tobool40 ? 0 : 0;
  }
  $conv45 = $49 & 1023;
  $53 = _i64Add($50 | 0, $51 | 0, $49 | 0, $52 | 0) | 0;
  $55 = _bitshift64Lshr($53 | 0, tempRet0 | 0, 10) | 0;
  $56 = tempRet0;
  $or$cond29 = ($rm | 0) == 0 & ($conv45 | 0) == 512;
  $59 = $or$cond29 ? $55 & -2 : $55;
  $60 = $or$cond29 ? $56 & 4194303 : $56;
  if ($60 >>> 0 > $23 >>> 0 | ($60 | 0) == ($23 | 0) & $59 >>> 0 > $26 >>> 0) label = 9; else if (!$conv45) {
   $67 = $59;
   $68 = $60;
   label = 19;
  } else {
   HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 16;
   $67 = $59;
   $68 = $60;
   label = 19;
  }
 }
 if ((label | 0) == 9) {
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $73 = $23;
  $74 = $26;
  tempRet0 = $73;
  STACKTOP = sp;
  return $74 | 0;
 } else if ((label | 0) == 19) {
  $tobool66 = ($a_sign$0 | 0) == 0;
  $69 = _i64Subtract(0, 0, $67 | 0, $68 | 0) | 0;
  $73 = $tobool66 ? $68 : tempRet0;
  $74 = $tobool66 ? $67 : $69;
  tempRet0 = $73;
  STACKTOP = sp;
  return $74 | 0;
 }
 return 0;
}
function _div_sf32($a, $b, $rm, $pfflags) {
 $a = $a | 0;
 $b = $b | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $10 = 0, $15 = 0, $5 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $a_mant$0 = 0, $and = 0, $and4 = 0, $and5 = 0, $and6 = 0, $b_mant$0 = 0, $call64$or67 = 0, $retval$0 = 0, $shl = 0, $sub2$i5276 = 0, $sub2$i77 = 0, $sub8$i = 0, $xor = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $xor = ($b ^ $a) >>> 31;
 $and = $a >>> 23 & 255;
 $and4 = $b >>> 23 & 255;
 $and5 = $a & 8388607;
 $and6 = $b & 8388607;
 if (($and | 0) == 255) {
  if (!$and5) if (($b & 2139095040 | 0) == 2139095040 & ($and6 | 0) != 0) label = 5; else if (($and4 | 0) == 255) {
   HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
   $retval$0 = 2143289344;
   STACKTOP = sp;
   return $retval$0 | 0;
  } else {
   $retval$0 = $xor << 31 | 2139095040;
   STACKTOP = sp;
   return $retval$0 | 0;
  } else if (($a & 2143289344 | 0) != 2139095040) label = 5;
  if ((label | 0) == 5) if (!(($b & 2143289344 | 0) == 2139095040 & ($and6 | 0) != 0)) {
   $retval$0 = 2143289344;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $retval$0 = 2143289344;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 do if (!$and4) {
  if ($and6) {
   $6 = _llvm_ctlz_i32($and6 | 0) | 0;
   $b_mant$0 = $and6 << $6 + -8;
   $sub2$i5276 = 9 - $6 | 0;
   break;
  }
  $5 = HEAP32[$pfflags >> 2] | 0;
  if (!($and | $and5)) {
   HEAP32[$pfflags >> 2] = $5 | 1;
   $retval$0 = 2143289344;
   STACKTOP = sp;
   return $retval$0 | 0;
  } else {
   HEAP32[$pfflags >> 2] = $5 | 8;
   $retval$0 = $xor << 31 | 2139095040;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 } else if (($and4 | 0) == 255) {
  if (!$and6) {
   $retval$0 = $xor << 31;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if (!(($a & 2143289344 | 0) == 2139095040 & ($and5 | 0) != 0)) if (($b & 2143289344 | 0) != 2139095040) {
   $retval$0 = 2143289344;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $retval$0 = 2143289344;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else {
  $b_mant$0 = $and6 | 8388608;
  $sub2$i5276 = $and4;
 } while (0);
 do if (!$and) {
  if ($and5) {
   $7 = _llvm_ctlz_i32($and5 | 0) | 0;
   $a_mant$0 = $and5 << $7 + -8;
   $sub2$i77 = 9 - $7 | 0;
   break;
  }
  $retval$0 = $xor << 31;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else {
  $a_mant$0 = $and5 | 8388608;
  $sub2$i77 = $and;
 } while (0);
 $shl = $b_mant$0 << 2;
 $8 = ___uremdi3(0, $a_mant$0 | 0, $shl | 0, 0) | 0;
 $9 = tempRet0;
 $10 = ___udivdi3(0, $a_mant$0 | 0, $shl | 0, 0) | 0;
 $call64$or67 = $10 | (($8 | 0) != 0 | ($9 | 0) != 0) & 1;
 if (!$call64$or67) $sub8$i = 31; else {
  $15 = _llvm_ctlz_i32($call64$or67 | 0) | 0;
  if (!$15) ___assert_fail(1104, 1064, 183, 1168); else $sub8$i = $15 + -1 | 0;
 }
 $retval$0 = _roundpack_sf32($xor, 127 - $sub2$i5276 + $sub2$i77 - $sub8$i | 0, $call64$or67 << $sub8$i, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _memchr($src, $c, $n) {
 $src = $src | 0;
 $c = $c | 0;
 $n = $n | 0;
 var $1 = 0, $5 = 0, $conv1 = 0, $dec = 0, $incdec$ptr = 0, $incdec$ptr21 = 0, $incdec$ptr33 = 0, $mul = 0, $n$addr$0$lcssa = 0, $n$addr$0$lcssa52 = 0, $n$addr$037 = 0, $n$addr$1$lcssa = 0, $n$addr$129 = 0, $n$addr$225 = 0, $n$addr$3 = 0, $s$0$lcssa = 0, $s$0$lcssa51 = 0, $s$038 = 0, $s$126 = 0, $s$2 = 0, $sub22 = 0, $tobool2 = 0, $tobool2$lcssa = 0, $tobool235 = 0, $w$0$lcssa = 0, $w$030 = 0, $xor = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $conv1 = $c & 255;
 $tobool235 = ($n | 0) == 0;
 L1 : do if (($src & 3 | 0) == 0 | $tobool235) {
  $n$addr$0$lcssa = $n;
  $s$0$lcssa = $src;
  $tobool2$lcssa = $tobool235;
  label = 5;
 } else {
  $1 = $c & 255;
  $n$addr$037 = $n;
  $s$038 = $src;
  while (1) {
   if ((HEAP8[$s$038 >> 0] | 0) == $1 << 24 >> 24) {
    $n$addr$0$lcssa52 = $n$addr$037;
    $s$0$lcssa51 = $s$038;
    label = 6;
    break L1;
   }
   $incdec$ptr = $s$038 + 1 | 0;
   $dec = $n$addr$037 + -1 | 0;
   $tobool2 = ($dec | 0) == 0;
   if (($incdec$ptr & 3 | 0) == 0 | $tobool2) {
    $n$addr$0$lcssa = $dec;
    $s$0$lcssa = $incdec$ptr;
    $tobool2$lcssa = $tobool2;
    label = 5;
    break;
   } else {
    $n$addr$037 = $dec;
    $s$038 = $incdec$ptr;
   }
  }
 } while (0);
 if ((label | 0) == 5) if ($tobool2$lcssa) {
  $n$addr$3 = 0;
  $s$2 = $s$0$lcssa;
 } else {
  $n$addr$0$lcssa52 = $n$addr$0$lcssa;
  $s$0$lcssa51 = $s$0$lcssa;
  label = 6;
 }
 L8 : do if ((label | 0) == 6) {
  $5 = $c & 255;
  if ((HEAP8[$s$0$lcssa51 >> 0] | 0) == $5 << 24 >> 24) {
   $n$addr$3 = $n$addr$0$lcssa52;
   $s$2 = $s$0$lcssa51;
  } else {
   $mul = Math_imul($conv1, 16843009) | 0;
   L11 : do if ($n$addr$0$lcssa52 >>> 0 > 3) {
    $n$addr$129 = $n$addr$0$lcssa52;
    $w$030 = $s$0$lcssa51;
    while (1) {
     $xor = HEAP32[$w$030 >> 2] ^ $mul;
     if (($xor & -2139062144 ^ -2139062144) & $xor + -16843009) {
      $n$addr$1$lcssa = $n$addr$129;
      $w$0$lcssa = $w$030;
      break L11;
     }
     $incdec$ptr21 = $w$030 + 4 | 0;
     $sub22 = $n$addr$129 + -4 | 0;
     if ($sub22 >>> 0 > 3) {
      $n$addr$129 = $sub22;
      $w$030 = $incdec$ptr21;
     } else {
      $n$addr$1$lcssa = $sub22;
      $w$0$lcssa = $incdec$ptr21;
      break;
     }
    }
   } else {
    $n$addr$1$lcssa = $n$addr$0$lcssa52;
    $w$0$lcssa = $s$0$lcssa51;
   } while (0);
   if (!$n$addr$1$lcssa) {
    $n$addr$3 = 0;
    $s$2 = $w$0$lcssa;
   } else {
    $n$addr$225 = $n$addr$1$lcssa;
    $s$126 = $w$0$lcssa;
    while (1) {
     if ((HEAP8[$s$126 >> 0] | 0) == $5 << 24 >> 24) {
      $n$addr$3 = $n$addr$225;
      $s$2 = $s$126;
      break L8;
     }
     $incdec$ptr33 = $s$126 + 1 | 0;
     $n$addr$225 = $n$addr$225 + -1 | 0;
     if (!$n$addr$225) {
      $n$addr$3 = 0;
      $s$2 = $incdec$ptr33;
      break;
     } else $s$126 = $incdec$ptr33;
    }
   }
  }
 } while (0);
 STACKTOP = sp;
 return (($n$addr$3 | 0) != 0 ? $s$2 : 0) | 0;
}
function _sqrt_sf32($a, $rm, $pfflags) {
 $a = $a | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $10 = 0, $12 = 0, $14 = 0, $15 = 0, $21 = 0, $26 = 0, $4 = 0, $6 = 0, $8 = 0, $9 = 0, $add = 0, $and = 0, $and2 = 0, $retval$0 = 0, $shl33 = 0, $shr = 0, $storemerge = 0, $storemerge$i2632 = 0, $storemerge$i2635 = 0, $storemerge$i27 = 0, $sub = 0, $sub2$i28 = 0, $sub2$i29 = 0, $sub8$i = 0, sp = 0;
 sp = STACKTOP;
 $shr = $a >>> 31;
 $and = $a >>> 23 & 255;
 $and2 = $a & 8388607;
 do if (($and | 0) == 255) {
  if (!$and2) {
   if (!$shr) $retval$0 = $a; else break;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if (($a & 2143289344 | 0) != 2139095040) {
   $retval$0 = 2143289344;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $retval$0 = 2143289344;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else {
  if ($shr) {
   if (!($and | $and2)) $retval$0 = $a; else break;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  do if (!$and) if (!$and2) {
   $retval$0 = 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  } else {
   $4 = _llvm_ctlz_i32($and2 | 0) | 0;
   $storemerge = $and2 << $4 + -8;
   $sub2$i29 = 9 - $4 | 0;
   break;
  } else {
   $storemerge = $and2 | 8388608;
   $sub2$i29 = $and;
  } while (0);
  $sub = $sub2$i29 + -127 | 0;
  if (!($sub & 1)) {
   $storemerge$i27 = $storemerge;
   $sub2$i28 = $sub;
  } else {
   $storemerge$i27 = $storemerge << 1;
   $sub2$i28 = $sub2$i29 + -128 | 0;
  }
  $add = ($sub2$i28 >> 1) + 127 | 0;
  $shl33 = $storemerge$i27 << 5;
  do if (!$shl33) {
   $storemerge$i2632 = 0;
   $sub8$i = 31;
  } else {
   $6 = _bitshift64Shl(1, 0, (65 - (_llvm_ctlz_i32($shl33 + -1 | 0) | 0) | 0) >>> 1 | 0) | 0;
   $8 = $6;
   $9 = tempRet0;
   while (1) {
    $10 = ___udivdi3(0, $shl33 | 0, $8 | 0, $9 | 0) | 0;
    $12 = _i64Add($10 | 0, tempRet0 | 0, $8 | 0, $9 | 0) | 0;
    $14 = _bitshift64Lshr($12 | 0, tempRet0 | 0, 1) | 0;
    $15 = tempRet0;
    if ($15 >>> 0 < $9 >>> 0 | ($15 | 0) == ($9 | 0) & $14 >>> 0 < $8 >>> 0) {
     $8 = $14;
     $9 = $15;
    } else break;
   }
   $21 = ___muldi3($8 | 0, $9 | 0, $8 | 0, $9 | 0) | 0;
   if (0 == ($21 | 0) & ($shl33 | 0) == (tempRet0 | 0)) if (!$8) {
    $storemerge$i2632 = 0;
    $sub8$i = 31;
    break;
   } else $storemerge$i2635 = $8; else $storemerge$i2635 = $8 | 1;
   $26 = _llvm_ctlz_i32($storemerge$i2635 | 0) | 0;
   if (!$26) ___assert_fail(1104, 1064, 183, 1168); else {
    $storemerge$i2632 = $storemerge$i2635;
    $sub8$i = $26 + -1 | 0;
   }
  } while (0);
  $retval$0 = _roundpack_sf32(0, $add - $sub8$i | 0, $storemerge$i2632 << $sub8$i, $rm, $pfflags) | 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 } while (0);
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $retval$0 = 2143289344;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _rtc_read($opaque, $0, $1, $size_log2) {
 $opaque = $opaque | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $size_log2 = $size_log2 | 0;
 var $10 = 0, $12 = 0, $18 = 0, $2 = 0, $20 = 0, $26 = 0, $28 = 0, $30 = 0, $33 = 0, $38 = 0, $4 = 0, $40 = 0, $47 = 0, $53 = 0, $7 = 0, $div$i$i13 = 0, $ts$i$i4 = 0, $val$0 = 0, sp = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 16 | 0;
 $ts$i$i4 = sp;
 if (($size_log2 | 0) != 2) ___assert_fail(840, 56, 1795, 976);
 if (($0 | 0) == 4) {
  if ($1) {
   $val$0 = 0;
   tempRet0 = 0;
   STACKTOP = sp;
   return $val$0 | 0;
  }
  $28 = HEAP32[$opaque + 1392 >> 2] | 0;
  if (!(HEAP32[$28 + 20 >> 2] | 0)) {
   $47 = $opaque + 528 | 0;
   $53 = _bitshift64Lshr(HEAP32[$47 >> 2] | 0, HEAP32[$47 + 4 >> 2] | 0, 36) | 0;
   $val$0 = $53;
   tempRet0 = 0;
   STACKTOP = sp;
   return $val$0 | 0;
  } else {
   _clock_gettime(1, $ts$i$i4 | 0) | 0;
   $30 = HEAP32[$ts$i$i4 >> 2] | 0;
   $33 = ___muldi3($30 | 0, (($30 | 0) < 0) << 31 >> 31 | 0, 1e7, 0) | 0;
   $div$i$i13 = (HEAP32[$ts$i$i4 + 4 >> 2] | 0) / 100 | 0;
   $38 = _i64Add($div$i$i13 | 0, (($div$i$i13 | 0) < 0) << 31 >> 31 | 0, $33 | 0, tempRet0 | 0) | 0;
   $40 = $28 + 24 | 0;
   _i64Subtract($38 | 0, tempRet0 | 0, HEAP32[$40 >> 2] | 0, HEAP32[$40 + 4 >> 2] | 0) | 0;
   $val$0 = tempRet0;
   tempRet0 = 0;
   STACKTOP = sp;
   return $val$0 | 0;
  }
 } else if (($0 | 0) == 12) {
  if ($1) {
   $val$0 = 0;
   tempRet0 = 0;
   STACKTOP = sp;
   return $val$0 | 0;
  }
  $val$0 = HEAP32[$opaque + 540 >> 2] | 0;
  tempRet0 = 0;
  STACKTOP = sp;
  return $val$0 | 0;
 } else if (($0 | 0) == 8) {
  if ($1) {
   $val$0 = 0;
   tempRet0 = 0;
   STACKTOP = sp;
   return $val$0 | 0;
  }
  $val$0 = HEAP32[$opaque + 536 >> 2] | 0;
  tempRet0 = 0;
  STACKTOP = sp;
  return $val$0 | 0;
 } else if (!$0) {
  if ($1) {
   $val$0 = 0;
   tempRet0 = 0;
   STACKTOP = sp;
   return $val$0 | 0;
  }
  $2 = HEAP32[$opaque + 1392 >> 2] | 0;
  if (!(HEAP32[$2 + 20 >> 2] | 0)) {
   $20 = $opaque + 528 | 0;
   $26 = _bitshift64Lshr(HEAP32[$20 >> 2] | 0, HEAP32[$20 + 4 >> 2] | 0, 4) | 0;
   $val$0 = $26;
   tempRet0 = 0;
   STACKTOP = sp;
   return $val$0 | 0;
  } else {
   _clock_gettime(1, $ts$i$i4 | 0) | 0;
   $4 = HEAP32[$ts$i$i4 >> 2] | 0;
   $7 = ___muldi3($4 | 0, (($4 | 0) < 0) << 31 >> 31 | 0, 1e7, 0) | 0;
   $10 = _i64Add((HEAP32[$ts$i$i4 + 4 >> 2] | 0) / 100 | 0 | 0, 0, $7 | 0, tempRet0 | 0) | 0;
   $12 = $2 + 24 | 0;
   $18 = _i64Subtract($10 | 0, tempRet0 | 0, HEAP32[$12 >> 2] | 0, HEAP32[$12 + 4 >> 2] | 0) | 0;
   $val$0 = $18;
   tempRet0 = 0;
   STACKTOP = sp;
   return $val$0 | 0;
  }
 } else {
  $val$0 = 0;
  tempRet0 = 0;
  STACKTOP = sp;
  return $val$0 | 0;
 }
 return 0;
}
function _roundpack_sf64($a_sign, $a_exp, $0, $1, $rm, $pfflags) {
 $a_sign = $a_sign | 0;
 $a_exp = $a_exp | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $10 = 0, $11 = 0, $12 = 0, $21 = 0, $22 = 0, $27 = 0, $28 = 0, $29 = 0, $31 = 0, $32 = 0, $35 = 0, $36 = 0, $37 = 0, $39 = 0, $40 = 0, $41 = 0, $51 = 0, $52 = 0, $53 = 0, $56 = 0, $58 = 0, $62 = 0, $8 = 0, $a_exp$addr$2 = 0, $addend$0 = 0, $cmp44 = 0, $conv8 = 0, $or$cond23 = 0, $rnd_bits$0 = 0, $sub30 = 0, sp = 0;
 sp = STACKTOP;
 if (($rm | 0) == 4 | ($rm | 0) == 0) $addend$0 = 512; else if (($rm | 0) == 1) $addend$0 = 0; else $addend$0 = ($rm & 1 | 0) == ($a_sign | 0) ? 0 : 1023;
 if (($a_exp | 0) < 1) {
  if (($a_exp | 0) < 0) $22 = 0; else {
   _i64Add($addend$0 | 0, 0, $0 | 0, $1 | 0) | 0;
   $22 = (tempRet0 | 0) < 0;
  }
  $sub30 = 1 - $a_exp | 0;
  if (($sub30 | 0) > 63) {
   $21 = (($0 | 0) != 0 | ($1 | 0) != 0) & 1;
   $62 = 0;
  } else {
   $8 = _bitshift64Shl(1, 0, $sub30 | 0) | 0;
   $10 = _i64Add($8 | 0, tempRet0 | 0, -1, -1) | 0;
   $11 = tempRet0;
   $12 = _bitshift64Lshr($0 | 0, $1 | 0, $sub30 | 0) | 0;
   $21 = (($10 & $0 | 0) != 0 | ($11 & $1 | 0) != 0) & 1 | $12;
   $62 = tempRet0;
  }
  $conv8 = $21 & 1023;
  if ($22 | ($conv8 | 0) == 0) {
   $27 = $21;
   $28 = $62;
   $39 = 1;
   $40 = 0;
   $rnd_bits$0 = $conv8;
  } else {
   HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 2;
   $27 = $21;
   $28 = $62;
   $39 = 1;
   $40 = 0;
   $rnd_bits$0 = $conv8;
  }
 } else {
  $27 = $0;
  $28 = $1;
  $39 = $a_exp;
  $40 = (($a_exp | 0) < 0) << 31 >> 31;
  $rnd_bits$0 = $0 & 1023;
 }
 if ($rnd_bits$0) HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 16;
 $29 = _i64Add($27 | 0, $28 | 0, $addend$0 | 0, 0) | 0;
 $31 = _bitshift64Lshr($29 | 0, tempRet0 | 0, 10) | 0;
 $32 = tempRet0;
 $or$cond23 = ($rm | 0) == 0 & ($rnd_bits$0 | 0) == 512;
 $35 = $or$cond23 ? $31 & -2 : $31;
 $36 = $or$cond23 ? $32 & 4194303 : $32;
 $37 = _bitshift64Lshr($35 | 0, $36 | 0, 53) | 0;
 $41 = _i64Add($37 | 0, tempRet0 | 0, $39 | 0, $40 | 0) | 0;
 if ($36 >>> 0 < 1048576 | ($36 | 0) == 1048576 & $35 >>> 0 < 0) {
  $56 = $36;
  $58 = $35;
  $a_exp$addr$2 = 0;
 } else if (($41 | 0) > 2046) {
  $cmp44 = ($addend$0 | 0) == 0;
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 20;
  $56 = $cmp44 ? 1048575 : 0;
  $58 = $cmp44 ? -1 : 0;
  $a_exp$addr$2 = $cmp44 ? 2046 : 2047;
 } else {
  $56 = $36;
  $58 = $35;
  $a_exp$addr$2 = $41;
 }
 $51 = _bitshift64Shl($a_sign | 0, 0, 63) | 0;
 $52 = tempRet0;
 $53 = _bitshift64Shl($a_exp$addr$2 | 0, 0, 52) | 0;
 tempRet0 = $56 & 1048575 | $52 | tempRet0;
 STACKTOP = sp;
 return $58 | $51 | $53 | 0;
}
function _ide_sector_write_cb2($opaque) {
 $opaque = $opaque | 0;
 var $$and = 0, $$idx$val = 0, $0 = 0, $1 = 0, $11 = 0, $12 = 0, $13 = 0, $18 = 0, $22 = 0, $40 = 0, $41 = 0, $43 = 0, $45 = 0, $46 = 0, $48 = 0, $56 = 0, $add$i = 0, $add26$i = 0, $and = 0, $conv$i = 0, $io_nb_sectors = 0, $mul$i = 0, $mul$i34 = 0, $nsector = 0, sp = 0;
 sp = STACKTOP;
 $io_nb_sectors = $opaque + 44 | 0;
 $0 = HEAP32[$io_nb_sectors >> 2] | 0;
 $1 = $opaque + 39 | 0;
 $conv$i = HEAPU8[$1 >> 0] | 0;
 if (!($conv$i & 64)) {
  $mul$i = Math_imul((HEAPU8[$opaque + 38 >> 0] | 0) << 8 | (HEAPU8[$opaque + 37 >> 0] | 0), HEAP32[$opaque + 12 >> 2] | 0) | 0;
  $add$i = Math_imul($mul$i + ($conv$i & 15) | 0, HEAP32[$opaque + 16 >> 2] | 0) | 0;
  $add26$i = (HEAPU8[$opaque + 36 >> 0] | 0) + -1 + $add$i | 0;
  $40 = _i64Add($add26$i | 0, (($add26$i | 0) < 0) << 31 >> 31 | 0, $0 | 0, (($0 | 0) < 0) << 31 >> 31 | 0) | 0;
  $41 = tempRet0;
  $43 = HEAP32[$opaque + 16 >> 2] | 0;
  $mul$i34 = Math_imul($43, HEAP32[$opaque + 12 >> 2] | 0) | 0;
  $45 = (($mul$i34 | 0) < 0) << 31 >> 31;
  $46 = ___divdi3($40 | 0, $41 | 0, $mul$i34 | 0, $45 | 0) | 0;
  $48 = ___remdi3($40 | 0, $41 | 0, $mul$i34 | 0, $45 | 0) | 0;
  HEAP8[$opaque + 38 >> 0] = $46 >>> 8;
  HEAP8[$opaque + 37 >> 0] = $46;
  HEAP8[$1 >> 0] = (($48 >>> 0) / ($43 >>> 0) | 0) & 15 | $conv$i & 240;
  HEAP8[$opaque + 36 >> 0] = (($48 >>> 0) % ($43 >>> 0) | 0) + 1;
 } else {
  $11 = _i64Add((HEAPU8[$opaque + 38 >> 0] | 0) << 16 | $conv$i << 24 & 251658240 | (HEAPU8[$opaque + 37 >> 0] | 0) << 8 | (HEAPU8[$opaque + 36 >> 0] | 0) | 0, 0, $0 | 0, (($0 | 0) < 0) << 31 >> 31 | 0) | 0;
  $12 = tempRet0;
  $13 = _bitshift64Lshr($11 | 0, $12 | 0, 24) | 0;
  HEAP8[$1 >> 0] = $conv$i & 240 | $13 & 15;
  $18 = _bitshift64Lshr($11 | 0, $12 | 0, 16) | 0;
  HEAP8[$opaque + 38 >> 0] = $18;
  $22 = _bitshift64Lshr($11 | 0, $12 | 0, 8) | 0;
  HEAP8[$opaque + 37 >> 0] = $22;
  HEAP8[$opaque + 36 >> 0] = $11;
 }
 $nsector = $opaque + 34 | 0;
 $and = (HEAPU16[$nsector >> 1] | 0) - $0 & 255;
 HEAP16[$nsector >> 1] = $and;
 if (!$and) HEAP8[$opaque + 40 >> 0] = 80; else {
  $56 = HEAP32[$opaque + 48 >> 2] | 0;
  $$and = ($and | 0) > ($56 | 0) ? $56 : $and;
  HEAP32[$io_nb_sectors >> 2] = $$and;
  HEAP32[$opaque + 52 >> 2] = 5;
  HEAP32[$opaque + 56 >> 2] = 0;
  HEAP32[$opaque + 60 >> 2] = $$and << 9;
  HEAP8[$opaque + 40 >> 0] = 88;
 }
 $$idx$val = HEAP32[$opaque >> 2] | 0;
 if (HEAP8[$$idx$val + 20 >> 0] & 2) {
  STACKTOP = sp;
  return;
 }
 FUNCTION_TABLE_vii[HEAP32[$$idx$val + 4 >> 2] & 1](HEAP32[$$idx$val >> 2] | 0, 1);
 STACKTOP = sp;
 return;
}
function _ide_sector_read_cb($opaque) {
 $opaque = $opaque | 0;
 var $$idx$val = 0, $0 = 0, $1 = 0, $11 = 0, $12 = 0, $13 = 0, $18 = 0, $22 = 0, $40 = 0, $41 = 0, $43 = 0, $45 = 0, $46 = 0, $48 = 0, $58 = 0, $59 = 0, $add$i = 0, $add26$i = 0, $and = 0, $conv$i = 0, $mul$i = 0, $mul$i29 = 0, $nsector = 0, sp = 0;
 sp = STACKTOP;
 $0 = HEAP32[$opaque + 44 >> 2] | 0;
 $1 = $opaque + 39 | 0;
 $conv$i = HEAPU8[$1 >> 0] | 0;
 if (!($conv$i & 64)) {
  $mul$i = Math_imul((HEAPU8[$opaque + 38 >> 0] | 0) << 8 | (HEAPU8[$opaque + 37 >> 0] | 0), HEAP32[$opaque + 12 >> 2] | 0) | 0;
  $add$i = Math_imul($mul$i + ($conv$i & 15) | 0, HEAP32[$opaque + 16 >> 2] | 0) | 0;
  $add26$i = (HEAPU8[$opaque + 36 >> 0] | 0) + -1 + $add$i | 0;
  $40 = _i64Add($add26$i | 0, (($add26$i | 0) < 0) << 31 >> 31 | 0, $0 | 0, (($0 | 0) < 0) << 31 >> 31 | 0) | 0;
  $41 = tempRet0;
  $43 = HEAP32[$opaque + 16 >> 2] | 0;
  $mul$i29 = Math_imul($43, HEAP32[$opaque + 12 >> 2] | 0) | 0;
  $45 = (($mul$i29 | 0) < 0) << 31 >> 31;
  $46 = ___divdi3($40 | 0, $41 | 0, $mul$i29 | 0, $45 | 0) | 0;
  $48 = ___remdi3($40 | 0, $41 | 0, $mul$i29 | 0, $45 | 0) | 0;
  HEAP8[$opaque + 38 >> 0] = $46 >>> 8;
  HEAP8[$opaque + 37 >> 0] = $46;
  HEAP8[$1 >> 0] = (($48 >>> 0) / ($43 >>> 0) | 0) & 15 | $conv$i & 240;
  HEAP8[$opaque + 36 >> 0] = (($48 >>> 0) % ($43 >>> 0) | 0) + 1;
 } else {
  $11 = _i64Add((HEAPU8[$opaque + 38 >> 0] | 0) << 16 | $conv$i << 24 & 251658240 | (HEAPU8[$opaque + 37 >> 0] | 0) << 8 | (HEAPU8[$opaque + 36 >> 0] | 0) | 0, 0, $0 | 0, (($0 | 0) < 0) << 31 >> 31 | 0) | 0;
  $12 = tempRet0;
  $13 = _bitshift64Lshr($11 | 0, $12 | 0, 24) | 0;
  HEAP8[$1 >> 0] = $conv$i & 240 | $13 & 15;
  $18 = _bitshift64Lshr($11 | 0, $12 | 0, 16) | 0;
  HEAP8[$opaque + 38 >> 0] = $18;
  $22 = _bitshift64Lshr($11 | 0, $12 | 0, 8) | 0;
  HEAP8[$opaque + 37 >> 0] = $22;
  HEAP8[$opaque + 36 >> 0] = $11;
 }
 $nsector = $opaque + 34 | 0;
 $and = (HEAPU16[$nsector >> 1] | 0) - $0 & 255;
 HEAP16[$nsector >> 1] = $and;
 HEAP32[$opaque + 52 >> 2] = ($and | 0) == 0 ? 10 : 9;
 HEAP32[$opaque + 56 >> 2] = 0;
 HEAP32[$opaque + 60 >> 2] = $0 << 9;
 $$idx$val = HEAP32[$opaque >> 2] | 0;
 if (HEAP8[$$idx$val + 20 >> 0] & 2) {
  $58 = $opaque + 40 | 0;
  HEAP8[$58 >> 0] = 88;
  $59 = $opaque + 33 | 0;
  HEAP8[$59 >> 0] = 0;
  STACKTOP = sp;
  return;
 }
 FUNCTION_TABLE_vii[HEAP32[$$idx$val + 4 >> 2] & 1](HEAP32[$$idx$val >> 2] | 0, 1);
 $58 = $opaque + 40 | 0;
 HEAP8[$58 >> 0] = 88;
 $59 = $opaque + 33 | 0;
 HEAP8[$59 >> 0] = 0;
 STACKTOP = sp;
 return;
}
function _add_sf32($a, $b, $rm, $pfflags) {
 $a = $a | 0;
 $b = $b | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $2 = 0, $a$addr$0$i = 0, $a$b = 0, $a_exp$0 = 0, $a_mant$0 = 0, $a_mant$1 = 0, $a_sign$0 = 0, $add48 = 0, $and6 = 0, $and8 = 0, $and9 = 0, $b$a = 0, $b_exp$0 = 0, $b_mant$0 = 0, $cmp = 0, $cmp33 = 0, $retval$0 = 0, $shl = 0, $shl11 = 0, $shr = 0, $shr4 = 0, $sub = 0, $sub42 = 0, $sub8$i = 0, sp = 0;
 sp = STACKTOP;
 $cmp = ($a & 2147483647) >>> 0 < ($b & 2147483647) >>> 0;
 $a$b = $cmp ? $a : $b;
 $b$a = $cmp ? $b : $a;
 $shr = $b$a >>> 31;
 $shr4 = $a$b >>> 31;
 $and6 = $b$a >>> 23 & 255;
 $and8 = $a$b >>> 23 & 255;
 $and9 = $b$a << 3;
 $shl = $and9 & 67108856;
 $shl11 = $a$b << 3 & 67108856;
 if (($and6 | 0) == 255) {
  if (!$shl) {
   if (($and8 | 0) != 255 | ($shr | 0) == ($shr4 | 0)) {
    $retval$0 = $b$a;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
   HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
   $retval$0 = 2143289344;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if ($and9 & 33554432) if (!(($a$b & 2143289344 | 0) == 2139095040 & ($a$b & 8388607 | 0) != 0)) {
   $retval$0 = 2143289344;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $retval$0 = 2143289344;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else if (!$and6) {
  $a_exp$0 = 1;
  $a_mant$0 = $shl;
 } else {
  $a_exp$0 = $and6;
  $a_mant$0 = $shl | 67108864;
 }
 $cmp33 = ($and8 | 0) == 0;
 $b_exp$0 = $cmp33 ? 1 : $and8;
 $b_mant$0 = $cmp33 ? $shl11 : $shl11 | 67108864;
 $sub = $a_exp$0 - $b_exp$0 | 0;
 do if (($a_exp$0 | 0) == ($b_exp$0 | 0)) $a$addr$0$i = $b_mant$0; else if (($sub | 0) > 31) {
  $a$addr$0$i = ($b_mant$0 | 0) != 0 & 1;
  break;
 } else {
  $a$addr$0$i = ((1 << $sub) + 134217727 & $b_mant$0 | 0) != 0 | $b_mant$0 >>> $sub;
  break;
 } while (0);
 if (($shr | 0) == ($shr4 | 0)) {
  $a_mant$1 = $a$addr$0$i + $a_mant$0 | 0;
  $a_sign$0 = $shr;
 } else {
  $sub42 = $a_mant$0 - $a$addr$0$i | 0;
  if (($a_mant$0 | 0) == ($a$addr$0$i | 0)) {
   $a_mant$1 = $sub42;
   $a_sign$0 = ($rm | 0) == 2 & 1;
  } else {
   $a_mant$1 = $sub42;
   $a_sign$0 = $shr;
  }
 }
 $add48 = $a_exp$0 + 4 | 0;
 if (!$a_mant$1) $sub8$i = 31; else {
  $2 = _llvm_ctlz_i32($a_mant$1 | 0) | 0;
  if (!$2) ___assert_fail(1104, 1064, 183, 1168); else $sub8$i = $2 + -1 | 0;
 }
 $retval$0 = _roundpack_sf32($a_sign$0, $add48 - $sub8$i | 0, $a_mant$1 << $sub8$i, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _riscv_machine_run($opaque) {
 $opaque = $opaque | 0;
 var $0 = 0, $11 = 0, $13 = 0, $16 = 0, $17 = 0, $19 = 0, $22 = 0, $27 = 0, $29 = 0, $35 = 0, $37 = 0, $43 = 0, $45 = 0, $46 = 0, $47 = 0, $49 = 0, $54 = 0, $56 = 0, $60 = 0, $69 = 0, $74 = 0, $80 = 0, $86 = 0, $88 = 0, $buf$i = 0, $div$i$i = 0, $htif_fromhost$i = 0, $insn_counter = 0, $mip = 0, sp = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 16 | 0;
 $buf$i = sp;
 $0 = HEAP32[$opaque >> 2] | 0;
 $mip = $0 + 608 | 0;
 if ((HEAP32[$mip >> 2] & 128 | 0) == 0 & 0 == 0) {
  $11 = $0 + 536 | 0;
  $13 = HEAP32[$11 >> 2] | 0;
  $16 = HEAP32[$11 + 4 >> 2] | 0;
  $17 = HEAP32[$0 + 1392 >> 2] | 0;
  if (!(HEAP32[$17 + 20 >> 2] | 0)) {
   $37 = $0 + 528 | 0;
   $43 = _bitshift64Lshr(HEAP32[$37 >> 2] | 0, HEAP32[$37 + 4 >> 2] | 0, 4) | 0;
   $45 = $43;
   $46 = tempRet0;
  } else {
   _clock_gettime(1, $buf$i | 0) | 0;
   $19 = HEAP32[$buf$i >> 2] | 0;
   $22 = ___muldi3($19 | 0, (($19 | 0) < 0) << 31 >> 31 | 0, 1e7, 0) | 0;
   $div$i$i = (HEAP32[$buf$i + 4 >> 2] | 0) / 100 | 0;
   $27 = _i64Add($div$i$i | 0, (($div$i$i | 0) < 0) << 31 >> 31 | 0, $22 | 0, tempRet0 | 0) | 0;
   $29 = $17 + 24 | 0;
   $35 = _i64Subtract($27 | 0, tempRet0 | 0, HEAP32[$29 >> 2] | 0, HEAP32[$29 + 4 >> 2] | 0) | 0;
   $45 = $35;
   $46 = tempRet0;
  }
  $47 = _i64Subtract($13 | 0, $16 | 0, $45 | 0, $46 | 0) | 0;
  if (($47 | 0) < 1) {
   $49 = $mip;
   $54 = HEAP32[$49 + 4 >> 2] | 0;
   $56 = $mip;
   HEAP32[$56 >> 2] = HEAP32[$49 >> 2] | 128;
   HEAP32[$56 + 4 >> 2] = $54;
   HEAP32[$0 + 544 >> 2] = 0;
  }
 }
 $htif_fromhost$i = $opaque + 56 | 0;
 $60 = $htif_fromhost$i;
 if ((HEAP32[$60 >> 2] | 0) == 0 & (HEAP32[$60 + 4 >> 2] | 0) == 0) {
  $69 = HEAP32[$opaque + 40 >> 2] | 0;
  if ((FUNCTION_TABLE_iiii[HEAP32[$69 + 8 >> 2] & 3](HEAP32[$69 >> 2] | 0, $buf$i, 1) | 0) == 1) {
   $74 = $htif_fromhost$i;
   HEAP32[$74 >> 2] = HEAPU8[$buf$i >> 0];
   HEAP32[$74 + 4 >> 2] = 16777216;
  }
 }
 if (!(HEAP32[$0 + 544 >> 2] | 0)) {
  _riscv_cpu_interp($0);
  _emscripten_async_call(2, $opaque | 0, 0);
  STACKTOP = sp;
  return;
 }
 if (!(HEAP32[$opaque + 20 >> 2] | 0)) {
  $insn_counter = $0 + 528 | 0;
  $80 = $insn_counter;
  $86 = _i64Add(HEAP32[$80 >> 2] | 0, HEAP32[$80 + 4 >> 2] | 0, 1e6, 0) | 0;
  $88 = $insn_counter;
  HEAP32[$88 >> 2] = $86;
  HEAP32[$88 + 4 >> 2] = tempRet0;
 }
 _emscripten_async_call(2, $opaque | 0, 10);
 STACKTOP = sp;
 return;
}
function _mul_sf32($a, $b, $rm, $pfflags) {
 $a = $a | 0;
 $b = $b | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $10 = 0, $6 = 0, $7 = 0, $8 = 0, $a_mant$0 = 0, $and = 0, $and4 = 0, $and5 = 0, $and6 = 0, $b_mant$0 = 0, $cmp = 0, $cmp2$i = 0, $cmp7 = 0, $or57 = 0, $retval$0 = 0, $sub2$i4766 = 0, $sub2$i65 = 0, $sub8$i = 0, $xor = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $xor = ($b ^ $a) >>> 31;
 $and = $a >>> 23 & 255;
 $and4 = $b >>> 23 & 255;
 $and5 = $a & 8388607;
 $and6 = $b & 8388607;
 $cmp = ($and | 0) == 255;
 $cmp7 = ($and4 | 0) == 255;
 if ($cmp | $cmp7) {
  $cmp2$i = ($and5 | 0) != 0;
  if (!(($a & 2139095040 | 0) == 2139095040 & $cmp2$i)) if (!(($b & 2139095040 | 0) == 2139095040 & ($and6 | 0) != 0)) {
   if ($cmp) {
    if ($and4 | $and6) label = 9;
   } else label = 9;
   do if ((label | 0) == 9) {
    if ($cmp7) if (!($and | $and5)) break;
    $retval$0 = $xor << 31 | 2139095040;
    STACKTOP = sp;
    return $retval$0 | 0;
   } while (0);
   HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
   $retval$0 = 2143289344;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if (!(($a & 2143289344 | 0) == 2139095040 & $cmp2$i)) if (!(($b & 2143289344 | 0) == 2139095040 & ($and6 | 0) != 0)) {
   $retval$0 = 2143289344;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $retval$0 = 2143289344;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 do if (!$and) {
  if ($and5) {
   $6 = _llvm_ctlz_i32($and5 | 0) | 0;
   $a_mant$0 = $and5 << $6 + -8;
   $sub2$i4766 = 9 - $6 | 0;
   break;
  }
  $retval$0 = $xor << 31;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else {
  $a_mant$0 = $and5 | 8388608;
  $sub2$i4766 = $and;
 } while (0);
 do if (!$and4) {
  if ($and6) {
   $7 = _llvm_ctlz_i32($and6 | 0) | 0;
   $b_mant$0 = $and6 << $7 + -8;
   $sub2$i65 = 9 - $7 | 0;
   break;
  }
  $retval$0 = $xor << 31;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else {
  $b_mant$0 = $and6 | 8388608;
  $sub2$i65 = $and4;
 } while (0);
 $8 = ___muldi3($b_mant$0 << 8 | 0, 0, $a_mant$0 << 7 | 0, 0) | 0;
 $or57 = ($8 | 0) != 0 | tempRet0;
 if (!$or57) $sub8$i = 31; else {
  $10 = _llvm_ctlz_i32($or57 | 0) | 0;
  if (!$10) ___assert_fail(1104, 1064, 183, 1168); else $sub8$i = $10 + -1 | 0;
 }
 $retval$0 = _roundpack_sf32($xor, $sub2$i4766 + -126 + $sub2$i65 - $sub8$i | 0, $or57 << $sub8$i, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _main($argc, $argv) {
 $argc = $argc | 0;
 $argv = $argv | 0;
 var $0 = 0, $4 = 0, $cached_blocks$i = 0, $call$i$i = 0, $call$i$i1 = 0, $call$i1$i = 0, $read_data$i = 0, $retval$0$i$i = 0, $retval$0$i$i4 = 0, $retval$0$i4$i = 0, $write_data$i = 0, dest = 0, sp = 0, src = 0, stop = 0;
 sp = STACKTOP;
 _emscripten_asm_const(200);
 $call$i$i = _malloc(16) | 0;
 if (!$call$i$i) $retval$0$i$i = 0; else {
  dest = $call$i$i + 0 | 0;
  stop = dest + 16 | 0;
  do {
   HEAP8[dest >> 0] = 0;
   dest = dest + 1 | 0;
  } while ((dest | 0) < (stop | 0));
  $retval$0$i$i = $call$i$i;
 }
 $call$i1$i = _malloc(1096) | 0;
 if (!$call$i1$i) $retval$0$i4$i = 0; else {
  _memset($call$i1$i | 0, 0, 1096) | 0;
  $retval$0$i4$i = $call$i1$i;
 }
 dest = $retval$0$i4$i + 24 | 0;
 src = 456 | 0;
 stop = dest + 25 | 0;
 do {
  HEAP8[dest >> 0] = HEAP8[src >> 0] | 0;
  dest = dest + 1 | 0;
  src = src + 1 | 0;
 } while ((dest | 0) < (stop | 0));
 HEAP32[$retval$0$i4$i + 16 >> 2] = 512;
 $0 = $retval$0$i4$i + 8 | 0;
 HEAP32[$0 >> 2] = 524288;
 HEAP32[$0 + 4 >> 2] = 0;
 HEAP32[$retval$0$i4$i + 20 >> 2] = 1024;
 $cached_blocks$i = $retval$0$i4$i + 1048 | 0;
 HEAP32[$cached_blocks$i >> 2] = $cached_blocks$i;
 HEAP32[$retval$0$i4$i + 1052 >> 2] = $cached_blocks$i;
 HEAP32[$retval$0$i4$i + 1056 >> 2] = 0;
 HEAP32[$retval$0$i4$i + 1060 >> 2] = 32;
 HEAP32[$retval$0$i$i + 12 >> 2] = $retval$0$i4$i;
 HEAP32[$retval$0$i$i >> 2] = 1;
 HEAP32[$retval$0$i$i + 4 >> 2] = 1;
 HEAP32[$retval$0$i$i + 8 >> 2] = 2;
 $call$i$i1 = _malloc(12) | 0;
 if (!$call$i$i1) {
  $retval$0$i$i4 = 0;
  $write_data$i = $retval$0$i$i4 + 4 | 0;
  HEAP32[$write_data$i >> 2] = 1;
  $read_data$i = $retval$0$i$i4 + 8 | 0;
  HEAP32[$read_data$i >> 2] = 2;
  HEAP32[122] = 268435456;
  $4 = _riscv_machine_init(268435456, 0, 1, $retval$0$i$i4, $retval$0$i$i) | 0;
  _emscripten_async_wget_data(496, $4 | 0, 2, 1);
  STACKTOP = sp;
  return 0;
 }
 dest = $call$i$i1 + 0 | 0;
 stop = dest + 12 | 0;
 do {
  HEAP8[dest >> 0] = 0;
  dest = dest + 1 | 0;
 } while ((dest | 0) < (stop | 0));
 $retval$0$i$i4 = $call$i$i1;
 $write_data$i = $retval$0$i$i4 + 4 | 0;
 HEAP32[$write_data$i >> 2] = 1;
 $read_data$i = $retval$0$i$i4 + 8 | 0;
 HEAP32[$read_data$i >> 2] = 2;
 HEAP32[122] = 268435456;
 $4 = _riscv_machine_init(268435456, 0, 1, $retval$0$i$i4, $retval$0$i$i) | 0;
 _emscripten_async_wget_data(496, $4 | 0, 2, 1);
 STACKTOP = sp;
 return 0;
}
function _internal_cvt_sf32_i64($a, $rm, $pfflags, $is_unsigned) {
 $a = $a | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 $is_unsigned = $is_unsigned | 0;
 var $0 = 0, $10 = 0, $2 = 0, $20 = 0, $21 = 0, $22 = 0, $26 = 0, $27 = 0, $4 = 0, $5 = 0, $7 = 0, $a$addr$0$i = 0, $a_exp$0 = 0, $a_mant$0 = 0, $a_mant$1 = 0, $a_sign$0 = 0, $addend$0 = 0, $and = 0, $and2 = 0, $and40 = 0, $shl = 0, $shr41 = 0, $sub31 = 0, $tobool62 = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $and = $a >>> 23 & 255;
 $and2 = $a & 8388607;
 $a_sign$0 = ($and | 0) != 255 | ($and2 | 0) == 0 ? $a >>> 31 : 0;
 if (!$and) {
  $a_exp$0 = -149;
  $a_mant$0 = $and2;
 } else {
  $a_exp$0 = $and + -150 | 0;
  $a_mant$0 = $and2 | 8388608;
 }
 $shl = $a_mant$0 << 7;
 if (!$is_unsigned) {
  $2 = _i64Subtract(0, -2147483648, $a_sign$0 ^ 1 | 0, 0) | 0;
  $10 = $2;
  $7 = tempRet0;
 } else {
  $0 = _i64Add($a_sign$0 | 0, 0, -1, -1) | 0;
  $10 = $0;
  $7 = tempRet0;
 }
 if (($a_exp$0 | 0) > -1) if (($a_exp$0 | 0) < 41) {
  $4 = _bitshift64Shl($a_mant$0 & 33554431 | 0, 0, $a_exp$0 | 0) | 0;
  $5 = tempRet0;
  if ($5 >>> 0 > $7 >>> 0 | ($5 | 0) == ($7 | 0) & $4 >>> 0 > $10 >>> 0) label = 9; else {
   $20 = $4;
   $21 = $5;
   label = 19;
  }
 } else label = 9; else {
  $sub31 = 0 - $a_exp$0 | 0;
  if (($sub31 | 0) > 31) $a$addr$0$i = ($a_mant$0 | 0) != 0 & 1; else $a$addr$0$i = ((1 << $sub31) + -1 & $shl | 0) != 0 | $shl >>> $sub31;
  if (($rm | 0) == 4 | ($rm | 0) == 0) $addend$0 = 64; else if (($rm | 0) == 1) $addend$0 = 0; else $addend$0 = ($a_sign$0 | 0) == ($rm & 1 | 0) ? 0 : 127;
  $and40 = $a$addr$0$i & 127;
  $shr41 = ($addend$0 + $a$addr$0$i | 0) >>> 7;
  $a_mant$1 = ($rm | 0) == 0 & ($and40 | 0) == 64 ? $shr41 & 33554430 : $shr41;
  if (0 > $7 >>> 0 | 0 == ($7 | 0) & $a_mant$1 >>> 0 > $10 >>> 0) label = 9; else if (!$and40) {
   $20 = $a_mant$1;
   $21 = 0;
   label = 19;
  } else {
   HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 16;
   $20 = $a_mant$1;
   $21 = 0;
   label = 19;
  }
 }
 if ((label | 0) == 9) {
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $26 = $7;
  $27 = $10;
  tempRet0 = $26;
  STACKTOP = sp;
  return $27 | 0;
 } else if ((label | 0) == 19) {
  $tobool62 = ($a_sign$0 | 0) == 0;
  $22 = _i64Subtract(0, 0, $20 | 0, $21 | 0) | 0;
  $26 = $tobool62 ? $21 : tempRet0;
  $27 = $tobool62 ? $20 : $22;
  tempRet0 = $26;
  STACKTOP = sp;
  return $27 | 0;
 }
 return 0;
}
function _internal_cvt_sf64_i32($0, $1, $rm, $pfflags, $is_unsigned) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 $is_unsigned = $is_unsigned | 0;
 var $11 = 0, $12 = 0, $13 = 0, $14 = 0, $2 = 0, $20 = 0, $22 = 0, $23 = 0, $24 = 0, $35 = 0, $36 = 0, $37 = 0, $38 = 0, $39 = 0, $4 = 0, $41 = 0, $42 = 0, $45 = 0, $46 = 0, $6 = 0, $a_exp$0 = 0, $a_sign$0 = 0, $conv2 = 0, $conv44 = 0, $or$cond29 = 0, $r_max$0 = 0, $retval$0 = 0, $sub34 = 0, $tobool39 = 0, sp = 0;
 sp = STACKTOP;
 $2 = _bitshift64Lshr($0 | 0, $1 | 0, 63) | 0;
 $4 = _bitshift64Lshr($0 | 0, $1 | 0, 52) | 0;
 $conv2 = $4 & 2047;
 $6 = $1 & 1048575;
 $a_sign$0 = ($conv2 | 0) != 2047 | ($0 | 0) == 0 & ($6 | 0) == 0 ? $2 : 0;
 if (!$conv2) {
  $11 = $0;
  $12 = $6;
  $a_exp$0 = -1074;
 } else {
  $11 = $0;
  $12 = $6 | 1048576;
  $a_exp$0 = $conv2 + -1075 | 0;
 }
 $13 = _bitshift64Shl($11 | 0, $12 | 0, 10) | 0;
 $14 = tempRet0;
 if (!$is_unsigned) $r_max$0 = -2147483648 - ($a_sign$0 ^ 1) | 0; else $r_max$0 = $a_sign$0 + -1 | 0;
 if (($a_exp$0 | 0) <= -1) {
  $sub34 = 0 - $a_exp$0 | 0;
  if (($sub34 | 0) > 63) {
   $35 = (($11 | 0) != 0 | ($12 | 0) != 0) & 1;
   $38 = 0;
  } else {
   $20 = _bitshift64Shl(1, 0, $sub34 | 0) | 0;
   $22 = _i64Add($20 | 0, tempRet0 | 0, -1, -1) | 0;
   $23 = tempRet0;
   $24 = _bitshift64Lshr($13 | 0, $14 | 0, $sub34 | 0) | 0;
   $35 = (($22 & $13 | 0) != 0 | ($23 & $14 | 0) != 0) & 1 | $24;
   $38 = tempRet0;
  }
  if (($rm | 0) == 1) {
   $36 = 0;
   $37 = 0;
  } else if (($rm | 0) == 4 | ($rm | 0) == 0) {
   $36 = 512;
   $37 = 0;
  } else {
   $tobool39 = ($a_sign$0 | 0) == ($rm & 1 | 0);
   $36 = $tobool39 ? 0 : 1023;
   $37 = $tobool39 ? 0 : 0;
  }
  $conv44 = $35 & 1023;
  $39 = _i64Add($36 | 0, $37 | 0, $35 | 0, $38 | 0) | 0;
  $41 = _bitshift64Lshr($39 | 0, tempRet0 | 0, 10) | 0;
  $42 = tempRet0;
  $or$cond29 = ($rm | 0) == 0 & ($conv44 | 0) == 512;
  $45 = $or$cond29 ? $41 & -2 : $41;
  $46 = $or$cond29 ? $42 & 4194303 : $42;
  if (!($46 >>> 0 > 0 | ($46 | 0) == 0 & $45 >>> 0 > $r_max$0 >>> 0)) {
   if ($conv44) HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 16;
   $retval$0 = ($a_sign$0 | 0) == 0 ? $45 : 0 - $45 | 0;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $retval$0 = $r_max$0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _htif_write($opaque, $0, $1, $2, $3, $size_log2) {
 $opaque = $opaque | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $size_log2 = $size_log2 | 0;
 var $10 = 0, $14 = 0, $18 = 0, $26 = 0, $28 = 0, $31 = 0, $35 = 0, $39 = 0, $4 = 0, $43 = 0, $47 = 0, $57 = 0, $buf$i = 0, $conv3$i = 0, $htif_fromhost12 = 0, $htif_tohost3 = 0, $vararg_buffer = 0, sp = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 16 | 0;
 $vararg_buffer = sp;
 $buf$i = sp + 8 | 0;
 if (($size_log2 | 0) != 2) ___assert_fail(840, 56, 1755, 856);
 if (($0 | 0) == 12) {
  if ($1) {
   STACKTOP = sp;
   return;
  }
  $htif_fromhost12 = $opaque + 56 | 0;
  $57 = $htif_fromhost12;
  HEAP32[$57 >> 2] = HEAP32[$htif_fromhost12 >> 2];
  HEAP32[$57 + 4 >> 2] = $2;
  STACKTOP = sp;
  return;
 } else if (!$0) {
  if ($1) {
   STACKTOP = sp;
   return;
  }
  $4 = $opaque + 48 | 0;
  HEAP32[$4 >> 2] = $2;
  HEAP32[$4 + 4 >> 2] = $3;
  STACKTOP = sp;
  return;
 } else if (($0 | 0) == 8) {
  if ($1) {
   STACKTOP = sp;
   return;
  }
  $47 = $opaque + 56 | 0;
  HEAP32[$47 >> 2] = $2;
  HEAP32[$47 + 4 >> 2] = $3;
  STACKTOP = sp;
  return;
 } else if (($0 | 0) == 4) {
  if ($1) {
   STACKTOP = sp;
   return;
  }
  $htif_tohost3 = $opaque + 48 | 0;
  $10 = HEAP32[$htif_tohost3 >> 2] | 0;
  $14 = $htif_tohost3;
  HEAP32[$14 >> 2] = $10;
  HEAP32[$14 + 4 >> 2] = $2;
  $18 = _bitshift64Lshr($2 | 0, $3 | 0, 16) | 0;
  $conv3$i = $18 & 255;
  if (($10 | 0) == 1 & ($2 | 0) == 0) {
   _puts(1040) | 0;
   _exit(0);
  }
  $26 = 0 == 0 & ($2 & -16777216 | 0) == 16777216;
  if ($26 & ($conv3$i | 0) == 1) {
   HEAP8[$buf$i >> 0] = $10;
   $28 = HEAP32[$opaque + 40 >> 2] | 0;
   FUNCTION_TABLE_viii[HEAP32[$28 + 4 >> 2] & 3](HEAP32[$28 >> 2] | 0, $buf$i, 1);
   $31 = $htif_tohost3;
   HEAP32[$31 >> 2] = 0;
   HEAP32[$31 + 4 >> 2] = 0;
   $35 = $opaque + 56 | 0;
   HEAP32[$35 >> 2] = 0;
   HEAP32[$35 + 4 >> 2] = 16842752;
   STACKTOP = sp;
   return;
  }
  if ($26 & ($conv3$i | 0) == 0) {
   $39 = $htif_tohost3;
   HEAP32[$39 >> 2] = 0;
   HEAP32[$39 + 4 >> 2] = 0;
   STACKTOP = sp;
   return;
  } else {
   $43 = $vararg_buffer;
   HEAP32[$43 >> 2] = $10;
   HEAP32[$43 + 4 >> 2] = $2;
   _printf(872, $vararg_buffer | 0) | 0;
   STACKTOP = sp;
   return;
  }
 } else {
  STACKTOP = sp;
  return;
 }
}
function _internal_cvt_sf32_i32($a, $rm, $pfflags, $is_unsigned) {
 $a = $a | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 $is_unsigned = $is_unsigned | 0;
 var $a$addr$0$i = 0, $a_exp$0 = 0, $a_mant$0 = 0, $a_mant$1 = 0, $a_sign$0 = 0, $addend$0 = 0, $and = 0, $and2 = 0, $and35 = 0, $r$0 = 0, $r_max$0 = 0, $retval$0 = 0, $shl = 0, $shl18 = 0, $shr36 = 0, $sub26 = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $and = $a >>> 23 & 255;
 $and2 = $a & 8388607;
 $a_sign$0 = ($and | 0) != 255 | ($and2 | 0) == 0 ? $a >>> 31 : 0;
 if (!$and) {
  $a_exp$0 = -149;
  $a_mant$0 = $and2;
 } else {
  $a_exp$0 = $and + -150 | 0;
  $a_mant$0 = $and2 | 8388608;
 }
 $shl = $a_mant$0 << 7;
 if (!$is_unsigned) $r_max$0 = -2147483648 - ($a_sign$0 ^ 1) | 0; else $r_max$0 = $a_sign$0 + -1 | 0;
 if (($a_exp$0 | 0) > -1) if (($a_exp$0 | 0) < 9) {
  $shl18 = ($a_mant$0 & 33554431) << $a_exp$0;
  if ($shl18 >>> 0 > $r_max$0 >>> 0) label = 9; else {
   $r$0 = $shl18;
   label = 19;
  }
 } else label = 9; else {
  $sub26 = 0 - $a_exp$0 | 0;
  if (($sub26 | 0) > 31) $a$addr$0$i = ($a_mant$0 | 0) != 0 & 1; else $a$addr$0$i = ((1 << $sub26) + -1 & $shl | 0) != 0 | $shl >>> $sub26;
  if (($rm | 0) == 1) $addend$0 = 0; else if (($rm | 0) == 4 | ($rm | 0) == 0) $addend$0 = 64; else $addend$0 = ($a_sign$0 | 0) == ($rm & 1 | 0) ? 0 : 127;
  $and35 = $a$addr$0$i & 127;
  $shr36 = ($addend$0 + $a$addr$0$i | 0) >>> 7;
  $a_mant$1 = ($rm | 0) == 0 & ($and35 | 0) == 64 ? $shr36 & 33554430 : $shr36;
  if ($a_mant$1 >>> 0 > $r_max$0 >>> 0) label = 9; else if (!$and35) {
   $r$0 = $a_mant$1;
   label = 19;
  } else {
   HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 16;
   $r$0 = $a_mant$1;
   label = 19;
  }
 }
 if ((label | 0) == 9) {
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $retval$0 = $r_max$0;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else if ((label | 0) == 19) {
  $retval$0 = ($a_sign$0 | 0) == 0 ? $r$0 : 0 - $r$0 | 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 return 0;
}
function _roundpack_sf32($a_sign, $a_exp, $a_mant, $rm, $pfflags) {
 $a_sign = $a_sign | 0;
 $a_exp = $a_exp | 0;
 $a_mant = $a_mant | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $0 = 0, $a$addr$0$i = 0, $a_exp$addr$0 = 0, $a_exp$addr$2 = 0, $a_mant$addr$0 = 0, $a_mant$addr$1 = 0, $a_mant$addr$3 = 0, $add26 = 0, $addend$0 = 0, $and6 = 0, $cmp32 = 0, $rnd_bits$0 = 0, $shr = 0, $sub29 = 0, sp = 0;
 sp = STACKTOP;
 if (($rm | 0) == 4 | ($rm | 0) == 0) $addend$0 = 64; else if (($rm | 0) == 1) $addend$0 = 0; else $addend$0 = ($rm & 1 | 0) == ($a_sign | 0) ? 0 : 127;
 if (($a_exp | 0) < 1) {
  if (($a_exp | 0) < 0) $0 = 0; else $0 = ($addend$0 + $a_mant | 0) < 0;
  $sub29 = 1 - $a_exp | 0;
  if (($sub29 | 0) > 31) $a$addr$0$i = ($a_mant | 0) != 0 & 1; else $a$addr$0$i = ((1 << $sub29) + -1 & $a_mant | 0) != 0 | $a_mant >>> $sub29;
  $and6 = $a$addr$0$i & 127;
  if ($0 | ($and6 | 0) == 0) {
   $a_exp$addr$0 = 1;
   $a_mant$addr$0 = $a$addr$0$i;
   $rnd_bits$0 = $and6;
  } else {
   HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 2;
   $a_exp$addr$0 = 1;
   $a_mant$addr$0 = $a$addr$0$i;
   $rnd_bits$0 = $and6;
  }
 } else {
  $a_exp$addr$0 = $a_exp;
  $a_mant$addr$0 = $a_mant;
  $rnd_bits$0 = $a_mant & 127;
 }
 if ($rnd_bits$0) HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 16;
 $shr = ($a_mant$addr$0 + $addend$0 | 0) >>> 7;
 $a_mant$addr$1 = ($rm | 0) == 0 & ($rnd_bits$0 | 0) == 64 ? $shr & 33554430 : $shr;
 $add26 = ($a_mant$addr$1 >>> 24) + $a_exp$addr$0 | 0;
 if ($a_mant$addr$1 >>> 0 < 8388608) {
  $a_exp$addr$2 = 0;
  $a_mant$addr$3 = $a_mant$addr$1;
 } else if (($add26 | 0) > 254) {
  $cmp32 = ($addend$0 | 0) == 0;
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 20;
  $a_exp$addr$2 = $cmp32 ? 254 : 255;
  $a_mant$addr$3 = $cmp32 ? 8388607 : 0;
 } else {
  $a_exp$addr$2 = $add26;
  $a_mant$addr$3 = $a_mant$addr$1;
 }
 STACKTOP = sp;
 return $a_mant$addr$3 & 8388607 | $a_sign << 31 | $a_exp$addr$2 << 23 | 0;
}
function _ide_mmio_read_u32($s, $offset) {
 $s = $s | 0;
 $offset = $offset | 0;
 var $0 = 0, $6 = 0, $add3$i = 0, $conv13$i = 0, $data_index$i = 0, $or$i = 0, $s$idx$val = 0, $s$idx5$val = 0, $shr = 0, $val$0 = 0, sp = 0;
 sp = STACKTOP;
 $shr = $offset >>> 2;
 L1 : do if (($shr | 0) == 8) {
  $s$idx5$val = HEAP32[$s + 8 >> 2] | 0;
  if (!$s$idx5$val) $val$0 = 0; else $val$0 = HEAPU8[$s$idx5$val + 40 >> 0] | 0;
 } else if (!$shr) {
  $s$idx$val = HEAP32[$s + 8 >> 2] | 0;
  if (!$s$idx$val) $val$0 = 0; else {
   $data_index$i = $s$idx$val + 56 | 0;
   $0 = HEAP32[$data_index$i >> 2] | 0;
   $or$i = (HEAPU8[$s$idx$val + ($0 + 1) + 64 >> 0] | 0) << 8 | (HEAPU8[$s$idx$val + $0 + 64 >> 0] | 0);
   $add3$i = $0 + 2 | 0;
   HEAP32[$data_index$i >> 2] = $add3$i;
   if (($add3$i | 0) < (HEAP32[$s$idx$val + 60 >> 2] | 0)) $val$0 = $or$i; else {
    FUNCTION_TABLE_vi[HEAP32[$s$idx$val + 52 >> 2] & 15]($s$idx$val);
    $val$0 = $or$i;
   }
  }
 } else {
  $6 = HEAP32[$s + 8 >> 2] | 0;
  if (!$6) $val$0 = 255; else switch ($shr & 7 | 0) {
  case 5:
   {
    $val$0 = HEAPU8[$6 + 38 >> 0] | 0;
    break L1;
    break;
   }
  case 4:
   {
    $val$0 = HEAPU8[$6 + 37 >> 0] | 0;
    break L1;
    break;
   }
  case 6:
   {
    $val$0 = HEAPU8[$6 + 39 >> 0] | 0;
    break L1;
    break;
   }
  case 2:
   {
    $val$0 = HEAPU16[$6 + 34 >> 1] | 0;
    break L1;
    break;
   }
  case 1:
   {
    $val$0 = HEAPU8[$6 + 33 >> 0] | 0;
    break L1;
    break;
   }
  case 0:
   {
    $val$0 = 255;
    break L1;
    break;
   }
  case 3:
   {
    $val$0 = HEAPU8[$6 + 36 >> 0] | 0;
    break L1;
    break;
   }
  default:
   {
    $conv13$i = HEAPU8[$6 + 40 >> 0] | 0;
    FUNCTION_TABLE_vii[HEAP32[$s + 4 >> 2] & 1](HEAP32[$s >> 2] | 0, 0);
    $val$0 = $conv13$i;
    break L1;
   }
  }
 } while (0);
 STACKTOP = sp;
 return $val$0 | 0;
}
function _plic_read($opaque, $0, $1, $size_log2) {
 $opaque = $opaque | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $size_log2 = $size_log2 | 0;
 var $$idx$val = 0, $10 = 0, $13 = 0, $16 = 0, $17 = 0, $18 = 0, $23 = 0, $34 = 0, $35 = 0, $5 = 0, $6 = 0, $8 = 0, $and = 0, $i$05$i = 0, $mip$i = 0, $or = 0, $plic_served_irq = 0, $power_down_flag$i = 0, $retval$0$i = 0, $tobool$i8 = 0, sp = 0;
 sp = STACKTOP;
 if (($size_log2 | 0) != 2) ___assert_fail(840, 56, 1855, 944);
 if (!(($0 | 0) == 4 & ($1 | 0) == 0)) {
  $34 = 0;
  $35 = 0;
  tempRet0 = $34;
  STACKTOP = sp;
  return $35 | 0;
 }
 $5 = HEAP32[$opaque + 32 >> 2] | 0;
 $plic_served_irq = $opaque + 36 | 0;
 $6 = HEAP32[$plic_served_irq >> 2] | 0;
 $and = $5 & ~$6;
 if (!$and) {
  $34 = 0;
  $35 = 0;
  tempRet0 = $34;
  STACKTOP = sp;
  return $35 | 0;
 } else $i$05$i = 0;
 while (1) {
  if (1 << $i$05$i & $and) {
   $retval$0$i = $i$05$i;
   break;
  }
  $i$05$i = $i$05$i + 1 | 0;
  if (($i$05$i | 0) >= 32) {
   $retval$0$i = 32;
   break;
  }
 }
 $or = $6 | 1 << $retval$0$i;
 HEAP32[$plic_served_irq >> 2] = $or;
 $$idx$val = HEAP32[$opaque >> 2] | 0;
 $tobool$i8 = ($5 & ~$or | 0) == 0;
 $mip$i = $$idx$val + 608 | 0;
 $8 = $mip$i;
 $10 = HEAP32[$8 >> 2] | 0;
 $13 = HEAP32[$8 + 4 >> 2] | 0;
 $16 = $tobool$i8 ? $10 & -2561 : $10 | 2560;
 $17 = $tobool$i8 ? $13 : $13;
 $18 = $mip$i;
 HEAP32[$18 >> 2] = $16;
 HEAP32[$18 + 4 >> 2] = $17;
 $power_down_flag$i = $$idx$val + 544 | 0;
 if (HEAP32[$power_down_flag$i >> 2] | 0) {
  $23 = $$idx$val + 560 | 0;
  if (!((HEAP32[$23 >> 2] & $16 | 0) == 0 ? (HEAP32[$23 + 4 >> 2] & $17 | 0) == 0 : 0)) HEAP32[$power_down_flag$i >> 2] = 0;
 }
 $34 = 0;
 $35 = $retval$0$i + 1 | 0;
 tempRet0 = $34;
 STACKTOP = sp;
 return $35 | 0;
}
function _cvt_sf64_sf32($0, $1, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $15 = 0, $2 = 0, $20 = 0, $22 = 0, $25 = 0, $26 = 0, $27 = 0, $3 = 0, $34 = 0, $35 = 0, $4 = 0, $6 = 0, $add = 0, $conv2$i = 0, $retval$0 = 0, $sub2$i20 = 0, $sub8$i = 0, sp = 0;
 sp = STACKTOP;
 $2 = _bitshift64Lshr($0 | 0, $1 | 0, 63) | 0;
 $3 = tempRet0;
 $4 = _bitshift64Lshr($0 | 0, $1 | 0, 52) | 0;
 $conv2$i = $4 & 2047;
 $6 = $1 & 1048575;
 do if (($conv2$i | 0) == 2047) {
  if (($0 | 0) == 0 & ($6 | 0) == 0) {
   $15 = _bitshift64Shl($2 | 0, $3 | 0, 31) | 0;
   $retval$0 = $15 | 2139095040;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if (!(0 == 0 & ($1 & 2146959360 | 0) == 2146435072)) {
   $retval$0 = 2143289344;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
  $retval$0 = 2143289344;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else if (!$conv2$i) {
  if (!(($0 | 0) == 0 & ($6 | 0) == 0)) {
   $22 = _llvm_ctlz_i64($0 | 0, $6 | 0, 0) | 0;
   $25 = $0;
   $26 = $6;
   $sub2$i20 = 12 - $22 | 0;
   break;
  }
  $20 = _bitshift64Shl($2 | 0, $3 | 0, 31) | 0;
  $retval$0 = $20;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else {
  $25 = $0;
  $26 = $6 | 1048576;
  $sub2$i20 = $conv2$i;
 } while (0);
 $add = $sub2$i20 + -896 | 0;
 $27 = _bitshift64Lshr($25 | 0, $26 | 0, 22) | 0;
 $34 = (($25 & 4194303 | 0) != 0 | 0 != 0) & 1 | $27;
 if (!$34) $sub8$i = 31; else {
  $35 = _llvm_ctlz_i32($34 | 0) | 0;
  if (!$35) ___assert_fail(1104, 1064, 183, 1168); else $sub8$i = $35 + -1 | 0;
 }
 $retval$0 = _roundpack_sf32($2, $add - $sub8$i | 0, $34 << $sub8$i, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _min_sf64($0, $1, $2, $3, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $pfflags = $pfflags | 0;
 var $11 = 0, $31 = 0, $39 = 0, $41 = 0, $52 = 0, $53 = 0, $or$cond54 = 0, $tobool21 = 0, $tobool27 = 0, sp = 0;
 sp = STACKTOP;
 $11 = ($0 | 0) != 0 | ($1 & 1048575 | 0) != 0;
 $or$cond54 = 0 == 0 & ($1 & 2146435072 | 0) == 2146435072 & $11;
 if (!$or$cond54) if (!(0 == 0 & ($3 & 2146435072 | 0) == 2146435072 & (($2 | 0) != 0 | ($3 & 1048575 | 0) != 0))) {
  $39 = _bitshift64Lshr($0 | 0, $1 | 0, 63) | 0;
  $41 = _bitshift64Lshr($2 | 0, $3 | 0, 63) | 0;
  if (($39 | 0) == ($41 | 0)) {
   $tobool27 = (($1 >>> 0 < $3 >>> 0 | ($1 | 0) == ($3 | 0) & $0 >>> 0 < $2 >>> 0) & 1 | 0) == ($39 | 0);
   $52 = $tobool27 ? $3 : $1;
   $53 = $tobool27 ? $2 : $0;
   tempRet0 = $52;
   STACKTOP = sp;
   return $53 | 0;
  } else {
   $tobool21 = ($39 | 0) == 0;
   $52 = $tobool21 ? $3 : $1;
   $53 = $tobool21 ? $2 : $0;
   tempRet0 = $52;
   STACKTOP = sp;
   return $53 | 0;
  }
 }
 if (!(0 == 0 & ($1 & 2146959360 | 0) == 2146435072 & $11)) {
  $31 = ($2 | 0) != 0 | ($3 & 1048575 | 0) != 0;
  if (!(0 == 0 & ($3 & 2146959360 | 0) == 2146435072 & $31)) {
   if (!$or$cond54) {
    $52 = $1;
    $53 = $0;
    tempRet0 = $52;
    STACKTOP = sp;
    return $53 | 0;
   }
   if (!(0 == 0 & ($3 & 2146435072 | 0) == 2146435072)) {
    $52 = $3;
    $53 = $2;
    tempRet0 = $52;
    STACKTOP = sp;
    return $53 | 0;
   }
   $52 = $31 ? 2146959360 : $3;
   $53 = $31 ? 0 : $2;
   tempRet0 = $52;
   STACKTOP = sp;
   return $53 | 0;
  }
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $52 = 2146959360;
 $53 = 0;
 tempRet0 = $52;
 STACKTOP = sp;
 return $53 | 0;
}
function _max_sf64($0, $1, $2, $3, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $pfflags = $pfflags | 0;
 var $11 = 0, $31 = 0, $39 = 0, $41 = 0, $52 = 0, $53 = 0, $or$cond54 = 0, $tobool21 = 0, $tobool27 = 0, sp = 0;
 sp = STACKTOP;
 $11 = ($0 | 0) != 0 | ($1 & 1048575 | 0) != 0;
 $or$cond54 = 0 == 0 & ($1 & 2146435072 | 0) == 2146435072 & $11;
 if (!$or$cond54) if (!(0 == 0 & ($3 & 2146435072 | 0) == 2146435072 & (($2 | 0) != 0 | ($3 & 1048575 | 0) != 0))) {
  $39 = _bitshift64Lshr($0 | 0, $1 | 0, 63) | 0;
  $41 = _bitshift64Lshr($2 | 0, $3 | 0, 63) | 0;
  if (($39 | 0) == ($41 | 0)) {
   $tobool27 = (($1 >>> 0 < $3 >>> 0 | ($1 | 0) == ($3 | 0) & $0 >>> 0 < $2 >>> 0) & 1 | 0) == ($39 | 0);
   $52 = $tobool27 ? $1 : $3;
   $53 = $tobool27 ? $0 : $2;
   tempRet0 = $52;
   STACKTOP = sp;
   return $53 | 0;
  } else {
   $tobool21 = ($39 | 0) == 0;
   $52 = $tobool21 ? $1 : $3;
   $53 = $tobool21 ? $0 : $2;
   tempRet0 = $52;
   STACKTOP = sp;
   return $53 | 0;
  }
 }
 if (!(0 == 0 & ($1 & 2146959360 | 0) == 2146435072 & $11)) {
  $31 = ($2 | 0) != 0 | ($3 & 1048575 | 0) != 0;
  if (!(0 == 0 & ($3 & 2146959360 | 0) == 2146435072 & $31)) {
   if (!$or$cond54) {
    $52 = $1;
    $53 = $0;
    tempRet0 = $52;
    STACKTOP = sp;
    return $53 | 0;
   }
   if (!(0 == 0 & ($3 & 2146435072 | 0) == 2146435072)) {
    $52 = $3;
    $53 = $2;
    tempRet0 = $52;
    STACKTOP = sp;
    return $53 | 0;
   }
   $52 = $31 ? 2146959360 : $3;
   $53 = $31 ? 0 : $2;
   tempRet0 = $52;
   STACKTOP = sp;
   return $53 | 0;
  }
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $52 = 2146959360;
 $53 = 0;
 tempRet0 = $52;
 STACKTOP = sp;
 return $53 | 0;
}
function _cvt_i64_sf32($0, $1, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $12 = 0, $14 = 0, $16 = 0, $19 = 0, $2 = 0, $20 = 0, $27 = 0, $3 = 0, $5 = 0, $6 = 0, $7 = 0, $a_exp$0$i = 0, $call2$i$i = 0, $r$0$i$i = 0, $r$1$off0$i = 0, $shl$i$i = 0, $sub1$i = 0, $sub1$i$i = 0, $sub2$i = 0, $sub8$i$i = 0, sp = 0;
 sp = STACKTOP;
 $2 = ($1 | 0) < 0;
 $3 = _i64Subtract(0, 0, $0 | 0, $1 | 0) | 0;
 $5 = $2 ? $3 : $0;
 $6 = $2 ? tempRet0 : $1;
 $7 = _bitshift64Lshr($0 | 0, $1 | 0, 63) | 0;
 if (($5 | 0) == 0 & ($6 | 0) == 0) $r$0$i$i = 64; else {
  $12 = _llvm_ctlz_i64($5 | 0, $6 | 0, 0) | 0;
  $r$0$i$i = $12;
 }
 $sub1$i = 64 - $r$0$i$i | 0;
 $sub2$i = $sub1$i + -31 | 0;
 if (($sub2$i | 0) > 0) {
  $14 = _bitshift64Shl(1, 0, $sub2$i | 0) | 0;
  $16 = _i64Add($14 | 0, tempRet0 | 0, -1, -1) | 0;
  $19 = tempRet0 & $6;
  $20 = _bitshift64Lshr($5 | 0, $6 | 0, $sub2$i | 0) | 0;
  $a_exp$0$i = $sub1$i + 126 | 0;
  $r$1$off0$i = (($16 & $5 | 0) != 0 | ($19 | 0) != 0) & 1 | $20;
 } else {
  $a_exp$0$i = 157;
  $r$1$off0$i = $5;
 }
 if (!$r$1$off0$i) {
  $sub8$i$i = 31;
  $sub1$i$i = $a_exp$0$i - $sub8$i$i | 0;
  $shl$i$i = $r$1$off0$i << $sub8$i$i;
  $call2$i$i = _roundpack_sf32($7, $sub1$i$i, $shl$i$i, $rm, $pfflags) | 0;
  STACKTOP = sp;
  return $call2$i$i | 0;
 }
 $27 = _llvm_ctlz_i32($r$1$off0$i | 0) | 0;
 if (!$27) ___assert_fail(1104, 1064, 183, 1168); else {
  $sub8$i$i = $27 + -1 | 0;
  $sub1$i$i = $a_exp$0$i - $sub8$i$i | 0;
  $shl$i$i = $r$1$off0$i << $sub8$i$i;
  $call2$i$i = _roundpack_sf32($7, $sub1$i$i, $shl$i$i, $rm, $pfflags) | 0;
  STACKTOP = sp;
  return $call2$i$i | 0;
 }
 return 0;
}
function _MUSL_vfprintf($f, $fmt, $ap) {
 $f = $f | 0;
 $fmt = $fmt | 0;
 $ap = $ap | 0;
 var $$call13 = 0, $1 = 0, $ap2 = 0, $buf = 0, $buf_size = 0, $call13 = 0, $internal_buf = 0, $nl_arg = 0, $nl_type = 0, $ret$1 = 0, $retval$0 = 0, $wbase = 0, $wend = 0, $wpos = 0, dest = 0, sp = 0, stop = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 224 | 0;
 $ap2 = sp + 120 | 0;
 $nl_type = sp + 80 | 0;
 $nl_arg = sp;
 $internal_buf = sp + 136 | 0;
 dest = $nl_type + 0 | 0;
 stop = dest + 40 | 0;
 do {
  HEAP32[dest >> 2] = 0;
  dest = dest + 4 | 0;
 } while ((dest | 0) < (stop | 0));
 HEAP32[$ap2 >> 2] = HEAP32[$ap >> 2];
 if ((_printf_core(0, $fmt, $ap2, $nl_arg, $nl_type) | 0) < 0) {
  $retval$0 = -1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 $buf_size = $f + 48 | 0;
 if (!(HEAP32[$buf_size >> 2] | 0)) {
  $buf = $f + 44 | 0;
  $1 = HEAP32[$buf >> 2] | 0;
  HEAP32[$buf >> 2] = $internal_buf;
  $wbase = $f + 28 | 0;
  HEAP32[$wbase >> 2] = $internal_buf;
  $wpos = $f + 20 | 0;
  HEAP32[$wpos >> 2] = $internal_buf;
  HEAP32[$buf_size >> 2] = 80;
  $wend = $f + 16 | 0;
  HEAP32[$wend >> 2] = $internal_buf + 80;
  $call13 = _printf_core($f, $fmt, $ap2, $nl_arg, $nl_type) | 0;
  if (!$1) $ret$1 = $call13; else {
   FUNCTION_TABLE_iiii[HEAP32[$f + 36 >> 2] & 3]($f, 0, 0) | 0;
   $$call13 = (HEAP32[$wpos >> 2] | 0) == 0 ? -1 : $call13;
   HEAP32[$buf >> 2] = $1;
   HEAP32[$buf_size >> 2] = 0;
   HEAP32[$wend >> 2] = 0;
   HEAP32[$wbase >> 2] = 0;
   HEAP32[$wpos >> 2] = 0;
   $ret$1 = $$call13;
  }
 } else $ret$1 = _printf_core($f, $fmt, $ap2, $nl_arg, $nl_type) | 0;
 $retval$0 = $ret$1;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _ide_sector_read($s) {
 $s = $s | 0;
 var $$$conv = 0, $$conv = 0, $11 = 0, $12 = 0, $13 = 0, $15 = 0, $add$i = 0, $conv$i = 0, $mul$i = 0, $s$idx$val = 0, $sector_num$0$in$i = 0, sp = 0;
 sp = STACKTOP;
 $conv$i = HEAPU8[$s + 39 >> 0] | 0;
 if (!($conv$i & 64)) {
  $mul$i = Math_imul((HEAPU8[$s + 38 >> 0] | 0) << 8 | (HEAPU8[$s + 37 >> 0] | 0), HEAP32[$s + 12 >> 2] | 0) | 0;
  $add$i = Math_imul($mul$i + ($conv$i & 15) | 0, HEAP32[$s + 16 >> 2] | 0) | 0;
  $sector_num$0$in$i = (HEAPU8[$s + 36 >> 0] | 0) + -1 + $add$i | 0;
 } else $sector_num$0$in$i = (HEAPU8[$s + 38 >> 0] | 0) << 16 | $conv$i << 24 & 251658240 | (HEAPU8[$s + 37 >> 0] | 0) << 8 | (HEAPU8[$s + 36 >> 0] | 0);
 $11 = HEAP16[$s + 34 >> 1] | 0;
 $$conv = $11 << 16 >> 16 == 0 ? 256 : $11 & 65535;
 $12 = HEAP32[$s + 48 >> 2] | 0;
 $$$conv = ($$conv | 0) > ($12 | 0) ? $12 : $$conv;
 HEAP32[$s + 44 >> 2] = $$$conv;
 $13 = HEAP32[$s + 4 >> 2] | 0;
 $15 = FUNCTION_TABLE_iiiiiiii[HEAP32[$13 + 4 >> 2] & 3]($13, $sector_num$0$in$i, (($sector_num$0$in$i | 0) < 0) << 31 >> 31, $s + 64 | 0, $$$conv, 7, $s) | 0;
 if (($15 | 0) < 0) {
  HEAP8[$s + 40 >> 0] = 65;
  HEAP8[$s + 33 >> 0] = 4;
  $s$idx$val = HEAP32[$s >> 2] | 0;
  if (HEAP8[$s$idx$val + 20 >> 0] & 2) {
   STACKTOP = sp;
   return;
  }
  FUNCTION_TABLE_vii[HEAP32[$s$idx$val + 4 >> 2] & 1](HEAP32[$s$idx$val >> 2] | 0, 1);
  STACKTOP = sp;
  return;
 }
 if (!$15) {
  _ide_sector_read_cb($s);
  STACKTOP = sp;
  return;
 } else {
  HEAP8[$s + 40 >> 0] = -48;
  HEAP8[$s + 33 >> 0] = 0;
  STACKTOP = sp;
  return;
 }
}
function ___fwritex($s, $l, $f) {
 $s = $s | 0;
 $l = $l | 0;
 $f = $f | 0;
 var $0 = 0, $1 = 0, $2 = 0, $7 = 0, $i$0 = 0, $i$1 = 0, $l$addr$0 = 0, $retval$0 = 0, $s$addr$0 = 0, $sub = 0, $wend = 0, $wpos = 0, sp = 0;
 sp = STACKTOP;
 $wend = $f + 16 | 0;
 $0 = HEAP32[$wend >> 2] | 0;
 do if (!$0) if (!(___towrite($f) | 0)) {
  $2 = HEAP32[$wend >> 2] | 0;
  break;
 } else {
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else $2 = $0; while (0);
 $wpos = $f + 20 | 0;
 $1 = HEAP32[$wpos >> 2] | 0;
 if (($2 - $1 | 0) >>> 0 < $l >>> 0) {
  $retval$0 = FUNCTION_TABLE_iiii[HEAP32[$f + 36 >> 2] & 3]($f, $s, $l) | 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 L11 : do if ((HEAP8[$f + 75 >> 0] | 0) > -1) {
  $i$0 = $l;
  while (1) {
   if (!$i$0) {
    $7 = $1;
    $i$1 = 0;
    $l$addr$0 = $l;
    $s$addr$0 = $s;
    break L11;
   }
   $sub = $i$0 + -1 | 0;
   if ((HEAP8[$s + $sub >> 0] | 0) == 10) break; else $i$0 = $sub;
  }
  if ((FUNCTION_TABLE_iiii[HEAP32[$f + 36 >> 2] & 3]($f, $s, $i$0) | 0) >>> 0 < $i$0 >>> 0) {
   $retval$0 = $i$0;
   STACKTOP = sp;
   return $retval$0 | 0;
  } else {
   $7 = HEAP32[$wpos >> 2] | 0;
   $i$1 = $i$0;
   $l$addr$0 = $l - $i$0 | 0;
   $s$addr$0 = $s + $i$0 | 0;
   break;
  }
 } else {
  $7 = $1;
  $i$1 = 0;
  $l$addr$0 = $l;
  $s$addr$0 = $s;
 } while (0);
 _memcpy($7 | 0, $s$addr$0 | 0, $l$addr$0 | 0) | 0;
 HEAP32[$wpos >> 2] = (HEAP32[$wpos >> 2] | 0) + $l$addr$0;
 $retval$0 = $i$1 + $l$addr$0 | 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _plic_write($opaque, $0, $1, $2, $3, $size_log2) {
 $opaque = $opaque | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $size_log2 = $size_log2 | 0;
 var $$idx$val = 0, $14 = 0, $15 = 0, $17 = 0, $20 = 0, $23 = 0, $24 = 0, $25 = 0, $30 = 0, $7 = 0, $8 = 0, $mip$i = 0, $plic_served_irq = 0, $power_down_flag$i = 0, $shl = 0, $tobool$i = 0, sp = 0;
 sp = STACKTOP;
 if (($size_log2 | 0) != 2) ___assert_fail(840, 56, 1883, 928);
 if (!(($0 | 0) == 4 & ($1 | 0) == 0)) {
  STACKTOP = sp;
  return;
 }
 $7 = _i64Add($2 | 0, $3 | 0, -1, -1) | 0;
 $8 = tempRet0;
 if (!($8 >>> 0 < 0 | ($8 | 0) == 0 & $7 >>> 0 < 32)) {
  STACKTOP = sp;
  return;
 }
 $shl = 1 << $7;
 $plic_served_irq = $opaque + 36 | 0;
 $14 = HEAP32[$plic_served_irq >> 2] | 0;
 HEAP32[$plic_served_irq >> 2] = $14 & ~$shl;
 $$idx$val = HEAP32[$opaque >> 2] | 0;
 $tobool$i = (HEAP32[$opaque + 32 >> 2] & ($shl | ~$14) | 0) == 0;
 $mip$i = $$idx$val + 608 | 0;
 $15 = $mip$i;
 $17 = HEAP32[$15 >> 2] | 0;
 $20 = HEAP32[$15 + 4 >> 2] | 0;
 $23 = $tobool$i ? $17 & -2561 : $17 | 2560;
 $24 = $tobool$i ? $20 : $20;
 $25 = $mip$i;
 HEAP32[$25 >> 2] = $23;
 HEAP32[$25 + 4 >> 2] = $24;
 $power_down_flag$i = $$idx$val + 544 | 0;
 if (!(HEAP32[$power_down_flag$i >> 2] | 0)) {
  STACKTOP = sp;
  return;
 }
 $30 = $$idx$val + 560 | 0;
 if ((HEAP32[$30 >> 2] & $23 | 0) == 0 ? (HEAP32[$30 + 4 >> 2] & $24 | 0) == 0 : 0) {
  STACKTOP = sp;
  return;
 }
 HEAP32[$power_down_flag$i >> 2] = 0;
 STACKTOP = sp;
 return;
}
function _vsnprintf($s, $n, $fmt, $ap) {
 $s = $s | 0;
 $n = $n | 0;
 $fmt = $fmt | 0;
 $ap = $ap | 0;
 var $0 = 0, $add$ptr = 0, $b = 0, $call10 = 0, $f = 0, $n$addr$0 = 0, $retval$0 = 0, $s$addr$0 = 0, $sub3 = 0, $sub3$n$addr$0 = 0, $wend = 0, $wpos = 0, dest = 0, sp = 0, src = 0, stop = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 128 | 0;
 $b = sp + 112 | 0;
 $f = sp;
 dest = $f + 0 | 0;
 src = 2272 | 0;
 stop = dest + 112 | 0;
 do {
  HEAP32[dest >> 2] = HEAP32[src >> 2];
  dest = dest + 4 | 0;
  src = src + 4 | 0;
 } while ((dest | 0) < (stop | 0));
 if (($n + -1 | 0) >>> 0 > 2147483646) if (!$n) {
  $n$addr$0 = 1;
  $s$addr$0 = $b;
 } else {
  HEAP32[(___errno_location() | 0) >> 2] = 75;
  $retval$0 = -1;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else {
  $n$addr$0 = $n;
  $s$addr$0 = $s;
 }
 $sub3 = -2 - $s$addr$0 | 0;
 $sub3$n$addr$0 = $n$addr$0 >>> 0 > $sub3 >>> 0 ? $sub3 : $n$addr$0;
 HEAP32[$f + 48 >> 2] = $sub3$n$addr$0;
 $wpos = $f + 20 | 0;
 HEAP32[$wpos >> 2] = $s$addr$0;
 HEAP32[$f + 44 >> 2] = $s$addr$0;
 $add$ptr = $s$addr$0 + $sub3$n$addr$0 | 0;
 $wend = $f + 16 | 0;
 HEAP32[$wend >> 2] = $add$ptr;
 HEAP32[$f + 28 >> 2] = $add$ptr;
 $call10 = _MUSL_vfprintf($f, $fmt, $ap) | 0;
 if (!$sub3$n$addr$0) {
  $retval$0 = $call10;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 $0 = HEAP32[$wpos >> 2] | 0;
 HEAP8[$0 + ((($0 | 0) == (HEAP32[$wend >> 2] | 0)) << 31 >> 31) >> 0] = 0;
 $retval$0 = $call10;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _cvt_i64_sf64($0, $1, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $12 = 0, $14 = 0, $16 = 0, $19 = 0, $2 = 0, $20 = 0, $27 = 0, $29 = 0, $3 = 0, $32 = 0, $34 = 0, $36 = 0, $5 = 0, $6 = 0, $7 = 0, $a_exp$0$i = 0, $r$0$i$i = 0, $sub1$i = 0, $sub2$i = 0, $sub8$i$i = 0, sp = 0;
 sp = STACKTOP;
 $2 = ($1 | 0) < 0;
 $3 = _i64Subtract(0, 0, $0 | 0, $1 | 0) | 0;
 $5 = $2 ? $3 : $0;
 $6 = $2 ? tempRet0 : $1;
 $7 = _bitshift64Lshr($0 | 0, $1 | 0, 63) | 0;
 if (($5 | 0) == 0 & ($6 | 0) == 0) $r$0$i$i = 64; else {
  $12 = _llvm_ctlz_i64($5 | 0, $6 | 0, 0) | 0;
  $r$0$i$i = $12;
 }
 $sub1$i = 64 - $r$0$i$i | 0;
 $sub2$i = $sub1$i + -63 | 0;
 if (($sub2$i | 0) > 0) {
  $14 = _bitshift64Shl(1, 0, $sub2$i | 0) | 0;
  $16 = _i64Add($14 | 0, tempRet0 | 0, -1, -1) | 0;
  $19 = tempRet0 & $6;
  $20 = _bitshift64Lshr($5 | 0, $6 | 0, $sub2$i | 0) | 0;
  $27 = (($16 & $5 | 0) != 0 | ($19 | 0) != 0) & 1 | $20;
  $29 = tempRet0;
  $a_exp$0$i = $sub1$i + 1022 | 0;
 } else {
  $27 = $5;
  $29 = $6;
  $a_exp$0$i = 1085;
 }
 if (($27 | 0) == 0 & ($29 | 0) == 0) $sub8$i$i = 63; else {
  $32 = _llvm_ctlz_i64($27 | 0, $29 | 0, 0) | 0;
  if (!$32) ___assert_fail(1104, 1064, 183, 1136); else $sub8$i$i = $32 + -1 | 0;
 }
 $34 = _bitshift64Shl($27 | 0, $29 | 0, $sub8$i$i | 0) | 0;
 $36 = _roundpack_sf64($7, $a_exp$0$i - $sub8$i$i | 0, $34, tempRet0, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $36 | 0;
}
function _ide_sector_write_cb1($s) {
 $s = $s | 0;
 var $11 = 0, $14 = 0, $add$i = 0, $conv$i = 0, $mul$i = 0, $s$idx$val = 0, $sector_num$0$in$i = 0, sp = 0;
 sp = STACKTOP;
 HEAP32[$s + 52 >> 2] = 6;
 HEAP32[$s + 56 >> 2] = 0;
 HEAP32[$s + 60 >> 2] = 0;
 $conv$i = HEAPU8[$s + 39 >> 0] | 0;
 if (!($conv$i & 64)) {
  $mul$i = Math_imul((HEAPU8[$s + 38 >> 0] | 0) << 8 | (HEAPU8[$s + 37 >> 0] | 0), HEAP32[$s + 12 >> 2] | 0) | 0;
  $add$i = Math_imul($mul$i + ($conv$i & 15) | 0, HEAP32[$s + 16 >> 2] | 0) | 0;
  $sector_num$0$in$i = (HEAPU8[$s + 36 >> 0] | 0) + -1 + $add$i | 0;
 } else $sector_num$0$in$i = (HEAPU8[$s + 38 >> 0] | 0) << 16 | $conv$i << 24 & 251658240 | (HEAPU8[$s + 37 >> 0] | 0) << 8 | (HEAPU8[$s + 36 >> 0] | 0);
 $11 = HEAP32[$s + 4 >> 2] | 0;
 $14 = FUNCTION_TABLE_iiiiiiii[HEAP32[$11 + 8 >> 2] & 3]($11, $sector_num$0$in$i, (($sector_num$0$in$i | 0) < 0) << 31 >> 31, $s + 64 | 0, HEAP32[$s + 44 >> 2] | 0, 8, $s) | 0;
 if (($14 | 0) < 0) {
  HEAP8[$s + 40 >> 0] = 65;
  HEAP8[$s + 33 >> 0] = 4;
  $s$idx$val = HEAP32[$s >> 2] | 0;
  if (HEAP8[$s$idx$val + 20 >> 0] & 2) {
   STACKTOP = sp;
   return;
  }
  FUNCTION_TABLE_vii[HEAP32[$s$idx$val + 4 >> 2] & 1](HEAP32[$s$idx$val >> 2] | 0, 1);
  STACKTOP = sp;
  return;
 }
 if (!$14) {
  _ide_sector_write_cb2($s);
  STACKTOP = sp;
  return;
 } else {
  HEAP8[$s + 40 >> 0] = -48;
  STACKTOP = sp;
  return;
 }
}
function _cvt_sf32_sf64($a, $pfflags) {
 $a = $a | 0;
 $pfflags = $pfflags | 0;
 var $1 = 0, $10 = 0, $11 = 0, $19 = 0, $20 = 0, $4 = 0, $6 = 0, $7 = 0, $8 = 0, $9 = 0, $a_mant$0$in = 0, $and$i = 0, $and2$i = 0, $shr$i = 0, $sub2$i17 = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $shr$i = $a >>> 31;
 $and$i = $a >>> 23 & 255;
 $and2$i = $a & 8388607;
 do if (($and$i | 0) == 255) {
  if (!$and2$i) {
   $1 = _bitshift64Shl($shr$i | 0, 0, 63) | 0;
   $19 = tempRet0 | 2146435072;
   $20 = $1;
   break;
  }
  if (($a & 2143289344 | 0) == 2139095040) {
   HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
   $19 = 2146959360;
   $20 = 0;
  } else {
   $19 = 2146959360;
   $20 = 0;
  }
 } else if (!$and$i) if (!$and2$i) {
  $4 = _bitshift64Shl($shr$i | 0, 0, 63) | 0;
  $19 = tempRet0;
  $20 = $4;
  break;
 } else {
  $6 = _llvm_ctlz_i32($and2$i | 0) | 0;
  $a_mant$0$in = $and2$i << $6 + -8;
  $sub2$i17 = 9 - $6 | 0;
  label = 9;
  break;
 } else {
  $a_mant$0$in = $and2$i;
  $sub2$i17 = $and$i;
  label = 9;
 } while (0);
 if ((label | 0) == 9) {
  $7 = _bitshift64Shl($a_mant$0$in | 0, 0, 29) | 0;
  $8 = tempRet0;
  $9 = _bitshift64Shl($shr$i | 0, 0, 63) | 0;
  $10 = tempRet0;
  $11 = _bitshift64Shl($sub2$i17 + 896 | 0, 0, 52) | 0;
  $19 = tempRet0 | $10 | $8 & 1048575;
  $20 = $11 | $9 | $7 & -536870912;
 }
 tempRet0 = $19;
 STACKTOP = sp;
 return $20 | 0;
}
function _cvt_u64_sf64($0, $1, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $12 = 0, $13 = 0, $20 = 0, $22 = 0, $25 = 0, $27 = 0, $29 = 0, $5 = 0, $7 = 0, $9 = 0, $a_exp$0$i = 0, $r$0$i$i = 0, $sub1$i = 0, $sub2$i = 0, $sub8$i$i = 0, sp = 0;
 sp = STACKTOP;
 if (($0 | 0) == 0 & ($1 | 0) == 0) $r$0$i$i = 64; else {
  $5 = _llvm_ctlz_i64($0 | 0, $1 | 0, 0) | 0;
  $r$0$i$i = $5;
 }
 $sub1$i = 64 - $r$0$i$i | 0;
 $sub2$i = $sub1$i + -63 | 0;
 if (($sub2$i | 0) > 0) {
  $7 = _bitshift64Shl(1, 0, $sub2$i | 0) | 0;
  $9 = _i64Add($7 | 0, tempRet0 | 0, -1, -1) | 0;
  $12 = tempRet0 & $1;
  $13 = _bitshift64Lshr($0 | 0, $1 | 0, $sub2$i | 0) | 0;
  $20 = (($9 & $0 | 0) != 0 | ($12 | 0) != 0) & 1 | $13;
  $22 = tempRet0;
  $a_exp$0$i = $sub1$i + 1022 | 0;
 } else {
  $20 = $0;
  $22 = $1;
  $a_exp$0$i = 1085;
 }
 if (($20 | 0) == 0 & ($22 | 0) == 0) $sub8$i$i = 63; else {
  $25 = _llvm_ctlz_i64($20 | 0, $22 | 0, 0) | 0;
  if (!$25) ___assert_fail(1104, 1064, 183, 1136); else $sub8$i$i = $25 + -1 | 0;
 }
 $27 = _bitshift64Shl($20 | 0, $22 | 0, $sub8$i$i | 0) | 0;
 $29 = _roundpack_sf64(0, $a_exp$0$i - $sub8$i$i | 0, $27, tempRet0, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $29 | 0;
}
function _min_sf32($a, $b, $pfflags) {
 $a = $a | 0;
 $b = $b | 0;
 $pfflags = $pfflags | 0;
 var $cmp2$i = 0, $cmp2$i35 = 0, $or$cond54 = 0, $retval$0 = 0, $shr = 0, sp = 0;
 sp = STACKTOP;
 $cmp2$i = ($a & 8388607 | 0) != 0;
 $or$cond54 = ($a & 2139095040 | 0) == 2139095040 & $cmp2$i;
 if (!$or$cond54) if (!(($b & 2139095040 | 0) == 2139095040 & ($b & 8388607 | 0) != 0)) {
  $shr = $a >>> 31;
  if (($shr | 0) == ($b >>> 31 | 0)) {
   $retval$0 = ($a >>> 0 < $b >>> 0 | 0) == ($shr | 0) ? $b : $a;
   STACKTOP = sp;
   return $retval$0 | 0;
  } else {
   $retval$0 = ($shr | 0) == 0 ? $b : $a;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 }
 if (!(($a & 2143289344 | 0) == 2139095040 & $cmp2$i)) {
  $cmp2$i35 = ($b & 8388607 | 0) != 0;
  if (!(($b & 2143289344 | 0) == 2139095040 & $cmp2$i35)) {
   if (!$or$cond54) {
    $retval$0 = $a;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
   if (($b & 2139095040 | 0) != 2139095040) {
    $retval$0 = $b;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
   $retval$0 = $cmp2$i35 ? 2143289344 : $b;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $retval$0 = 2143289344;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _max_sf32($a, $b, $pfflags) {
 $a = $a | 0;
 $b = $b | 0;
 $pfflags = $pfflags | 0;
 var $cmp2$i = 0, $cmp2$i35 = 0, $or$cond54 = 0, $retval$0 = 0, $shr = 0, sp = 0;
 sp = STACKTOP;
 $cmp2$i = ($a & 8388607 | 0) != 0;
 $or$cond54 = ($a & 2139095040 | 0) == 2139095040 & $cmp2$i;
 if (!$or$cond54) if (!(($b & 2139095040 | 0) == 2139095040 & ($b & 8388607 | 0) != 0)) {
  $shr = $a >>> 31;
  if (($shr | 0) == ($b >>> 31 | 0)) {
   $retval$0 = ($a >>> 0 < $b >>> 0 | 0) == ($shr | 0) ? $a : $b;
   STACKTOP = sp;
   return $retval$0 | 0;
  } else {
   $retval$0 = ($shr | 0) == 0 ? $a : $b;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 }
 if (!(($a & 2143289344 | 0) == 2139095040 & $cmp2$i)) {
  $cmp2$i35 = ($b & 8388607 | 0) != 0;
  if (!(($b & 2143289344 | 0) == 2139095040 & $cmp2$i35)) {
   if (!$or$cond54) {
    $retval$0 = $a;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
   if (($b & 2139095040 | 0) != 2139095040) {
    $retval$0 = $b;
    STACKTOP = sp;
    return $retval$0 | 0;
   }
   $retval$0 = $cmp2$i35 ? 2143289344 : $b;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $retval$0 = 2143289344;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _ide_set_irq($opaque, $state) {
 $opaque = $opaque | 0;
 $state = $state | 0;
 var $0 = 0, $1 = 0, $10 = 0, $11 = 0, $16 = 0, $3 = 0, $6 = 0, $9 = 0, $mip$i$i = 0, $plic_pending_irq1$i = 0, $power_down_flag$i$i = 0, $s$idx$val$i = 0, $storemerge$i = 0, $tobool$i$i = 0, sp = 0;
 sp = STACKTOP;
 $plic_pending_irq1$i = $opaque + 32 | 0;
 $0 = HEAP32[$plic_pending_irq1$i >> 2] | 0;
 $storemerge$i = ($state | 0) == 0 ? $0 & -3 : $0 | 2;
 HEAP32[$plic_pending_irq1$i >> 2] = $storemerge$i;
 $s$idx$val$i = HEAP32[$opaque >> 2] | 0;
 $tobool$i$i = ($storemerge$i & ~HEAP32[$opaque + 36 >> 2] | 0) == 0;
 $mip$i$i = $s$idx$val$i + 608 | 0;
 $1 = $mip$i$i;
 $3 = HEAP32[$1 >> 2] | 0;
 $6 = HEAP32[$1 + 4 >> 2] | 0;
 $9 = $tobool$i$i ? $3 & -2561 : $3 | 2560;
 $10 = $tobool$i$i ? $6 : $6;
 $11 = $mip$i$i;
 HEAP32[$11 >> 2] = $9;
 HEAP32[$11 + 4 >> 2] = $10;
 $power_down_flag$i$i = $s$idx$val$i + 544 | 0;
 if (!(HEAP32[$power_down_flag$i$i >> 2] | 0)) {
  STACKTOP = sp;
  return;
 }
 $16 = $s$idx$val$i + 560 | 0;
 if ((HEAP32[$16 >> 2] & $9 | 0) == 0 ? (HEAP32[$16 + 4 >> 2] & $10 | 0) == 0 : 0) {
  STACKTOP = sp;
  return;
 }
 HEAP32[$power_down_flag$i$i >> 2] = 0;
 STACKTOP = sp;
 return;
}
function _cvt_u64_sf32($0, $1, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $12 = 0, $13 = 0, $20 = 0, $5 = 0, $7 = 0, $9 = 0, $a_exp$0$i = 0, $call2$i$i = 0, $r$0$i$i = 0, $r$1$off0$i = 0, $sub1$i = 0, $sub2$i = 0, $sub8$i$i = 0, sp = 0;
 sp = STACKTOP;
 if (($0 | 0) == 0 & ($1 | 0) == 0) $r$0$i$i = 64; else {
  $5 = _llvm_ctlz_i64($0 | 0, $1 | 0, 0) | 0;
  $r$0$i$i = $5;
 }
 $sub1$i = 64 - $r$0$i$i | 0;
 $sub2$i = $sub1$i + -31 | 0;
 if (($sub2$i | 0) > 0) {
  $7 = _bitshift64Shl(1, 0, $sub2$i | 0) | 0;
  $9 = _i64Add($7 | 0, tempRet0 | 0, -1, -1) | 0;
  $12 = tempRet0 & $1;
  $13 = _bitshift64Lshr($0 | 0, $1 | 0, $sub2$i | 0) | 0;
  $a_exp$0$i = $sub1$i + 126 | 0;
  $r$1$off0$i = (($9 & $0 | 0) != 0 | ($12 | 0) != 0) & 1 | $13;
 } else {
  $a_exp$0$i = 157;
  $r$1$off0$i = $0;
 }
 if (!$r$1$off0$i) $sub8$i$i = 31; else {
  $20 = _llvm_ctlz_i32($r$1$off0$i | 0) | 0;
  if (!$20) ___assert_fail(1104, 1064, 183, 1168); else $sub8$i$i = $20 + -1 | 0;
 }
 $call2$i$i = _roundpack_sf32(0, $a_exp$0$i - $sub8$i$i | 0, $r$1$off0$i << $sub8$i$i, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $call2$i$i | 0;
}
function _rtc_write($opaque, $0, $1, $2, $3, $size_log2) {
 $opaque = $opaque | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $size_log2 = $size_log2 | 0;
 var $13 = 0, $15 = 0, $25 = 0, $29 = 0, $34 = 0, $36 = 0, $4 = 0, $8 = 0, $mip = 0, $mip8 = 0, $timecmp4 = 0, sp = 0;
 sp = STACKTOP;
 if (($size_log2 | 0) != 2) ___assert_fail(840, 56, 1821, 960);
 if (($0 | 0) == 12) {
  if ($1) {
   STACKTOP = sp;
   return;
  }
  $timecmp4 = $opaque + 536 | 0;
  $25 = $timecmp4;
  HEAP32[$25 >> 2] = HEAP32[$timecmp4 >> 2];
  HEAP32[$25 + 4 >> 2] = $2;
  $mip8 = $opaque + 608 | 0;
  $29 = $mip8;
  $34 = HEAP32[$29 + 4 >> 2] | 0;
  $36 = $mip8;
  HEAP32[$36 >> 2] = HEAP32[$29 >> 2] & -129;
  HEAP32[$36 + 4 >> 2] = $34;
  STACKTOP = sp;
  return;
 } else if (($0 | 0) == 8) {
  if ($1) {
   STACKTOP = sp;
   return;
  }
  $4 = $opaque + 536 | 0;
  HEAP32[$4 >> 2] = $2;
  HEAP32[$4 + 4 >> 2] = $3;
  $mip = $opaque + 608 | 0;
  $8 = $mip;
  $13 = HEAP32[$8 + 4 >> 2] | 0;
  $15 = $mip;
  HEAP32[$15 >> 2] = HEAP32[$8 >> 2] & -129;
  HEAP32[$15 + 4 >> 2] = $13;
  STACKTOP = sp;
  return;
 } else {
  STACKTOP = sp;
  return;
 }
}
function _le_sf64($0, $1, $2, $3, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $pfflags = $pfflags | 0;
 var $21 = 0, $23 = 0, $31 = 0, $retval$0 = 0, $tobool7 = 0, sp = 0;
 sp = STACKTOP;
 if (!(0 == 0 & ($1 & 2146435072 | 0) == 2146435072 & (($0 | 0) != 0 | ($1 & 1048575 | 0) != 0))) if (!(0 == 0 & ($3 & 2146435072 | 0) == 2146435072 & (($2 | 0) != 0 | ($3 & 1048575 | 0) != 0))) {
  $21 = _bitshift64Lshr($0 | 0, $1 | 0, 63) | 0;
  $23 = _bitshift64Lshr($2 | 0, $3 | 0, 63) | 0;
  $tobool7 = ($21 | 0) != 0;
  if (($21 | 0) != ($23 | 0)) {
   if ($tobool7) $31 = 1; else $31 = ($2 | $0 | 0) == 0 & (($3 | $1) & 2147483647 | 0) == 0;
   $retval$0 = $31 & 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if ($tobool7) {
   $retval$0 = ($1 >>> 0 > $3 >>> 0 | ($1 | 0) == ($3 | 0) & $0 >>> 0 >= $2 >>> 0) & 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  } else {
   $retval$0 = ($1 >>> 0 < $3 >>> 0 | ($1 | 0) == ($3 | 0) & $0 >>> 0 <= $2 >>> 0) & 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $retval$0 = 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _lt_sf64($0, $1, $2, $3, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $pfflags = $pfflags | 0;
 var $21 = 0, $23 = 0, $31 = 0, $retval$0 = 0, $tobool7 = 0, sp = 0;
 sp = STACKTOP;
 if (!(0 == 0 & ($1 & 2146435072 | 0) == 2146435072 & (($0 | 0) != 0 | ($1 & 1048575 | 0) != 0))) if (!(0 == 0 & ($3 & 2146435072 | 0) == 2146435072 & (($2 | 0) != 0 | ($3 & 1048575 | 0) != 0))) {
  $21 = _bitshift64Lshr($0 | 0, $1 | 0, 63) | 0;
  $23 = _bitshift64Lshr($2 | 0, $3 | 0, 63) | 0;
  $tobool7 = ($21 | 0) != 0;
  if (($21 | 0) != ($23 | 0)) {
   if ($tobool7) $31 = ($2 | $0 | 0) != 0 | (($3 | $1) & 2147483647 | 0) != 0; else $31 = 0;
   $retval$0 = $31 & 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if ($tobool7) {
   $retval$0 = ($1 >>> 0 > $3 >>> 0 | ($1 | 0) == ($3 | 0) & $0 >>> 0 > $2 >>> 0) & 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  } else {
   $retval$0 = ($1 >>> 0 < $3 >>> 0 | ($1 | 0) == ($3 | 0) & $0 >>> 0 < $2 >>> 0) & 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $retval$0 = 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _riscv_cpu_interp($s) {
 $s = $s | 0;
 var $0 = 0, $10 = 0, $11 = 0, $15 = 0, $2 = 0, $5 = 0, $6 = 0, $7 = 0, $9 = 0, $conv7 = 0, $cur_xlen = 0, $insn_counter = 0, $power_down_flag = 0, label = 0, sp = 0;
 sp = STACKTOP;
 $insn_counter = $s + 528 | 0;
 $0 = $insn_counter;
 $2 = HEAP32[$0 >> 2] | 0;
 $5 = HEAP32[$0 + 4 >> 2] | 0;
 $6 = _i64Add($2 | 0, $5 | 0, 1e6, 0) | 0;
 $7 = tempRet0;
 $power_down_flag = $s + 544 | 0;
 if (HEAP32[$power_down_flag >> 2] | 0) {
  STACKTOP = sp;
  return;
 }
 $cur_xlen = $s + 525 | 0;
 $10 = $5;
 $9 = $2;
 while (1) {
  $11 = _i64Subtract($6 | 0, $7 | 0, $9 | 0, $10 | 0) | 0;
  if (($11 | 0) <= 0) {
   label = 10;
   break;
  }
  $conv7 = HEAPU8[$cur_xlen >> 0] | 0;
  if (($conv7 | 0) == 32) _riscv_cpu_interp32($s, $11); else if (($conv7 | 0) == 64) _riscv_cpu_interp64($s, $11); else {
   label = 9;
   break;
  }
  if (HEAP32[$power_down_flag >> 2] | 0) {
   label = 10;
   break;
  }
  $15 = $insn_counter;
  $10 = HEAP32[$15 + 4 >> 2] | 0;
  $9 = HEAP32[$15 >> 2] | 0;
 }
 if ((label | 0) == 9) _abort(); else if ((label | 0) == 10) {
  STACKTOP = sp;
  return;
 }
}
function _wcrtomb($s, $wc, $st) {
 $s = $s | 0;
 $wc = $wc | 0;
 $st = $st | 0;
 var $retval$0 = 0, sp = 0;
 sp = STACKTOP;
 if (!$s) {
  $retval$0 = 1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 if ($wc >>> 0 < 128) {
  HEAP8[$s >> 0] = $wc;
  $retval$0 = 1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 if ($wc >>> 0 < 2048) {
  HEAP8[$s >> 0] = $wc >>> 6 | 192;
  HEAP8[$s + 1 >> 0] = $wc & 63 | 128;
  $retval$0 = 2;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 if ($wc >>> 0 < 55296 | ($wc + -57344 | 0) >>> 0 < 8192) {
  HEAP8[$s >> 0] = $wc >>> 12 | 224;
  HEAP8[$s + 1 >> 0] = $wc >>> 6 & 63 | 128;
  HEAP8[$s + 2 >> 0] = $wc & 63 | 128;
  $retval$0 = 3;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 if (($wc + -65536 | 0) >>> 0 < 1048576) {
  HEAP8[$s >> 0] = $wc >>> 18 | 240;
  HEAP8[$s + 1 >> 0] = $wc >>> 12 & 63 | 128;
  HEAP8[$s + 2 >> 0] = $wc >>> 6 & 63 | 128;
  HEAP8[$s + 3 >> 0] = $wc & 63 | 128;
  $retval$0 = 4;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else {
  HEAP32[(___errno_location() | 0) >> 2] = 84;
  $retval$0 = -1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 return 0;
}
function _bf_read_onload($opaque, $data, $size) {
 $opaque = $opaque | 0;
 $data = $data | 0;
 $size = $size | 0;
 var $0 = 0, $1 = 0, $10 = 0, $12 = 0, $2 = 0, $call$i = 0, $n_cached_blocks$i = 0, $next$i$i = 0, sp = 0;
 sp = STACKTOP;
 $0 = HEAP32[$opaque + 12 >> 2] | 0;
 $1 = HEAP32[$0 + 16 >> 2] | 0;
 if (($1 << 9 | 0) == ($size | 0)) {
  $2 = $0 + 1064 | 0;
  $10 = ___udivdi3(HEAP32[$2 >> 2] | 0, HEAP32[$2 + 4 >> 2] | 0, $1 | 0, (($1 | 0) < 0) << 31 >> 31 | 0) | 0;
  $n_cached_blocks$i = $0 + 1056 | 0;
  $call$i = _malloc($size | 12) | 0;
  HEAP32[$call$i + 8 >> 2] = $10;
  $next$i$i = $0 + 1052 | 0;
  $12 = HEAP32[$next$i$i >> 2] | 0;
  HEAP32[$next$i$i >> 2] = $call$i;
  HEAP32[$call$i >> 2] = $0 + 1048;
  HEAP32[$call$i + 4 >> 2] = $12;
  HEAP32[$12 >> 2] = $call$i;
  HEAP32[$n_cached_blocks$i >> 2] = (HEAP32[$n_cached_blocks$i >> 2] | 0) + 1;
  _memcpy($call$i + 12 | 0, $data | 0, $size | 0) | 0;
  _bf_read_async1($opaque, 0) | 0;
  STACKTOP = sp;
  return;
 } else ___assert_fail(736, 56, 2206, 768);
}
function _frexp($x, $e) {
 $x = +$x;
 $e = $e | 0;
 var $0 = 0, $1 = 0, $2 = 0, $call = 0.0, $conv = 0, $retval$0 = 0.0, $storemerge = 0, $x$addr$0 = 0.0, sp = 0;
 sp = STACKTOP;
 HEAPF64[tempDoublePtr >> 3] = $x;
 $0 = HEAP32[tempDoublePtr >> 2] | 0;
 $1 = HEAP32[tempDoublePtr + 4 >> 2] | 0;
 $2 = _bitshift64Lshr($0 | 0, $1 | 0, 52) | 0;
 $conv = $2 & 2047;
 if (($conv | 0) == 2047) {
  $retval$0 = $x;
  STACKTOP = sp;
  return +$retval$0;
 } else if (!$conv) {
  if ($x != 0.0) {
   $call = +_frexp($x * 18446744073709552000.0, $e);
   $storemerge = (HEAP32[$e >> 2] | 0) + -64 | 0;
   $x$addr$0 = $call;
  } else {
   $storemerge = 0;
   $x$addr$0 = $x;
  }
  HEAP32[$e >> 2] = $storemerge;
  $retval$0 = $x$addr$0;
  STACKTOP = sp;
  return +$retval$0;
 } else {
  HEAP32[$e >> 2] = $conv + -1022;
  HEAP32[tempDoublePtr >> 2] = $0;
  HEAP32[tempDoublePtr + 4 >> 2] = $1 & -2146435073 | 1071644672;
  $retval$0 = +HEAPF64[tempDoublePtr >> 3];
  STACKTOP = sp;
  return +$retval$0;
 }
 return 0.0;
}
function _cvt_i32_sf64($a, $rm, $pfflags) {
 $a = $a | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $1 = 0, $3 = 0, $5 = 0, $a$lobit = 0, $a_exp$0$i = 0, $r$0$i = 0, $r$0$i$i = 0, $r$1$i = 0, $sub1$i = 0, $sub2$i = 0, $sub8$i$i = 0, sp = 0;
 sp = STACKTOP;
 $r$0$i = ($a | 0) < 0 ? 0 - $a | 0 : $a;
 $a$lobit = $a >>> 31;
 if (!$r$0$i) $r$0$i$i = 32; else $r$0$i$i = _llvm_ctlz_i32($r$0$i | 0) | 0;
 $sub1$i = 32 - $r$0$i$i | 0;
 $sub2$i = $sub1$i + -63 | 0;
 if (($sub2$i | 0) > 0) {
  $a_exp$0$i = $sub1$i + 1022 | 0;
  $r$1$i = ((1 << $sub2$i) + -1 & $r$0$i | 0) != 0 | $r$0$i >>> $sub2$i;
 } else {
  $a_exp$0$i = 1085;
  $r$1$i = $r$0$i;
 }
 if (!$r$1$i) $sub8$i$i = 63; else {
  $1 = _llvm_ctlz_i64($r$1$i | 0, 0, 0) | 0;
  if (!$1) ___assert_fail(1104, 1064, 183, 1136); else $sub8$i$i = $1 + -1 | 0;
 }
 $3 = _bitshift64Shl($r$1$i | 0, 0, $sub8$i$i | 0) | 0;
 $5 = _roundpack_sf64($a$lobit, $a_exp$0$i - $sub8$i$i | 0, $3, tempRet0, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $5 | 0;
}
function _eq_quiet_sf64($0, $1, $2, $3, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $pfflags = $pfflags | 0;
 var $11 = 0, $retval$0 = 0, sp = 0;
 sp = STACKTOP;
 $11 = ($0 | 0) != 0 | ($1 & 1048575 | 0) != 0;
 if (!(0 == 0 & ($1 & 2146435072 | 0) == 2146435072 & $11)) if (!(0 == 0 & ($3 & 2146435072 | 0) == 2146435072 & (($2 | 0) != 0 | ($3 & 1048575 | 0) != 0))) {
  if (($2 | $0 | 0) == 0 & (($3 | $1) & 2147483647 | 0) == 0) {
   $retval$0 = 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  $retval$0 = ($0 | 0) == ($2 | 0) & ($1 | 0) == ($3 | 0) & 1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 if (!(0 == 0 & ($1 & 2146959360 | 0) == 2146435072 & $11)) if (!(0 == 0 & ($3 & 2146959360 | 0) == 2146435072 & (($2 | 0) != 0 | ($3 & 1048575 | 0) != 0))) {
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $retval$0 = 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _cvt_i32_sf32($a, $rm, $pfflags) {
 $a = $a | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $1 = 0, $a$lobit = 0, $a_exp$0$i = 0, $call2$i$i = 0, $r$0$i = 0, $r$0$i$i = 0, $r$1$i = 0, $sub1$i = 0, $sub2$i = 0, $sub8$i$i = 0, sp = 0;
 sp = STACKTOP;
 $r$0$i = ($a | 0) < 0 ? 0 - $a | 0 : $a;
 $a$lobit = $a >>> 31;
 if (!$r$0$i) $r$0$i$i = 32; else $r$0$i$i = _llvm_ctlz_i32($r$0$i | 0) | 0;
 $sub1$i = 32 - $r$0$i$i | 0;
 $sub2$i = $sub1$i + -31 | 0;
 if (($sub2$i | 0) > 0) {
  $a_exp$0$i = $sub1$i + 126 | 0;
  $r$1$i = ((1 << $sub2$i) + -1 & $r$0$i | 0) != 0 | $r$0$i >>> $sub2$i;
 } else {
  $a_exp$0$i = 157;
  $r$1$i = $r$0$i;
 }
 if (!$r$1$i) $sub8$i$i = 31; else {
  $1 = _llvm_ctlz_i32($r$1$i | 0) | 0;
  if (!$1) ___assert_fail(1104, 1064, 183, 1168); else $sub8$i$i = $1 + -1 | 0;
 }
 $call2$i$i = _roundpack_sf32($a$lobit, $a_exp$0$i - $sub8$i$i | 0, $r$1$i << $sub8$i$i, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $call2$i$i | 0;
}
function ___remdi3($a$0, $a$1, $b$0, $b$1) {
 $a$0 = $a$0 | 0;
 $a$1 = $a$1 | 0;
 $b$0 = $b$0 | 0;
 $b$1 = $b$1 | 0;
 var $rem = 0, $1$0 = 0, $1$1 = 0, $2$0 = 0, $2$1 = 0, $4$0 = 0, $4$1 = 0, $10$0 = 0, $10$1 = 0, __stackBase__ = 0;
 __stackBase__ = STACKTOP;
 STACKTOP = STACKTOP + 8 | 0;
 $rem = __stackBase__ | 0;
 $1$0 = $a$1 >> 31 | (($a$1 | 0) < 0 ? -1 : 0) << 1;
 $1$1 = (($a$1 | 0) < 0 ? -1 : 0) >> 31 | (($a$1 | 0) < 0 ? -1 : 0) << 1;
 $2$0 = $b$1 >> 31 | (($b$1 | 0) < 0 ? -1 : 0) << 1;
 $2$1 = (($b$1 | 0) < 0 ? -1 : 0) >> 31 | (($b$1 | 0) < 0 ? -1 : 0) << 1;
 $4$0 = _i64Subtract($1$0 ^ $a$0, $1$1 ^ $a$1, $1$0, $1$1) | 0;
 $4$1 = tempRet0;
 ___udivmoddi4($4$0, $4$1, _i64Subtract($2$0 ^ $b$0, $2$1 ^ $b$1, $2$0, $2$1) | 0, tempRet0, $rem) | 0;
 $10$0 = _i64Subtract(HEAP32[$rem >> 2] ^ $1$0, HEAP32[$rem + 4 >> 2] ^ $1$1, $1$0, $1$1) | 0;
 $10$1 = tempRet0;
 STACKTOP = __stackBase__;
 return (tempRet0 = $10$1, $10$0) | 0;
}
function _cvt_u32_sf64($a, $rm, $pfflags) {
 $a = $a | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $1 = 0, $3 = 0, $5 = 0, $a_exp$0$i = 0, $r$0$i$i = 0, $r$1$i = 0, $sub1$i = 0, $sub2$i = 0, $sub8$i$i = 0, sp = 0;
 sp = STACKTOP;
 if (!$a) $r$0$i$i = 32; else $r$0$i$i = _llvm_ctlz_i32($a | 0) | 0;
 $sub1$i = 32 - $r$0$i$i | 0;
 $sub2$i = $sub1$i + -63 | 0;
 if (($sub2$i | 0) > 0) {
  $a_exp$0$i = $sub1$i + 1022 | 0;
  $r$1$i = ((1 << $sub2$i) + -1 & $a | 0) != 0 | $a >>> $sub2$i;
 } else {
  $a_exp$0$i = 1085;
  $r$1$i = $a;
 }
 if (!$r$1$i) $sub8$i$i = 63; else {
  $1 = _llvm_ctlz_i64($r$1$i | 0, 0, 0) | 0;
  if (!$1) ___assert_fail(1104, 1064, 183, 1136); else $sub8$i$i = $1 + -1 | 0;
 }
 $3 = _bitshift64Shl($r$1$i | 0, 0, $sub8$i$i | 0) | 0;
 $5 = _roundpack_sf64(0, $a_exp$0$i - $sub8$i$i | 0, $3, tempRet0, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $5 | 0;
}
function _le_sf32($a, $b, $pfflags) {
 $a = $a | 0;
 $b = $b | 0;
 $pfflags = $pfflags | 0;
 var $1 = 0, $retval$0 = 0, $shr = 0, $tobool5 = 0, sp = 0;
 sp = STACKTOP;
 if (!(($a & 2139095040 | 0) == 2139095040 & ($a & 8388607 | 0) != 0)) if (!(($b & 2139095040 | 0) == 2139095040 & ($b & 8388607 | 0) != 0)) {
  $shr = $a >>> 31;
  $tobool5 = ($shr | 0) != 0;
  if (($shr | 0) != ($b >>> 31 | 0)) {
   if ($tobool5) $1 = 1; else $1 = (($b | $a) & 2147483647 | 0) == 0;
   $retval$0 = $1 & 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if ($tobool5) {
   $retval$0 = $a >>> 0 >= $b >>> 0 & 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  } else {
   $retval$0 = $a >>> 0 <= $b >>> 0 & 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $retval$0 = 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _lt_sf32($a, $b, $pfflags) {
 $a = $a | 0;
 $b = $b | 0;
 $pfflags = $pfflags | 0;
 var $1 = 0, $retval$0 = 0, $shr = 0, $tobool5 = 0, sp = 0;
 sp = STACKTOP;
 if (!(($a & 2139095040 | 0) == 2139095040 & ($a & 8388607 | 0) != 0)) if (!(($b & 2139095040 | 0) == 2139095040 & ($b & 8388607 | 0) != 0)) {
  $shr = $a >>> 31;
  $tobool5 = ($shr | 0) != 0;
  if (($shr | 0) != ($b >>> 31 | 0)) {
   if ($tobool5) $1 = (($b | $a) & 2147483647 | 0) != 0; else $1 = 0;
   $retval$0 = $1 & 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  if ($tobool5) {
   $retval$0 = $a >>> 0 > $b >>> 0 & 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  } else {
   $retval$0 = $a >>> 0 < $b >>> 0 & 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $retval$0 = 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function _cvt_u32_sf32($a, $rm, $pfflags) {
 $a = $a | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $1 = 0, $a_exp$0$i = 0, $call2$i$i = 0, $r$0$i$i = 0, $r$1$i = 0, $sub1$i = 0, $sub2$i = 0, $sub8$i$i = 0, sp = 0;
 sp = STACKTOP;
 if (!$a) $r$0$i$i = 32; else $r$0$i$i = _llvm_ctlz_i32($a | 0) | 0;
 $sub1$i = 32 - $r$0$i$i | 0;
 $sub2$i = $sub1$i + -31 | 0;
 if (($sub2$i | 0) > 0) {
  $a_exp$0$i = $sub1$i + 126 | 0;
  $r$1$i = ((1 << $sub2$i) + -1 & $a | 0) != 0 | $a >>> $sub2$i;
 } else {
  $a_exp$0$i = 157;
  $r$1$i = $a;
 }
 if (!$r$1$i) $sub8$i$i = 31; else {
  $1 = _llvm_ctlz_i32($r$1$i | 0) | 0;
  if (!$1) ___assert_fail(1104, 1064, 183, 1168); else $sub8$i$i = $1 + -1 | 0;
 }
 $call2$i$i = _roundpack_sf32(0, $a_exp$0$i - $sub8$i$i | 0, $r$1$i << $sub8$i$i, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $call2$i$i | 0;
}
function _eq_quiet_sf32($a, $b, $pfflags) {
 $a = $a | 0;
 $b = $b | 0;
 $pfflags = $pfflags | 0;
 var $cmp2$i = 0, $retval$0 = 0, sp = 0;
 sp = STACKTOP;
 $cmp2$i = ($a & 8388607 | 0) != 0;
 if (!(($a & 2139095040 | 0) == 2139095040 & $cmp2$i)) if (!(($b & 2139095040 | 0) == 2139095040 & ($b & 8388607 | 0) != 0)) {
  if (!(($b | $a) & 2147483647)) {
   $retval$0 = 1;
   STACKTOP = sp;
   return $retval$0 | 0;
  }
  $retval$0 = ($a | 0) == ($b | 0) & 1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 if (!(($a & 2143289344 | 0) == 2139095040 & $cmp2$i)) if (!(($b & 2143289344 | 0) == 2139095040 & ($b & 8388607 | 0) != 0)) {
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 HEAP32[$pfflags >> 2] = HEAP32[$pfflags >> 2] | 1;
 $retval$0 = 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function ___divdi3($a$0, $a$1, $b$0, $b$1) {
 $a$0 = $a$0 | 0;
 $a$1 = $a$1 | 0;
 $b$0 = $b$0 | 0;
 $b$1 = $b$1 | 0;
 var $1$0 = 0, $1$1 = 0, $2$0 = 0, $2$1 = 0, $4$0 = 0, $4$1 = 0, $7$0 = 0, $7$1 = 0, $10$0 = 0;
 $1$0 = $a$1 >> 31 | (($a$1 | 0) < 0 ? -1 : 0) << 1;
 $1$1 = (($a$1 | 0) < 0 ? -1 : 0) >> 31 | (($a$1 | 0) < 0 ? -1 : 0) << 1;
 $2$0 = $b$1 >> 31 | (($b$1 | 0) < 0 ? -1 : 0) << 1;
 $2$1 = (($b$1 | 0) < 0 ? -1 : 0) >> 31 | (($b$1 | 0) < 0 ? -1 : 0) << 1;
 $4$0 = _i64Subtract($1$0 ^ $a$0, $1$1 ^ $a$1, $1$0, $1$1) | 0;
 $4$1 = tempRet0;
 $7$0 = $2$0 ^ $1$0;
 $7$1 = $2$1 ^ $1$1;
 $10$0 = _i64Subtract((___udivmoddi4($4$0, $4$1, _i64Subtract($2$0 ^ $b$0, $2$1 ^ $b$1, $2$0, $2$1) | 0, tempRet0, 0) | 0) ^ $7$0, tempRet0 ^ $7$1, $7$0, $7$1) | 0;
 return $10$0 | 0;
}
function _fclass_sf64($0, $1) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 var $2 = 0, $4 = 0, $6 = 0, $conv2 = 0, $ret$0 = 0, $tobool23 = 0, sp = 0;
 sp = STACKTOP;
 $2 = _bitshift64Lshr($0 | 0, $1 | 0, 63) | 0;
 $4 = _bitshift64Lshr($0 | 0, $1 | 0, 52) | 0;
 $conv2 = $4 & 2047;
 $6 = $1 & 1048575;
 do if (($conv2 | 0) == 2047) if (($0 | 0) == 0 & ($6 | 0) == 0) {
  $ret$0 = ($2 | 0) == 0 ? 128 : 1;
  break;
 } else {
  $ret$0 = 0 == 0 & ($1 & 524288 | 0) == 0 ? 256 : 512;
  break;
 } else if (!$conv2) {
  $tobool23 = ($2 | 0) != 0;
  if (($0 | 0) == 0 & ($6 | 0) == 0) {
   $ret$0 = $tobool23 ? 8 : 16;
   break;
  } else {
   $ret$0 = $tobool23 ? 4 : 32;
   break;
  }
 } else $ret$0 = ($2 | 0) == 0 ? 64 : 2; while (0);
 STACKTOP = sp;
 return $ret$0 | 0;
}
function _memcpy(dest, src, num) {
 dest = dest | 0;
 src = src | 0;
 num = num | 0;
 var ret = 0;
 if ((num | 0) >= 4096) return _emscripten_memcpy_big(dest | 0, src | 0, num | 0) | 0;
 ret = dest | 0;
 if ((dest & 3) == (src & 3)) {
  while (dest & 3) {
   if (!num) return ret | 0;
   HEAP8[dest >> 0] = HEAP8[src >> 0] | 0;
   dest = dest + 1 | 0;
   src = src + 1 | 0;
   num = num - 1 | 0;
  }
  while ((num | 0) >= 4) {
   HEAP32[dest >> 2] = HEAP32[src >> 2];
   dest = dest + 4 | 0;
   src = src + 4 | 0;
   num = num - 4 | 0;
  }
 }
 while ((num | 0) > 0) {
  HEAP8[dest >> 0] = HEAP8[src >> 0] | 0;
  dest = dest + 1 | 0;
  src = src + 1 | 0;
  num = num - 1 | 0;
 }
 return ret | 0;
}
function _memset(ptr, value, num) {
 ptr = ptr | 0;
 value = value | 0;
 num = num | 0;
 var stop = 0, value4 = 0, stop4 = 0, unaligned = 0;
 stop = ptr + num | 0;
 if ((num | 0) >= 20) {
  value = value & 255;
  unaligned = ptr & 3;
  value4 = value | value << 8 | value << 16 | value << 24;
  stop4 = stop & ~3;
  if (unaligned) {
   unaligned = ptr + 4 - unaligned | 0;
   while ((ptr | 0) < (unaligned | 0)) {
    HEAP8[ptr >> 0] = value;
    ptr = ptr + 1 | 0;
   }
  }
  while ((ptr | 0) < (stop4 | 0)) {
   HEAP32[ptr >> 2] = value4;
   ptr = ptr + 4 | 0;
  }
 }
 while ((ptr | 0) < (stop | 0)) {
  HEAP8[ptr >> 0] = value;
  ptr = ptr + 1 | 0;
 }
 return ptr - num | 0;
}
function _htif_read($opaque, $0, $1, $size_log2) {
 $opaque = $opaque | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $size_log2 = $size_log2 | 0;
 var $val$0 = 0, sp = 0;
 sp = STACKTOP;
 if (($size_log2 | 0) != 2) ___assert_fail(840, 56, 1705, 912);
 if (($0 | 0) == 12) if (!$1) $val$0 = HEAP32[$opaque + 60 >> 2] | 0; else $val$0 = 0; else if (($0 | 0) == 8) if (!$1) $val$0 = HEAP32[$opaque + 56 >> 2] | 0; else $val$0 = 0; else if (($0 | 0) == 4) if (!$1) $val$0 = HEAP32[$opaque + 52 >> 2] | 0; else $val$0 = 0; else if (!$0) if (!$1) $val$0 = HEAP32[$opaque + 48 >> 2] | 0; else $val$0 = 0; else $val$0 = 0;
 tempRet0 = 0;
 STACKTOP = sp;
 return $val$0 | 0;
}
function ___towrite($f) {
 $f = $f | 0;
 var $1 = 0, $2 = 0, $conv = 0, $mode = 0, $retval$0 = 0, sp = 0;
 sp = STACKTOP;
 $mode = $f + 74 | 0;
 $conv = HEAP8[$mode >> 0] | 0;
 HEAP8[$mode >> 0] = $conv + 255 | $conv;
 $1 = HEAP32[$f >> 2] | 0;
 if (!($1 & 8)) {
  HEAP32[$f + 8 >> 2] = 0;
  HEAP32[$f + 4 >> 2] = 0;
  $2 = HEAP32[$f + 44 >> 2] | 0;
  HEAP32[$f + 28 >> 2] = $2;
  HEAP32[$f + 20 >> 2] = $2;
  HEAP32[$f + 16 >> 2] = $2 + (HEAP32[$f + 48 >> 2] | 0);
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 } else {
  HEAP32[$f >> 2] = $1 | 32;
  $retval$0 = -1;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 return 0;
}
function _fclass_sf32($a) {
 $a = $a | 0;
 var $and = 0, $and2 = 0, $ret$0 = 0, $shr = 0, $tobool18 = 0, sp = 0;
 sp = STACKTOP;
 $shr = $a >>> 31;
 $and = $a >>> 23 & 255;
 $and2 = $a & 8388607;
 do if (!$and) {
  $tobool18 = ($shr | 0) != 0;
  if (!$and2) {
   $ret$0 = $tobool18 ? 8 : 16;
   break;
  } else {
   $ret$0 = $tobool18 ? 4 : 32;
   break;
  }
 } else if (($and | 0) == 255) if (!$and2) {
  $ret$0 = ($shr | 0) == 0 ? 128 : 1;
  break;
 } else {
  $ret$0 = ($a >>> 14 & 256) + 256 | 0;
  break;
 } else $ret$0 = ($shr | 0) == 0 ? 64 : 2; while (0);
 STACKTOP = sp;
 return $ret$0 | 0;
}
function _bf_read_async($bs, $0, $1, $buf, $n, $cb, $opaque) {
 $bs = $bs | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $buf = $buf | 0;
 $n = $n | 0;
 $cb = $cb | 0;
 $opaque = $opaque | 0;
 var $2 = 0, $3 = 0, $call = 0, sp = 0;
 sp = STACKTOP;
 $2 = HEAP32[$bs + 12 >> 2] | 0;
 $3 = $2 + 1064 | 0;
 HEAP32[$3 >> 2] = $0;
 HEAP32[$3 + 4 >> 2] = $1;
 HEAP32[$2 + 1088 >> 2] = $buf;
 HEAP32[$2 + 1076 >> 2] = $n;
 HEAP32[$2 + 1072 >> 2] = 0;
 HEAP32[$2 + 1080 >> 2] = $cb;
 HEAP32[$2 + 1084 >> 2] = $opaque;
 $call = _bf_read_async1($bs, 1) | 0;
 STACKTOP = sp;
 return $call | 0;
}
function ___muldi3($a$0, $a$1, $b$0, $b$1) {
 $a$0 = $a$0 | 0;
 $a$1 = $a$1 | 0;
 $b$0 = $b$0 | 0;
 $b$1 = $b$1 | 0;
 var $x_sroa_0_0_extract_trunc = 0, $y_sroa_0_0_extract_trunc = 0, $1$0 = 0, $1$1 = 0;
 $x_sroa_0_0_extract_trunc = $a$0;
 $y_sroa_0_0_extract_trunc = $b$0;
 $1$0 = ___muldsi3($x_sroa_0_0_extract_trunc, $y_sroa_0_0_extract_trunc) | 0;
 $1$1 = tempRet0;
 return (tempRet0 = (Math_imul($a$1, $y_sroa_0_0_extract_trunc) | 0) + (Math_imul($b$1, $x_sroa_0_0_extract_trunc) | 0) + $1$1 | $1$1 & 0, $1$0 | 0 | 0) | 0;
}
function _sn_write($f, $s, $l) {
 $f = $f | 0;
 $s = $s | 0;
 $l = $l | 0;
 var $1 = 0, $l$sub$ptr$sub = 0, $sub$ptr$sub = 0, $wpos = 0, sp = 0;
 sp = STACKTOP;
 $wpos = $f + 20 | 0;
 $1 = HEAP32[$wpos >> 2] | 0;
 $sub$ptr$sub = (HEAP32[$f + 16 >> 2] | 0) - $1 | 0;
 $l$sub$ptr$sub = $sub$ptr$sub >>> 0 > $l >>> 0 ? $l : $sub$ptr$sub;
 _memcpy($1 | 0, $s | 0, $l$sub$ptr$sub | 0) | 0;
 HEAP32[$wpos >> 2] = (HEAP32[$wpos >> 2] | 0) + $l$sub$ptr$sub;
 STACKTOP = sp;
 return $l | 0;
}
function _console_read($opaque, $buf, $len) {
 $opaque = $opaque | 0;
 $buf = $buf | 0;
 $len = $len | 0;
 var $inc = 0, $retval$0 = 0, sp = 0;
 sp = STACKTOP;
 if (!(HEAP32[30] | 0)) {
  $retval$0 = 0;
  STACKTOP = sp;
  return $retval$0 | 0;
 }
 HEAP8[$buf >> 0] = HEAP8[136 + (HEAP32[196] | 0) >> 0] | 0;
 $inc = (HEAP32[196] | 0) + 1 | 0;
 HEAP32[196] = ($inc | 0) == 64 ? 0 : $inc;
 HEAP32[30] = (HEAP32[30] | 0) + -1;
 $retval$0 = 1;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function copyTempDouble(ptr) {
 ptr = ptr | 0;
 HEAP8[tempDoublePtr >> 0] = HEAP8[ptr >> 0];
 HEAP8[tempDoublePtr + 1 >> 0] = HEAP8[ptr + 1 >> 0];
 HEAP8[tempDoublePtr + 2 >> 0] = HEAP8[ptr + 2 >> 0];
 HEAP8[tempDoublePtr + 3 >> 0] = HEAP8[ptr + 3 >> 0];
 HEAP8[tempDoublePtr + 4 >> 0] = HEAP8[ptr + 4 >> 0];
 HEAP8[tempDoublePtr + 5 >> 0] = HEAP8[ptr + 5 >> 0];
 HEAP8[tempDoublePtr + 6 >> 0] = HEAP8[ptr + 6 >> 0];
 HEAP8[tempDoublePtr + 7 >> 0] = HEAP8[ptr + 7 >> 0];
}
function ___muldsi3($a, $b) {
 $a = $a | 0;
 $b = $b | 0;
 var $1 = 0, $2 = 0, $3 = 0, $6 = 0, $8 = 0, $11 = 0, $12 = 0;
 $1 = $a & 65535;
 $2 = $b & 65535;
 $3 = Math_imul($2, $1) | 0;
 $6 = $a >>> 16;
 $8 = ($3 >>> 16) + (Math_imul($2, $6) | 0) | 0;
 $11 = $b >>> 16;
 $12 = Math_imul($11, $1) | 0;
 return (tempRet0 = ($8 >>> 16) + (Math_imul($11, $6) | 0) + ((($8 & 65535) + $12 | 0) >>> 16) | 0, $8 + $12 << 16 | $3 & 65535 | 0) | 0;
}
function ___uremdi3($a$0, $a$1, $b$0, $b$1) {
 $a$0 = $a$0 | 0;
 $a$1 = $a$1 | 0;
 $b$0 = $b$0 | 0;
 $b$1 = $b$1 | 0;
 var $rem = 0, __stackBase__ = 0;
 __stackBase__ = STACKTOP;
 STACKTOP = STACKTOP + 8 | 0;
 $rem = __stackBase__ | 0;
 ___udivmoddi4($a$0, $a$1, $b$0, $b$1, $rem) | 0;
 STACKTOP = __stackBase__;
 return (tempRet0 = HEAP32[$rem + 4 >> 2] | 0, HEAP32[$rem >> 2] | 0) | 0;
}
function _console_write($opaque, $buf, $len) {
 $opaque = $opaque | 0;
 $buf = $buf | 0;
 $len = $len | 0;
 var $i$04 = 0, sp = 0;
 sp = STACKTOP;
 if (($len | 0) > 0) $i$04 = 0; else {
  STACKTOP = sp;
  return;
 }
 do {
  _emscripten_asm_const_int(792, HEAPU8[$buf + $i$04 >> 0] | 0 | 0) | 0;
  $i$04 = $i$04 + 1 | 0;
 } while (($i$04 | 0) != ($len | 0));
 STACKTOP = sp;
 return;
}
function _llvm_cttz_i32(x) {
 x = x | 0;
 var ret = 0;
 ret = HEAP8[cttz_i8 + (x & 255) >> 0] | 0;
 if ((ret | 0) < 8) return ret | 0;
 ret = HEAP8[cttz_i8 + (x >> 8 & 255) >> 0] | 0;
 if ((ret | 0) < 8) return ret + 8 | 0;
 ret = HEAP8[cttz_i8 + (x >> 16 & 255) >> 0] | 0;
 if ((ret | 0) < 8) return ret + 16 | 0;
 return (HEAP8[cttz_i8 + (x >>> 24) >> 0] | 0) + 24 | 0;
}
function _llvm_ctlz_i32(x) {
 x = x | 0;
 var ret = 0;
 ret = HEAP8[ctlz_i8 + (x >>> 24) >> 0] | 0;
 if ((ret | 0) < 8) return ret | 0;
 ret = HEAP8[ctlz_i8 + (x >> 16 & 255) >> 0] | 0;
 if ((ret | 0) < 8) return ret + 8 | 0;
 ret = HEAP8[ctlz_i8 + (x >> 8 & 255) >> 0] | 0;
 if ((ret | 0) < 8) return ret + 16 | 0;
 return (HEAP8[ctlz_i8 + (x & 255) >> 0] | 0) + 24 | 0;
}
function _console_queue_char($c) {
 $c = $c | 0;
 var $0 = 0, $1 = 0, $inc = 0, sp = 0;
 sp = STACKTOP;
 $0 = HEAP32[30] | 0;
 if ($0 >>> 0 >= 64) {
  STACKTOP = sp;
  return;
 }
 $1 = HEAP32[32] | 0;
 HEAP8[136 + $1 >> 0] = $c;
 $inc = $1 + 1 | 0;
 HEAP32[32] = ($inc | 0) == 64 ? 0 : $inc;
 HEAP32[30] = $0 + 1;
 STACKTOP = sp;
 return;
}
function _snprintf($s, $n, $fmt, $varargs) {
 $s = $s | 0;
 $n = $n | 0;
 $fmt = $fmt | 0;
 $varargs = $varargs | 0;
 var $ap = 0, $call = 0, sp = 0;
 sp = STACKTOP;
 STACKTOP = STACKTOP + 16 | 0;
 $ap = sp;
 HEAP32[$ap >> 2] = $varargs;
 $call = _vsnprintf($s, $n, $fmt, $ap) | 0;
 STACKTOP = sp;
 return $call | 0;
}
function dynCall_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
 index = index | 0;
 a1 = a1 | 0;
 a2 = a2 | 0;
 a3 = a3 | 0;
 a4 = a4 | 0;
 a5 = a5 | 0;
 a6 = a6 | 0;
 a7 = a7 | 0;
 return FUNCTION_TABLE_iiiiiiii[index & 3](a1 | 0, a2 | 0, a3 | 0, a4 | 0, a5 | 0, a6 | 0, a7 | 0) | 0;
}
function _sub_sf64($0, $1, $2, $3, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $5 = 0, sp = 0;
 sp = STACKTOP;
 $5 = _add_sf64($0, $1, $2, $3 ^ -2147483648, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $5 | 0;
}
function _bitshift64Ashr(low, high, bits) {
 low = low | 0;
 high = high | 0;
 bits = bits | 0;
 if ((bits | 0) < 32) {
  tempRet0 = high >> bits;
  return low >>> bits | (high & (1 << bits) - 1) << 32 - bits;
 }
 tempRet0 = (high | 0) < 0 ? -1 : 0;
 return high >> bits - 32 | 0;
}
function _ide_read($opaque, $0, $1, $size_log2) {
 $opaque = $opaque | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $size_log2 = $size_log2 | 0;
 var $call = 0, sp = 0;
 sp = STACKTOP;
 $call = _ide_mmio_read_u32($opaque, $0) | 0;
 tempRet0 = 0;
 STACKTOP = sp;
 return $call | 0;
}
function _bitshift64Shl(low, high, bits) {
 low = low | 0;
 high = high | 0;
 bits = bits | 0;
 if ((bits | 0) < 32) {
  tempRet0 = high << bits | (low & (1 << bits) - 1 << 32 - bits) >>> 32 - bits;
  return low << bits;
 }
 tempRet0 = low << bits - 32;
 return 0;
}
function _ide_write($opaque, $0, $1, $2, $3, $size_log2) {
 $opaque = $opaque | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $2 = $2 | 0;
 $3 = $3 | 0;
 $size_log2 = $size_log2 | 0;
 var sp = 0;
 sp = STACKTOP;
 _ide_mmio_write_u32($opaque, $0, $2);
 STACKTOP = sp;
 return;
}
function _bitshift64Lshr(low, high, bits) {
 low = low | 0;
 high = high | 0;
 bits = bits | 0;
 if ((bits | 0) < 32) {
  tempRet0 = high >>> bits;
  return low >>> bits | (high & (1 << bits) - 1) << 32 - bits;
 }
 tempRet0 = 0;
 return high >>> bits - 32 | 0;
}
function copyTempFloat(ptr) {
 ptr = ptr | 0;
 HEAP8[tempDoublePtr >> 0] = HEAP8[ptr >> 0];
 HEAP8[tempDoublePtr + 1 >> 0] = HEAP8[ptr + 1 >> 0];
 HEAP8[tempDoublePtr + 2 >> 0] = HEAP8[ptr + 2 >> 0];
 HEAP8[tempDoublePtr + 3 >> 0] = HEAP8[ptr + 3 >> 0];
}
function _sub_sf32($a, $b, $rm, $pfflags) {
 $a = $a | 0;
 $b = $b | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $call = 0, sp = 0;
 sp = STACKTOP;
 $call = _add_sf32($a, $b ^ -2147483648, $rm, $pfflags) | 0;
 STACKTOP = sp;
 return $call | 0;
}
function _cvt_sf64_u64($0, $1, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $2 = 0, sp = 0;
 sp = STACKTOP;
 $2 = _internal_cvt_sf64_i64($0, $1, $rm, $pfflags, 1) | 0;
 STACKTOP = sp;
 return $2 | 0;
}
function _cvt_sf64_u32($0, $1, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $2 = 0, sp = 0;
 sp = STACKTOP;
 $2 = _internal_cvt_sf64_i32($0, $1, $rm, $pfflags, 1) | 0;
 STACKTOP = sp;
 return $2 | 0;
}
function _cvt_sf64_i64($0, $1, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $2 = 0, sp = 0;
 sp = STACKTOP;
 $2 = _internal_cvt_sf64_i64($0, $1, $rm, $pfflags, 0) | 0;
 STACKTOP = sp;
 return $2 | 0;
}
function _cvt_sf64_i32($0, $1, $rm, $pfflags) {
 $0 = $0 | 0;
 $1 = $1 | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $2 = 0, sp = 0;
 sp = STACKTOP;
 $2 = _internal_cvt_sf64_i32($0, $1, $rm, $pfflags, 0) | 0;
 STACKTOP = sp;
 return $2 | 0;
}
function dynCall_viiiiii(index, a1, a2, a3, a4, a5, a6) {
 index = index | 0;
 a1 = a1 | 0;
 a2 = a2 | 0;
 a3 = a3 | 0;
 a4 = a4 | 0;
 a5 = a5 | 0;
 a6 = a6 | 0;
 FUNCTION_TABLE_viiiiii[index & 7](a1 | 0, a2 | 0, a3 | 0, a4 | 0, a5 | 0, a6 | 0);
}
function _cvt_sf32_u32($a, $rm, $pfflags) {
 $a = $a | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $call = 0, sp = 0;
 sp = STACKTOP;
 $call = _internal_cvt_sf32_i32($a, $rm, $pfflags, 1) | 0;
 STACKTOP = sp;
 return $call | 0;
}
function _cvt_sf32_i32($a, $rm, $pfflags) {
 $a = $a | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $call = 0, sp = 0;
 sp = STACKTOP;
 $call = _internal_cvt_sf32_i32($a, $rm, $pfflags, 0) | 0;
 STACKTOP = sp;
 return $call | 0;
}
function runPostSets() {}
function _i64Subtract(a, b, c, d) {
 a = a | 0;
 b = b | 0;
 c = c | 0;
 d = d | 0;
 var h = 0;
 h = b - d >>> 0;
 h = b - d - (c >>> 0 > a >>> 0 | 0) >>> 0;
 return (tempRet0 = h, a - c >>> 0 | 0) | 0;
}
function _cvt_sf32_u64($a, $rm, $pfflags) {
 $a = $a | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $0 = 0, sp = 0;
 sp = STACKTOP;
 $0 = _internal_cvt_sf32_i64($a, $rm, $pfflags, 1) | 0;
 STACKTOP = sp;
 return $0 | 0;
}
function _cvt_sf32_i64($a, $rm, $pfflags) {
 $a = $a | 0;
 $rm = $rm | 0;
 $pfflags = $pfflags | 0;
 var $0 = 0, sp = 0;
 sp = STACKTOP;
 $0 = _internal_cvt_sf32_i64($a, $rm, $pfflags, 0) | 0;
 STACKTOP = sp;
 return $0 | 0;
}
function _bf_get_sector_count($bs) {
 $bs = $bs | 0;
 var $1 = 0, sp = 0;
 sp = STACKTOP;
 $1 = (HEAP32[$bs + 12 >> 2] | 0) + 8 | 0;
 tempRet0 = HEAP32[$1 + 4 >> 2] | 0;
 STACKTOP = sp;
 return HEAP32[$1 >> 2] | 0;
}
function _wctomb($s, $wc) {
 $s = $s | 0;
 $wc = $wc | 0;
 var $retval$0 = 0, sp = 0;
 sp = STACKTOP;
 if (!$s) $retval$0 = 0; else $retval$0 = _wcrtomb($s, $wc, 0) | 0;
 STACKTOP = sp;
 return $retval$0 | 0;
}
function ___udivdi3($a$0, $a$1, $b$0, $b$1) {
 $a$0 = $a$0 | 0;
 $a$1 = $a$1 | 0;
 $b$0 = $b$0 | 0;
 $b$1 = $b$1 | 0;
 var $1$0 = 0;
 $1$0 = ___udivmoddi4($a$0, $a$1, $b$0, $b$1, 0) | 0;
 return $1$0 | 0;
}
function dynCall_iiiii(index, a1, a2, a3, a4) {
 index = index | 0;
 a1 = a1 | 0;
 a2 = a2 | 0;
 a3 = a3 | 0;
 a4 = a4 | 0;
 return FUNCTION_TABLE_iiiii[index & 7](a1 | 0, a2 | 0, a3 | 0, a4 | 0) | 0;
}
function _ide_sector_read_cb_end($s) {
 $s = $s | 0;
 HEAP8[$s + 40 >> 0] = 80;
 HEAP8[$s + 33 >> 0] = 0;
 HEAP32[$s + 52 >> 2] = 6;
 HEAP32[$s + 56 >> 2] = 0;
 HEAP32[$s + 60 >> 2] = 0;
 return;
}
function _bf_write_async($bs, $0, $1, $buf, $n, $cb, $opaque) {
 $bs = $bs | 0;
 $0 = $0 | 0;
 $1 = $1 | 0;
 $buf = $buf | 0;
 $n = $n | 0;
 $cb = $cb | 0;
 $opaque = $opaque | 0;
 return -1;
}
function _i64Add(a, b, c, d) {
 a = a | 0;
 b = b | 0;
 c = c | 0;
 d = d | 0;
 var l = 0;
 l = a + c >>> 0;
 return (tempRet0 = b + d + (l >>> 0 < a >>> 0 | 0) >>> 0, l | 0) | 0;
}
function dynCall_iiii(index, a1, a2, a3) {
 index = index | 0;
 a1 = a1 | 0;
 a2 = a2 | 0;
 a3 = a3 | 0;
 return FUNCTION_TABLE_iiii[index & 3](a1 | 0, a2 | 0, a3 | 0) | 0;
}
function _ide_identify_cb($s) {
 $s = $s | 0;
 HEAP32[$s + 52 >> 2] = 6;
 HEAP32[$s + 56 >> 2] = 0;
 HEAP32[$s + 60 >> 2] = 0;
 HEAP8[$s + 40 >> 0] = 64;
 return;
}
function dynCall_viii(index, a1, a2, a3) {
 index = index | 0;
 a1 = a1 | 0;
 a2 = a2 | 0;
 a3 = a3 | 0;
 FUNCTION_TABLE_viii[index & 3](a1 | 0, a2 | 0, a3 | 0);
}
function b0(p0, p1, p2, p3, p4, p5, p6) {
 p0 = p0 | 0;
 p1 = p1 | 0;
 p2 = p2 | 0;
 p3 = p3 | 0;
 p4 = p4 | 0;
 p5 = p5 | 0;
 p6 = p6 | 0;
 abort(0);
 return 0;
}
function stackAlloc(size) {
 size = size | 0;
 var ret = 0;
 ret = STACKTOP;
 STACKTOP = STACKTOP + size | 0;
 STACKTOP = STACKTOP + 15 & -16;
 return ret | 0;
}
function _frexpl($x, $e) {
 $x = +$x;
 $e = $e | 0;
 var $call = 0.0, sp = 0;
 sp = STACKTOP;
 $call = +_frexp($x, $e);
 STACKTOP = sp;
 return +$call;
}
function _strlen(ptr) {
 ptr = ptr | 0;
 var curr = 0;
 curr = ptr;
 while (HEAP8[curr >> 0] | 0) curr = curr + 1 | 0;
 return curr - ptr | 0;
}
function setThrew(threw, value) {
 threw = threw | 0;
 value = value | 0;
 if (!__THREW__) {
  __THREW__ = threw;
  threwValue = value;
 }
}
function _ide_transfer_stop($s) {
 $s = $s | 0;
 HEAP32[$s + 52 >> 2] = 6;
 HEAP32[$s + 56 >> 2] = 0;
 HEAP32[$s + 60 >> 2] = 0;
 return;
}
function _load_image_onerror($opaque) {
 $opaque = $opaque | 0;
 var sp = 0;
 sp = STACKTOP;
 _puts(1008) | 0;
 STACKTOP = sp;
 return;
}
function dynCall_vii(index, a1, a2) {
 index = index | 0;
 a1 = a1 | 0;
 a2 = a2 | 0;
 FUNCTION_TABLE_vii[index & 1](a1 | 0, a2 | 0);
}
function b7(p0, p1, p2, p3, p4, p5) {
 p0 = p0 | 0;
 p1 = p1 | 0;
 p2 = p2 | 0;
 p3 = p3 | 0;
 p4 = p4 | 0;
 p5 = p5 | 0;
 abort(7);
}
function dynCall_ii(index, a1) {
 index = index | 0;
 a1 = a1 | 0;
 return FUNCTION_TABLE_ii[index & 1](a1 | 0) | 0;
}
function b6(p0, p1, p2, p3) {
 p0 = p0 | 0;
 p1 = p1 | 0;
 p2 = p2 | 0;
 p3 = p3 | 0;
 abort(6);
 return 0;
}
function dynCall_vi(index, a1) {
 index = index | 0;
 a1 = a1 | 0;
 FUNCTION_TABLE_vi[index & 15](a1 | 0);
}
function b1(p0, p1, p2) {
 p0 = p0 | 0;
 p1 = p1 | 0;
 p2 = p2 | 0;
 abort(1);
 return 0;
}
function b5(p0, p1, p2) {
 p0 = p0 | 0;
 p1 = p1 | 0;
 p2 = p2 | 0;
 abort(5);
}
function _bf_read_onerror($opaque) {
 $opaque = $opaque | 0;
 _abort();
}
function setTempRet0(value) {
 value = value | 0;
 tempRet0 = value;
}
function stackRestore(top) {
 top = top | 0;
 STACKTOP = top;
}
function b3(p0, p1) {
 p0 = p0 | 0;
 p1 = p1 | 0;
 abort(3);
}
function b4(p0) {
 p0 = p0 | 0;
 abort(4);
 return 0;
}
function getTempRet0() {
 return tempRet0 | 0;
}
function stackSave() {
 return STACKTOP | 0;
}
function b2(p0) {
 p0 = p0 | 0;
 abort(2);
}

// EMSCRIPTEN_END_FUNCS
  var FUNCTION_TABLE_iiiiiiii = [b0,_bf_read_async,_bf_write_async,b0];
  var FUNCTION_TABLE_iiii = [b1,_sn_write,_console_read,b1];
  var FUNCTION_TABLE_vi = [b2,_load_image_onerror,_riscv_machine_run,_bf_read_onerror,_ide_identify_cb,_ide_sector_write_cb1,_ide_transfer_stop,_ide_sector_read_cb,_ide_sector_write_cb2,_ide_sector_read,_ide_sector_read_cb_end,b2,b2,b2,b2,b2];
  var FUNCTION_TABLE_vii = [b3,_ide_set_irq];
  var FUNCTION_TABLE_ii = [b4,_bf_get_sector_count];
  var FUNCTION_TABLE_viii = [b5,_console_write,_load_image_onload,_bf_read_onload];
  var FUNCTION_TABLE_iiiii = [b6,_rtc_read,_plic_read,_htif_read,_ide_read,b6,b6,b6];
  var FUNCTION_TABLE_viiiiii = [b7,_rtc_write,_plic_write,_htif_write,_ide_write,b7,b7,b7];

    return { _i64Subtract: _i64Subtract, _free: _free, _main: _main, _i64Add: _i64Add, _bitshift64Ashr: _bitshift64Ashr, _memset: _memset, _malloc: _malloc, _memcpy: _memcpy, _strlen: _strlen, _llvm_ctlz_i32: _llvm_ctlz_i32, _bitshift64Lshr: _bitshift64Lshr, _console_queue_char: _console_queue_char, _bitshift64Shl: _bitshift64Shl, runPostSets: runPostSets, stackAlloc: stackAlloc, stackSave: stackSave, stackRestore: stackRestore, setThrew: setThrew, setTempRet0: setTempRet0, getTempRet0: getTempRet0, dynCall_iiiiiiii: dynCall_iiiiiiii, dynCall_iiii: dynCall_iiii, dynCall_vi: dynCall_vi, dynCall_vii: dynCall_vii, dynCall_ii: dynCall_ii, dynCall_viii: dynCall_viii, dynCall_iiiii: dynCall_iiiii, dynCall_viiiiii: dynCall_viiiiii };
  })
  // EMSCRIPTEN_END_ASM
  (Module.asmGlobalArg, Module.asmLibraryArg, buffer);
  var _i64Subtract = Module["_i64Subtract"] = asm["_i64Subtract"];
var _free = Module["_free"] = asm["_free"];
var _main = Module["_main"] = asm["_main"];
var _i64Add = Module["_i64Add"] = asm["_i64Add"];
var _bitshift64Ashr = Module["_bitshift64Ashr"] = asm["_bitshift64Ashr"];
var _memset = Module["_memset"] = asm["_memset"];
var _malloc = Module["_malloc"] = asm["_malloc"];
var _memcpy = Module["_memcpy"] = asm["_memcpy"];
var _strlen = Module["_strlen"] = asm["_strlen"];
var _llvm_ctlz_i32 = Module["_llvm_ctlz_i32"] = asm["_llvm_ctlz_i32"];
var _bitshift64Lshr = Module["_bitshift64Lshr"] = asm["_bitshift64Lshr"];
var _console_queue_char = Module["_console_queue_char"] = asm["_console_queue_char"];
var _bitshift64Shl = Module["_bitshift64Shl"] = asm["_bitshift64Shl"];
var runPostSets = Module["runPostSets"] = asm["runPostSets"];
var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = asm["dynCall_iiiiiiii"];
var dynCall_iiii = Module["dynCall_iiii"] = asm["dynCall_iiii"];
var dynCall_vi = Module["dynCall_vi"] = asm["dynCall_vi"];
var dynCall_vii = Module["dynCall_vii"] = asm["dynCall_vii"];
var dynCall_ii = Module["dynCall_ii"] = asm["dynCall_ii"];
var dynCall_viii = Module["dynCall_viii"] = asm["dynCall_viii"];
var dynCall_iiiii = Module["dynCall_iiiii"] = asm["dynCall_iiiii"];
var dynCall_viiiiii = Module["dynCall_viiiiii"] = asm["dynCall_viiiiii"];
  
  Runtime.stackAlloc = asm['stackAlloc'];
  Runtime.stackSave = asm['stackSave'];
  Runtime.stackRestore = asm['stackRestore'];
  Runtime.setTempRet0 = asm['setTempRet0'];
  Runtime.getTempRet0 = asm['getTempRet0'];
  

var i64Math = null;

// === Auto-generated postamble setup entry stuff ===

if (memoryInitializer) {
  if (typeof Module['locateFile'] === 'function') {
    memoryInitializer = Module['locateFile'](memoryInitializer);
  } else if (Module['memoryInitializerPrefixURL']) {
    memoryInitializer = Module['memoryInitializerPrefixURL'] + memoryInitializer;
  }
  if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
    var data = Module['readBinary'](memoryInitializer);
    HEAPU8.set(data, STATIC_BASE);
  } else {
    addRunDependency('memory initializer');
    Browser.asyncLoad(memoryInitializer, function(data) {
      HEAPU8.set(data, STATIC_BASE);
      removeRunDependency('memory initializer');
    }, function(data) {
      throw 'could not load memory initializer ' + memoryInitializer;
    });
  }
}

function ExitStatus(status) {
  this.name = "ExitStatus";
  this.message = "Program terminated with exit(" + status + ")";
  this.status = status;
};
ExitStatus.prototype = new Error();
ExitStatus.prototype.constructor = ExitStatus;

var initialStackTop;
var preloadStartTime = null;
var calledMain = false;

dependenciesFulfilled = function runCaller() {
  // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
  if (!Module['calledRun'] && shouldRunNow) run();
  if (!Module['calledRun']) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
}

Module['callMain'] = Module.callMain = function callMain(args) {
  assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on __ATMAIN__)');
  assert(__ATPRERUN__.length == 0, 'cannot call main when preRun functions remain to be called');

  args = args || [];

  ensureInitRuntime();

  var argc = args.length+1;
  function pad() {
    for (var i = 0; i < 4-1; i++) {
      argv.push(0);
    }
  }
  var argv = [allocate(intArrayFromString(Module['thisProgram']), 'i8', ALLOC_NORMAL) ];
  pad();
  for (var i = 0; i < argc-1; i = i + 1) {
    argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL));
    pad();
  }
  argv.push(0);
  argv = allocate(argv, 'i32', ALLOC_NORMAL);

  initialStackTop = STACKTOP;

  try {

    var ret = Module['_main'](argc, argv, 0);


    // if we're not running an evented main loop, it's time to exit
    exit(ret);
  }
  catch(e) {
    if (e instanceof ExitStatus) {
      // exit() throws this once it's done to make sure execution
      // has been stopped completely
      return;
    } else if (e == 'SimulateInfiniteLoop') {
      // running an evented main loop, don't immediately exit
      Module['noExitRuntime'] = true;
      return;
    } else {
      if (e && typeof e === 'object' && e.stack) Module.printErr('exception thrown: ' + [e, e.stack]);
      throw e;
    }
  } finally {
    calledMain = true;
  }
}




function run(args) {
  args = args || Module['arguments'];

  if (preloadStartTime === null) preloadStartTime = Date.now();

  if (runDependencies > 0) {
    return;
  }

  preRun();

  if (runDependencies > 0) return; // a preRun added a dependency, run will be called later
  if (Module['calledRun']) return; // run may have just been called through dependencies being fulfilled just in this very frame

  function doRun() {
    if (Module['calledRun']) return; // run may have just been called while the async setStatus time below was happening
    Module['calledRun'] = true;

    if (ABORT) return; 

    ensureInitRuntime();

    preMain();

    if (ENVIRONMENT_IS_WEB && preloadStartTime !== null) {
      Module.printErr('pre-main prep time: ' + (Date.now() - preloadStartTime) + ' ms');
    }

    if (Module['_main'] && shouldRunNow) {
      Module['callMain'](args);
    }

    postRun();
  }

  if (Module['setStatus']) {
    Module['setStatus']('Running...');
    setTimeout(function() {
      setTimeout(function() {
        Module['setStatus']('');
      }, 1);
      doRun();
    }, 1);
  } else {
    doRun();
  }
}
Module['run'] = Module.run = run;

function exit(status) {
  if (Module['noExitRuntime']) {
    return;
  }

  ABORT = true;
  EXITSTATUS = status;
  STACKTOP = initialStackTop;

  // exit the runtime
  exitRuntime();

  if (ENVIRONMENT_IS_NODE) {
    // Work around a node.js bug where stdout buffer is not flushed at process exit:
    // Instead of process.exit() directly, wait for stdout flush event.
    // See https://github.com/joyent/node/issues/1669 and https://github.com/kripken/emscripten/issues/2582
    // Workaround is based on https://github.com/RReverser/acorn/commit/50ab143cecc9ed71a2d66f78b4aec3bb2e9844f6
    process['stdout']['once']('drain', function () {
      process['exit'](status);
    });
    console.log(' '); // Make sure to print something to force the drain event to occur, in case the stdout buffer was empty.
    // Work around another node bug where sometimes 'drain' is never fired - make another effort
    // to emit the exit status, after a significant delay (if node hasn't fired drain by then, give up)
    setTimeout(function() {
      process['exit'](status);
    }, 500);
  } else
  if (ENVIRONMENT_IS_SHELL && typeof quit === 'function') {
    quit(status);
  }
  // if we reach here, we must throw an exception to halt the current execution
  throw new ExitStatus(status);
}
Module['exit'] = Module.exit = exit;

function abort(text) {
  if (text) {
    Module.print(text);
    Module.printErr(text);
  }

  ABORT = true;
  EXITSTATUS = 1;

  var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.';

  throw 'abort() at ' + stackTrace() + extra;
}
Module['abort'] = Module.abort = abort;

// {{PRE_RUN_ADDITIONS}}

if (Module['preInit']) {
  if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];
  while (Module['preInit'].length > 0) {
    Module['preInit'].pop()();
  }
}

// shouldRunNow refers to calling main(), not run().
var shouldRunNow = true;
if (Module['noInitialRun']) {
  shouldRunNow = false;
}

Module["noExitRuntime"] = true;

run();

// {{POST_RUN_ADDITIONS}}






// {{MODULE_ADDITIONS}}