// Relooper, (C) 2012 Alon Zakai, MIT license, https://github.com/kripken/Relooper
var Relooper = (function() {
// Note: For maximum-speed code, see "Optimizing Code" on the Emscripten wiki, https://github.com/kripken/emscripten/wiki/Optimizing-Code
// Note: Some Emscripten settings may limit the speed of the generated code.
try {
  this['Module'] = Module;
} catch(e) {
  this['Module'] = Module = {};
}

// The environment setup code below is customized to use Module.
// *** Environment setup code ***
var ENVIRONMENT_IS_NODE = typeof process === 'object' && 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
  Module['print'] = function(x) {
    process['stdout'].write(x + '\n');
  };
  Module['printErr'] = function(x) {
    process['stderr'].write(x + '\n');
  };

  var nodeFS = require('fs');
  var nodePath = require('path');

  Module['read'] = function(filename) {
    filename = nodePath['normalize'](filename);
    var ret = nodeFS['readFileSync'](filename).toString();
    // The path is absolute if the normalized version is the same as the resolved.
    if (!ret && filename != nodePath['resolve'](filename)) {
      filename = path.join(__dirname, '..', 'src', filename);
      ret = nodeFS['readFileSync'](filename).toString();
    }
    return ret;
  };

  Module['load'] = function(f) {
    globalEval(read(f));
  };

  if (!Module['arguments']) {
    Module['arguments'] = process['argv'].slice(2);
  }
}

if (ENVIRONMENT_IS_SHELL) {
  Module['print'] = print;
  if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm

  // Polyfill over SpiderMonkey/V8 differences
  if (typeof read != 'undefined') {
    Module['read'] = read;
  } else {
    Module['read'] = function(f) { snarf(f) };
  }

  if (!Module['arguments']) {
    if (typeof scriptArgs != 'undefined') {
      Module['arguments'] = scriptArgs;
    } else if (typeof arguments != 'undefined') {
      Module['arguments'] = arguments;
    }
  }
}

if (ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER) {
  if (!Module['print']) {
    Module['print'] = function(x) {
      console.log(x);
    };
  }

  if (!Module['printErr']) {
    Module['printErr'] = function(x) {
      console.log(x);
    };
  }
}

if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
  Module['read'] = function(url) {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', url, false);
    xhr.send(null);
    return xhr.responseText;
  };

  if (!Module['arguments']) {
    if (typeof arguments != 'undefined') {
      Module['arguments'] = arguments;
    }
  }
}

if (ENVIRONMENT_IS_WORKER) {
  // We can do very little here...
  var TRY_USE_DUMP = false;
  if (!Module['print']) {
    Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {
      dump(x);
    }) : (function(x) {
      // self.postMessage(x); // enable this if you want stdout to be sent as messages
    }));
  }

  Module['load'] = importScripts;
}

if (!ENVIRONMENT_IS_WORKER && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_SHELL) {
  // Unreachable because SHELL is dependant on the others
  throw 'Unknown runtime environment. Where are we?';
}

function globalEval(x) {
  eval.call(null, x);
}
if (!Module['load'] == 'undefined' && Module['read']) {
  Module['load'] = function(f) {
    globalEval(Module['read'](f));
  };
}
if (!Module['print']) {
  Module['print'] = function(){};
}
if (!Module['printErr']) {
  Module['printErr'] = Module['print'];
}
if (!Module['arguments']) {
  Module['arguments'] = [];
}
// *** Environment setup code ***

// Closure helpers
Module.print = Module['print'];
Module.printErr = Module['printErr'];

// Callbacks
if (!Module['preRun']) Module['preRun'] = [];
if (!Module['postRun']) Module['postRun'] = [];

  
// === Auto-generated preamble library stuff ===

//========================================
// Runtime code shared with compiler
//========================================

var Runtime = {
  stackSave: function () {
    return STACKTOP;
  },
  stackRestore: function (stackTop) {
    STACKTOP = stackTop;
  },
  forceAlign: function (target, quantum) {
    quantum = quantum || 4;
    if (quantum == 1) return target;
    if (isNumber(target) && isNumber(quantum)) {
      return Math.ceil(target/quantum)*quantum;
    } else if (isNumber(quantum) && isPowerOfTwo(quantum)) {
      var logg = log2(quantum);
      return '((((' +target + ')+' + (quantum-1) + ')>>' + logg + ')<<' + logg + ')';
    }
    return 'Math.ceil((' + target + ')/' + quantum + ')*' + quantum;
  },
  isNumberType: function (type) {
    return type in Runtime.INT_TYPES || type in Runtime.FLOAT_TYPES;
  },
  isPointerType: function isPointerType(type) {
  return type[type.length-1] == '*';
},
  isStructType: function isStructType(type) {
  if (isPointerType(type)) return false;
  if (/^\[\d+\ x\ (.*)\]/.test(type)) return true; // [15 x ?] blocks. Like structs
  if (/<?{ ?[^}]* ?}>?/.test(type)) return true; // { i32, i8 } etc. - anonymous struct types
  // See comment in isStructPointerType()
  return type[0] == '%';
},
  INT_TYPES: {"i1":0,"i8":0,"i16":0,"i32":0,"i64":0},
  FLOAT_TYPES: {"float":0,"double":0},
  BITSHIFT64_SHL: 0,
  BITSHIFT64_ASHR: 1,
  BITSHIFT64_LSHR: 2,
  bitshift64: function (low, high, op, bits) {
    var ret;
    var ander = Math.pow(2, bits)-1;
    if (bits < 32) {
      switch (op) {
        case Runtime.BITSHIFT64_SHL:
          ret = [low << bits, (high << bits) | ((low&(ander << (32 - bits))) >>> (32 - bits))];
          break;
        case Runtime.BITSHIFT64_ASHR:
          ret = [(((low >>> bits ) | ((high&ander) << (32 - bits))) >> 0) >>> 0, (high >> bits) >>> 0];
          break;
        case Runtime.BITSHIFT64_LSHR:
          ret = [((low >>> bits) | ((high&ander) << (32 - bits))) >>> 0, high >>> bits];
          break;
      }
    } else if (bits == 32) {
      switch (op) {
        case Runtime.BITSHIFT64_SHL:
          ret = [0, low];
          break;
        case Runtime.BITSHIFT64_ASHR:
          ret = [high, (high|0) < 0 ? ander : 0];
          break;
        case Runtime.BITSHIFT64_LSHR:
          ret = [high, 0];
          break;
      }
    } else { // bits > 32
      switch (op) {
        case Runtime.BITSHIFT64_SHL:
          ret = [0, low << (bits - 32)];
          break;
        case Runtime.BITSHIFT64_ASHR:
          ret = [(high >> (bits - 32)) >>> 0, (high|0) < 0 ? ander : 0];
          break;
        case Runtime.BITSHIFT64_LSHR:
          ret = [high >>>  (bits - 32) , 0];
          break;
      }
    }
    HEAP32[tempDoublePtr>>2] = ret[0]; // cannot use utility functions since we are in runtime itself
    HEAP32[tempDoublePtr+4>>2] = ret[1];
  },
  or64: function (x, y) {
    var l = (x | 0) | (y | 0);
    var h = (Math.round(x / 4294967296) | Math.round(y / 4294967296)) * 4294967296;
    return l + h;
  },
  and64: function (x, y) {
    var l = (x | 0) & (y | 0);
    var h = (Math.round(x / 4294967296) & Math.round(y / 4294967296)) * 4294967296;
    return l + h;
  },
  xor64: function (x, y) {
    var l = (x | 0) ^ (y | 0);
    var h = (Math.round(x / 4294967296) ^ Math.round(y / 4294967296)) * 4294967296;
    return l + h;
  },
  getNativeTypeSize: function (type, quantumSize) {
    if (Runtime.QUANTUM_SIZE == 1) return 1;
    var size = {
      '%i1': 1,
      '%i8': 1,
      '%i16': 2,
      '%i32': 4,
      '%i64': 8,
      "%float": 4,
      "%double": 8
    }['%'+type]; // add '%' since float and double confuse Closure compiler as keys, and also spidermonkey as a compiler will remove 's from '_i8' etc
    if (!size) {
      if (type.charAt(type.length-1) == '*') {
        size = Runtime.QUANTUM_SIZE; // A pointer
      } else if (type[0] == 'i') {
        var bits = parseInt(type.substr(1));
        assert(bits % 8 == 0);
        size = bits/8;
      }
    }
    return size;
  },
  getNativeFieldSize: function (type) {
    return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE);
  },
  dedup: function dedup(items, ident) {
  var seen = {};
  if (ident) {
    return items.filter(function(item) {
      if (seen[item[ident]]) return false;
      seen[item[ident]] = true;
      return true;
    });
  } else {
    return items.filter(function(item) {
      if (seen[item]) return false;
      seen[item] = true;
      return true;
    });
  }
},
  set: function set() {
  var args = typeof arguments[0] === 'object' ? arguments[0] : arguments;
  var ret = {};
  for (var i = 0; i < args.length; i++) {
    ret[args[i]] = 0;
  }
  return ret;
},
  calculateStructAlignment: function calculateStructAlignment(type) {
    type.flatSize = 0;
    type.alignSize = 0;
    var diffs = [];
    var prev = -1;
    type.flatIndexes = type.fields.map(function(field) {
      var size, alignSize;
      if (Runtime.isNumberType(field) || Runtime.isPointerType(field)) {
        size = Runtime.getNativeTypeSize(field); // pack char; char; in structs, also char[X]s.
        alignSize = size;
      } else if (Runtime.isStructType(field)) {
        size = Types.types[field].flatSize;
        alignSize = Types.types[field].alignSize;
      } else if (field[0] == 'b') {
        // bN, large number field, like a [N x i8]
        size = field.substr(1)|0;
        alignSize = 1;
      } else {
        throw 'Unclear type in struct: ' + field + ', in ' + type.name_ + ' :: ' + dump(Types.types[type.name_]);
      }
      alignSize = type.packed ? 1 : Math.min(alignSize, Runtime.QUANTUM_SIZE);
      type.alignSize = Math.max(type.alignSize, alignSize);
      var curr = Runtime.alignMemory(type.flatSize, alignSize); // if necessary, place this on aligned memory
      type.flatSize = curr + size;
      if (prev >= 0) {
        diffs.push(curr-prev);
      }
      prev = curr;
      return curr;
    });
    type.flatSize = Runtime.alignMemory(type.flatSize, type.alignSize);
    if (diffs.length == 0) {
      type.flatFactor = type.flatSize;
    } else if (Runtime.dedup(diffs).length == 1) {
      type.flatFactor = diffs[0];
    }
    type.needsFlattening = (type.flatFactor != 1);
    return type.flatIndexes;
  },
  generateStructInfo: function (struct, typeName, offset) {
    var type, alignment;
    if (typeName) {
      offset = offset || 0;
      type = (typeof Types === 'undefined' ? Runtime.typeInfo : Types.types)[typeName];
      if (!type) return null;
      if (type.fields.length != struct.length) {
        printErr('Number of named fields must match the type for ' + typeName + ': possibly duplicate struct names. Cannot return structInfo');
        return null;
      }
      alignment = type.flatIndexes;
    } else {
      var type = { fields: struct.map(function(item) { return item[0] }) };
      alignment = Runtime.calculateStructAlignment(type);
    }
    var ret = {
      __size__: type.flatSize
    };
    if (typeName) {
      struct.forEach(function(item, i) {
        if (typeof item === 'string') {
          ret[item] = alignment[i] + offset;
        } else {
          // embedded struct
          var key;
          for (var k in item) key = k;
          ret[key] = Runtime.generateStructInfo(item[key], type.fields[i], alignment[i]);
        }
      });
    } else {
      struct.forEach(function(item, i) {
        ret[item[1]] = alignment[i];
      });
    }
    return ret;
  },
  dynCall: function (sig, ptr, args) {
    if (args && args.length) {
      return FUNCTION_TABLE[ptr].apply(null, args);
    } else {
      return FUNCTION_TABLE[ptr]();
    }
  },
  addFunction: function (func, sig) {
    //assert(sig); // TODO: support asm
    var table = FUNCTION_TABLE; // TODO: support asm
    var ret = table.length;
    table.push(func);
    table.push(0);
    return ret;
  },
  warnOnce: function (text) {
    if (!Runtime.warnOnce.shown) Runtime.warnOnce.shown = {};
    if (!Runtime.warnOnce.shown[text]) {
      Runtime.warnOnce.shown[text] = 1;
      Module.printErr(text);
    }
  },
  funcWrappers: {},
  getFuncWrapper: function (func, sig) {
    assert(sig);
    if (!Runtime.funcWrappers[func]) {
      Runtime.funcWrappers[func] = function() {
        Runtime.dynCall(sig, func, arguments);
      };
    }
    return Runtime.funcWrappers[func];
  },
  UTF8Processor: function () {
    var buffer = [];
    var needed = 0;
    this.processCChar = function (code) {
      code = code & 0xff;
      if (needed) {
        buffer.push(code);
        needed--;
      }
      if (buffer.length == 0) {
        if (code < 128) return String.fromCharCode(code);
        buffer.push(code);
        if (code > 191 && code < 224) {
          needed = 1;
        } else {
          needed = 2;
        }
        return '';
      }
      if (needed > 0) return '';
      var c1 = buffer[0];
      var c2 = buffer[1];
      var c3 = buffer[2];
      var ret;
      if (c1 > 191 && c1 < 224) {
        ret = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));
      } else {
        ret = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
      }
      buffer.length = 0;
      return ret;
    }
    this.processJSString = function(string) {
      string = unescape(encodeURIComponent(string));
      var ret = [];
      for (var i = 0; i < string.length; i++) {
        ret.push(string.charCodeAt(i));
      }
      return ret;
    }
  },
  stackAlloc: function stackAlloc(size) { var ret = STACKTOP;STACKTOP = (STACKTOP + size)|0;STACKTOP = ((((STACKTOP)+3)>>2)<<2); return ret; },
  staticAlloc: function staticAlloc(size) { var ret = STATICTOP;STATICTOP = (STATICTOP + size)|0;STATICTOP = ((((STATICTOP)+3)>>2)<<2); if (STATICTOP >= TOTAL_MEMORY) enlargeMemory();; return ret; },
  alignMemory: function alignMemory(size,quantum) { var ret = size = Math.ceil((size)/(quantum ? quantum : 4))*(quantum ? quantum : 4); return ret; },
  makeBigInt: function makeBigInt(low,high,unsigned) { var ret = (unsigned ? (((low)>>>0)+(((high)>>>0)*4294967296)) : (((low)>>>0)+(((high)|0)*4294967296))); return ret; },
  QUANTUM_SIZE: 4,
  __dummy__: 0
}







//========================================
// Runtime essentials
//========================================

var __THREW__ = 0; // Used in checking for thrown exceptions.
var setjmpId = 1; // Used in setjmp/longjmp
var setjmpLabels = {};

var ABORT = false;

var undef = 0;
// tempInt is used for 32-bit signed values or smaller. tempBigInt is used
// for 32-bit unsigned values or more than 32 bits. TODO: audit all uses of tempInt
var tempValue, tempInt, tempBigInt, tempInt2, tempBigInt2, tempPair, tempBigIntI, tempBigIntR, tempBigIntS, tempBigIntP, tempBigIntD;
var tempI64, tempI64b;
var tempRet0, tempRet1, tempRet2, tempRet3, tempRet4, tempRet5, tempRet6, tempRet7, tempRet8, tempRet9;

function abort(text) {
  Module.print(text + ':\n' + (new Error).stack);
  ABORT = true;
  throw "Assertion: " + text;
}

function assert(condition, text) {
  if (!condition) {
    abort('Assertion failed: ' + text);
  }
}

var globalScope = this;

// C calling interface. A convenient way to call C functions (in C files, or
// defined with extern "C").
//
// Note: LLVM optimizations can inline and remove functions, after which you will not be
//       able to call them. Closure can also do so. To avoid that, add your function to
//       the exports using something like
//
//         -s EXPORTED_FUNCTIONS='["_main", "_myfunc"]'
//
// @param ident      The name of the C function (note that C++ functions will be name-mangled - use extern "C")
// @param returnType The return type of the function, one of the JS types 'number', 'string' or 'array' (use 'number' for any C pointer, and
//                   'array' for JavaScript arrays and typed arrays).
// @param argTypes   An array of the types of arguments for the function (if there are no arguments, this can be ommitted). Types are as in returnType,
//                   except that 'array' is not possible (there is no way for us to know the length of the array)
// @param args       An array of the arguments to the function, as native JS values (as in returnType)
//                   Note that string arguments will be stored on the stack (the JS string will become a C string on the stack).
// @return           The return value, as a native JS value (as in returnType)
function ccall(ident, returnType, argTypes, args) {
  return ccallFunc(getCFunc(ident), returnType, argTypes, args);
}
Module["ccall"] = ccall;

// Returns the C function with a specified identifier (for C++, you need to do manual name mangling)
function getCFunc(ident) {
  try {
    var func = eval('_' + ident);
  } catch(e) {
    try {
      func = globalScope['Module']['_' + ident]; // closure exported function
    } catch(e) {}
  }
  assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)');
  return func;
}

// Internal function that does a C call using a function, not an identifier
function ccallFunc(func, returnType, argTypes, args) {
  var stack = 0;
  function toC(value, type) {
    if (type == 'string') {
      if (value === null || value === undefined || value === 0) return 0; // null string
      if (!stack) stack = Runtime.stackSave();
      var ret = Runtime.stackAlloc(value.length+1);
      writeStringToMemory(value, ret);
      return ret;
    } else if (type == 'array') {
      if (!stack) stack = Runtime.stackSave();
      var ret = Runtime.stackAlloc(value.length);
      writeArrayToMemory(value, ret);
      return ret;
    }
    return value;
  }
  function fromC(value, type) {
    if (type == 'string') {
      return Pointer_stringify(value);
    }
    assert(type != 'array');
    return value;
  }
  var i = 0;
  var cArgs = args ? args.map(function(arg) {
    return toC(arg, argTypes[i++]);
  }) : [];
  var ret = fromC(func.apply(null, cArgs), returnType);
  if (stack) Runtime.stackRestore(stack);
  return ret;
}

// Returns a native JS wrapper for a C function. This is similar to ccall, but
// returns a function you can call repeatedly in a normal way. For example:
//
//   var my_function = cwrap('my_c_function', 'number', ['number', 'number']);
//   alert(my_function(5, 22));
//   alert(my_function(99, 12));
//
function cwrap(ident, returnType, argTypes) {
  var func = getCFunc(ident);
  return function() {
    return ccallFunc(func, returnType, argTypes, Array.prototype.slice.call(arguments));
  }
}
Module["cwrap"] = cwrap;

// Sets a value in memory in a dynamic way at run-time. Uses the
// type data. This is the same as makeSetValue, except that
// makeSetValue is done at compile-time and generates the needed
// code then, whereas this function picks the right code at
// run-time.
// Note that setValue and getValue only do *aligned* writes and reads!
// Note that ccall uses JS types as for defining types, while setValue and
// getValue need LLVM types ('i8', 'i32') - this is a lower-level operation
function setValue(ptr, value, type, noSafe) {
  type = type || 'i8';
  if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
    switch(type) {
      case 'i1': HEAP8[(ptr)]=value; break;
      case 'i8': HEAP8[(ptr)]=value; break;
      case 'i16': HEAP16[((ptr)>>1)]=value; break;
      case 'i32': HEAP32[((ptr)>>2)]=value; break;
      case 'i64': (tempI64 = [value>>>0,Math.min(Math.floor((value)/4294967296), 4294967295)>>>0],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break;
      case 'float': HEAPF32[((ptr)>>2)]=value; break;
      case 'double': (HEAPF64[(tempDoublePtr)>>3]=value,HEAP32[((ptr)>>2)]=HEAP32[((tempDoublePtr)>>2)],HEAP32[(((ptr)+(4))>>2)]=HEAP32[(((tempDoublePtr)+(4))>>2)]); break;
      default: abort('invalid type for setValue: ' + type);
    }
}
Module['setValue'] = setValue;

// Parallel to setValue.
function getValue(ptr, type, noSafe) {
  type = type || 'i8';
  if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit
    switch(type) {
      case 'i1': return HEAP8[(ptr)];
      case 'i8': return HEAP8[(ptr)];
      case 'i16': return HEAP16[((ptr)>>1)];
      case 'i32': return HEAP32[((ptr)>>2)];
      case 'i64': return HEAP32[((ptr)>>2)];
      case 'float': return HEAPF32[((ptr)>>2)];
      case 'double': return (HEAP32[((tempDoublePtr)>>2)]=HEAP32[((ptr)>>2)],HEAP32[(((tempDoublePtr)+(4))>>2)]=HEAP32[(((ptr)+(4))>>2)],HEAPF64[(tempDoublePtr)>>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_NONE = 3; // Do not allocate
Module['ALLOC_NORMAL'] = ALLOC_NORMAL;
Module['ALLOC_STACK'] = ALLOC_STACK;
Module['ALLOC_STATIC'] = ALLOC_STATIC;
Module['ALLOC_NONE'] = ALLOC_NONE;

// Simple unoptimized memset - necessary during startup
var _memset = function(ptr, value, num) {
  var stop = ptr + num;
  while (ptr < stop) {
    HEAP8[(ptr++)]=value;
  }
}

// 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][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length));
  }

  if (zeroinit) {
    _memset(ret, 0, size);
    return ret;
  }

  if (singleType === 'i8') {
    HEAPU8.set(new Uint8Array(slab), ret);
    return ret;
  }

  var i = 0, type;
  while (i < size) {
    var curr = slab[i];

    if (typeof curr === 'function') {
      curr = Runtime.getFunctionIndex(curr);
    }

    type = singleType || types[i];
    if (type === 0) {
      i++;
      continue;
    }

    if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later

    setValue(ret+i, curr, type);
    i += Runtime.getNativeTypeSize(type);
  }

  return ret;
}
Module['allocate'] = allocate;

function Pointer_stringify(ptr, /* optional */ length) {
  var utf8 = new Runtime.UTF8Processor();
  var nullTerminated = typeof(length) == "undefined";
  var ret = "";
  var i = 0;
  var t;
  while (1) {
    t = HEAPU8[((ptr)+(i))];
    if (nullTerminated && t == 0) break;
    ret += utf8.processCChar(t);
    i += 1;
    if (!nullTerminated && i == length) break;
  }
  return ret;
}
Module['Pointer_stringify'] = Pointer_stringify;

function Array_stringify(array) {
  var ret = "";
  for (var i = 0; i < array.length; i++) {
    ret += String.fromCharCode(array[i]);
  }
  return ret;
}
Module['Array_stringify'] = Array_stringify;

// Memory management

var PAGE_SIZE = 4096;
function alignMemoryPage(x) {
  return ((x+4095)>>12)<<12;
}

var HEAP;
var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;

var STACK_ROOT, STACKTOP, STACK_MAX;
var STATICTOP;
function enlargeMemory() {
  abort('Cannot enlarge memory arrays. Either (1) compile with -s TOTAL_MEMORY=X with X higher than the current value, (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'] || 52428800;
var FAST_MEMORY = Module['FAST_MEMORY'] || 2097152;

// Initialize the runtime's memory
// check for full engine support (use string 'subarray' to avoid closure compiler confusion)
assert(!!Int32Array && !!Float64Array && !!(new Int32Array(1)['subarray']) && !!(new Int32Array(1)['set']),
       'Cannot fallback to non-typed array case: Code is too specialized');

var buffer = new ArrayBuffer(TOTAL_MEMORY);
HEAP8 = new Int8Array(buffer);
HEAP16 = new Int16Array(buffer);
HEAP32 = new Int32Array(buffer);
HEAPU8 = new Uint8Array(buffer);
HEAPU16 = new Uint16Array(buffer);
HEAPU32 = new Uint32Array(buffer);
HEAPF32 = new Float32Array(buffer);
HEAPF64 = new Float64Array(buffer);

// Endianness check (note: assumes compiler arch was little-endian)
HEAP32[0] = 255;
assert(HEAPU8[0] === 255 && HEAPU8[3] === 0, 'Typed arrays 2 must be run on a little-endian system');

Module['HEAP'] = HEAP;
Module['HEAP8'] = HEAP8;
Module['HEAP16'] = HEAP16;
Module['HEAP32'] = HEAP32;
Module['HEAPU8'] = HEAPU8;
Module['HEAPU16'] = HEAPU16;
Module['HEAPU32'] = HEAPU32;
Module['HEAPF32'] = HEAPF32;
Module['HEAPF64'] = HEAPF64;

STACK_ROOT = STACKTOP = Runtime.alignMemory(1);
STACK_MAX = TOTAL_STACK; // we lose a little stack here, but TOTAL_STACK is nice and round so use that as the max

var tempDoublePtr = Runtime.alignMemory(allocate(12, 'i8', ALLOC_STACK), 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];
}

STATICTOP = STACK_MAX;
assert(STATICTOP < TOTAL_MEMORY); // Stack must fit in TOTAL_MEMORY; allocations from here on may enlarge TOTAL_MEMORY

var nullString = allocate(intArrayFromString('(null)'), 'i8', ALLOC_STACK);

function callRuntimeCallbacks(callbacks) {
  while(callbacks.length > 0) {
    var callback = callbacks.shift();
    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 __ATINIT__ = []; // functions called during startup
var __ATMAIN__ = []; // functions called when main() is to be run
var __ATEXIT__ = []; // functions called during shutdown

function initRuntime() {
  callRuntimeCallbacks(__ATINIT__);
}
function preMain() {
  callRuntimeCallbacks(__ATMAIN__);
}
function exitRuntime() {
  callRuntimeCallbacks(__ATEXIT__);
}

// Tools

// This processes a JS string into a C-line array of numbers, 0-terminated.
// For LLVM-originating strings, see parser.js:parseLLVMString function
function intArrayFromString(stringy, dontAddNull, length /* optional */) {
  var ret = (new Runtime.UTF8Processor()).processJSString(stringy);
  if (length) {
    ret.length = length;
  }
  if (!dontAddNull) {
    ret.push(0);
  }
  return ret;
}
Module['intArrayFromString'] = intArrayFromString;

function intArrayToString(array) {
  var ret = [];
  for (var i = 0; i < array.length; i++) {
    var chr = array[i];
    if (chr > 0xFF) {
      chr &= 0xFF;
    }
    ret.push(String.fromCharCode(chr));
  }
  return ret.join('');
}
Module['intArrayToString'] = intArrayToString;

// Write a Javascript array to somewhere in the heap
function writeStringToMemory(string, buffer, dontAddNull) {
  var array = intArrayFromString(string, dontAddNull);
  var i = 0;
  while (i < array.length) {
    var chr = array[i];
    HEAP8[((buffer)+(i))]=chr
    i = i + 1;
  }
}
Module['writeStringToMemory'] = writeStringToMemory;

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

function unSign(value, bits, ignore, sig) {
  if (value >= 0) {
    return value;
  }
  return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts
                    : Math.pow(2, bits)         + value;
  // TODO: clean up previous line
}
function reSign(value, bits, ignore, sig) {
  if (value <= 0) {
    return value;
  }
  var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32
                        : Math.pow(2, bits-1);
  if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that
                                                       // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors
                                                       // TODO: In i64 mode 1, resign the two parts separately and safely
    value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts
  }
  return value;
}

// A counter of dependencies for calling run(). If we need to
// do asynchronous work before running, increment this and
// decrement it. Incrementing must happen in a place like
// PRE_RUN_ADDITIONS (used by emcc to add file preloading).
// Note that you can add dependencies in preRun, even though
// it happens right before run - run will be postponed until
// the dependencies are met.
var runDependencies = 0;
var runDependencyTracking = {};
var calledRun = false;
var runDependencyWatcher = null;
function addRunDependency(id) {
  runDependencies++;
  if (Module['monitorRunDependencies']) {
    Module['monitorRunDependencies'](runDependencies);
  }
  if (id) {
    assert(!runDependencyTracking[id]);
    runDependencyTracking[id] = 1;
    if (runDependencyWatcher === null && typeof setInterval !== 'undefined') {
      // Check for missing dependencies every few seconds
      runDependencyWatcher = setInterval(function() {
        var shown = false;
        for (var dep in runDependencyTracking) {
          if (!shown) {
            shown = true;
            Module.printErr('still waiting on run dependencies:');
          }
          Module.printErr('dependency: ' + dep);
        }
        if (shown) {
          Module.printErr('(end of list)');
        }
      }, 6000);
    }
  } else {
    Module.printErr('warning: run dependency added without ID');
  }
}
Module['addRunDependency'] = addRunDependency;
function removeRunDependency(id) {
  runDependencies--;
  if (Module['monitorRunDependencies']) {
    Module['monitorRunDependencies'](runDependencies);
  }
  if (id) {
    assert(runDependencyTracking[id]);
    delete runDependencyTracking[id];
  } else {
    Module.printErr('warning: run dependency removed without ID');
  }
  if (runDependencies == 0) {
    if (runDependencyWatcher !== null) {
      clearInterval(runDependencyWatcher);
      runDependencyWatcher = null;
    } 
    // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
    if (!calledRun && shouldRunNow) run();
  }
}
Module['removeRunDependency'] = removeRunDependency;

Module["preloadedImages"] = {}; // maps url to image data
Module["preloadedAudios"] = {}; // maps url to audio data

// === Body ===



assert(STATICTOP == STACK_MAX); assert(STACK_MAX == TOTAL_STACK);

STATICTOP += 1916;

assert(STATICTOP < TOTAL_MEMORY);



__ATINIT__ = __ATINIT__.concat([
  { func: function() { __GLOBAL__I_a() } }
]);







































var ___dso_handle;








var __ZTVN10__cxxabiv120__si_class_type_infoE;
var __ZTVN10__cxxabiv117__class_type_infoE;














var __ZTISt9type_info;
var __ZTISt9exception;

















allocate(24, "i8", ALLOC_NONE, 5242880);
allocate([33,68,101,102,97,117,108,116,84,97,114,103,101,116,0] /* !DefaultTarget\00 */, "i8", ALLOC_NONE, 5242904);
allocate([108,97,98,101,108,32,61,32,48,59,10,0] /* label = 0;\0A\00 */, "i8", ALLOC_NONE, 5242920);
allocate([66,114,97,110,99,104,101,115,79,117,116,46,102,105,110,100,40,84,97,114,103,101,116,41,32,61,61,32,66,114,97,110,99,104,101,115,79,117,116,46,101,110,100,40,41,0] /* BranchesOut.find(Tar */, "i8", ALLOC_NONE, 5242932);
allocate([114,101,108,111,111,112,101,114,47,82,101,108,111,111,112,101,114,46,99,112,112,0] /* relooper/Relooper.cp */, "i8", ALLOC_NONE, 5242980);
allocate([37,115,59,10,0] /* %s;\0A\00 */, "i8", ALLOC_NONE, 5243004);
allocate([99,111,110,116,105,110,117,101,0] /* continue\00 */, "i8", ALLOC_NONE, 5243012);
allocate([119,114,105,116,116,101,110,32,60,32,108,101,102,116,0] /* written _ left\00 */, "i8", ALLOC_NONE, 5243024);
allocate([110,101,101,100,101,100,32,60,32,108,101,102,116,0] /* needed _ left\00 */, "i8", ALLOC_NONE, 5243040);
allocate([115,116,100,58,58,98,97,100,95,97,108,108,111,99,0] /* std::bad_alloc\00 */, "i8", ALLOC_NONE, 5243056);
allocate([79,117,116,112,117,116,66,117,102,102,101,114,32,43,32,73,110,100,101,110,116,101,114,58,58,67,117,114,114,73,110,100,101,110,116,42,50,32,45,32,79,117,116,112,117,116,66,117,102,102,101,114,82,111,111,116,32,60,32,79,117,116,112,117,116,66,117,102,102,101,114,83,105,122,101,0] /* OutputBuffer + Inden */, "i8", ALLOC_NONE, 5243072);
allocate([79,117,116,112,117,116,66,117,102,102,101,114,0] /* OutputBuffer\00 */, "i8", ALLOC_NONE, 5243148);
allocate([73,110,110,101,114,66,108,111,99,107,115,46,115,105,122,101,40,41,32,62,32,48,0] /* InnerBlocks.size() _ */, "i8", ALLOC_NONE, 5243164);
allocate([76,111,111,112,83,116,97,99,107,46,115,105,122,101,40,41,32,62,32,48,0] /* LoopStack.size() _ 0 */, "i8", ALLOC_NONE, 5243188);
allocate([98,114,101,97,107,0] /* break\00 */, "i8", ALLOC_NONE, 5243212);
allocate([119,104,105,108,101,40,49,41,32,123,10,0] /* while(1) {\0A\00 */, "i8", ALLOC_NONE, 5243220);
allocate([76,37,100,58,32,119,104,105,108,101,40,49,41,32,123,10,0] /* L%d: while(1) {\0A\0 */, "i8", ALLOC_NONE, 5243232);
allocate([37,115,105,102,32,40,108,97,98,101,108,32,61,61,32,37,100,41,32,123,10,0] /* %sif (label == %d) { */, "i8", ALLOC_NONE, 5243252);
allocate([101,108,115,101,32,0] /* else \00 */, "i8", ALLOC_NONE, 5243276);
allocate([37,115,105,102,32,40,40,108,97,98,101,108,124,48,41,32,61,61,32,37,100,41,32,123,10,0] /* %sif ((label|0) == % */, "i8", ALLOC_NONE, 5243284);
allocate([125,32,119,104,105,108,101,40,48,41,59,10,0] /* } while(0);\0A\00 */, "i8", ALLOC_NONE, 5243312);
allocate([100,111,32,123,10,0] /* do {\0A\00 */, "i8", ALLOC_NONE, 5243328);
allocate([76,37,100,58,32,100,111,32,123,10,0] /* L%d: do {\0A\00 */, "i8", ALLOC_NONE, 5243336);
allocate([125,10,0] /* }\0A\00 */, "i8", ALLOC_NONE, 5243348);
allocate([125,32,101,108,115,101,32,123,10,0] /* } else {\0A\00 */, "i8", ALLOC_NONE, 5243352);
allocate([37,115,32,76,37,100,59,10,0] /* %s L%d;\0A\00 */, "i8", ALLOC_NONE, 5243364);
allocate([125,32,101,108,115,101,32,105,102,32,40,37,115,41,32,123,10,0] /* } else if (%s) {\0A\ */, "i8", ALLOC_NONE, 5243376);
allocate([105,102,32,40,37,115,41,32,123,10,0] /* if (%s) {\0A\00 */, "i8", ALLOC_NONE, 5243396);
allocate([41,0] /* )\00 */, "i8", ALLOC_NONE, 5243408);
allocate([33,40,0] /* !(\00 */, "i8", ALLOC_NONE, 5243412);
allocate([32,38,38,32,0] /*  && \00 */, "i8", ALLOC_NONE, 5243416);
allocate([125,32,101,108,115,101,32,0] /* } else \00 */, "i8", ALLOC_NONE, 5243424);
allocate(1, "i8", ALLOC_NONE, 5243432);
allocate([37,115,105,102,32,40,37,115,41,32,123,10,0] /* %sif (%s) {\0A\00 */, "i8", ALLOC_NONE, 5243436);
allocate([68,101,116,97,105,108,115,45,62,67,111,110,100,105,116,105,111,110,0] /* Details-_Condition\0 */, "i8", ALLOC_NONE, 5243452);
allocate([68,101,102,97,117,108,116,84,97,114,103,101,116,0] /* DefaultTarget\00 */, "i8", ALLOC_NONE, 5243472);
allocate([108,97,98,101,108,32,61,32,37,100,59,10,0] /* label = %d;\0A\00 */, "i8", ALLOC_NONE, 5243488);
allocate([37,115,10,0] /* %s\0A\00 */, "i8", ALLOC_NONE, 5243504);
allocate(468, "i8", ALLOC_NONE, 5243508);
allocate(12, "i8", ALLOC_NONE, 5243976);
allocate([83,104,97,112,101,32,42,82,101,108,111,111,112,101,114,58,58,67,97,108,99,117,108,97,116,101,40,66,108,111,99,107,32,42,41,58,58,65,110,97,108,121,122,101,114,58,58,77,97,107,101,76,111,111,112,40,66,108,111,99,107,83,101,116,32,38,44,32,66,108,111,99,107,83,101,116,32,38,44,32,66,108,111,99,107,83,101,116,32,38,41,0] /* Shape _Relooper::Cal */, "i8", ALLOC_NONE, 5243988);
allocate([118,111,105,100,32,82,101,108,111,111,112,101,114,58,58,67,97,108,99,117,108,97,116,101,40,66,108,111,99,107,32,42,41,58,58,80,111,115,116,79,112,116,105,109,105,122,101,114,58,58,70,105,110,100,76,97,98,101,108,101,100,76,111,111,112,115,40,83,104,97,112,101,32,42,41,0] /* void Relooper::Calcu */, "i8", ALLOC_NONE, 5244080);
allocate([118,111,105,100,32,66,108,111,99,107,58,58,82,101,110,100,101,114,40,98,111,111,108,41,0] /* void Block::Render(b */, "i8", ALLOC_NONE, 5244156);
allocate([118,111,105,100,32,66,108,111,99,107,58,58,65,100,100,66,114,97,110,99,104,84,111,40,66,108,111,99,107,32,42,44,32,99,111,110,115,116,32,99,104,97,114,32,42,44,32,99,111,110,115,116,32,99,104,97,114,32,42,41,0] /* void Block::AddBranc */, "i8", ALLOC_NONE, 5244184);
allocate([118,111,105,100,32,80,114,105,110,116,73,110,100,101,110,116,101,100,40,99,111,110,115,116,32,99,104,97,114,32,42,44,32,46,46,46,41,0] /* void PrintIndented(c */, "i8", ALLOC_NONE, 5244248);
allocate([118,111,105,100,32,80,117,116,73,110,100,101,110,116,101,100,40,99,111,110,115,116,32,99,104,97,114,32,42,41,0] /* void PutIndented(con */, "i8", ALLOC_NONE, 5244288);
allocate([0,0,0,0,244,6,80,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_NONE, 5244320);
allocate(1, "i8", ALLOC_NONE, 5244340);
__ZTVN10__cxxabiv120__si_class_type_infoE=allocate([0,0,0,0,0,7,80,0,0,0,0,0,0,0,0,0,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);
allocate(1, "i8", ALLOC_STATIC);
__ZTVN10__cxxabiv117__class_type_infoE=allocate([0,0,0,0,12,7,80,0,0,0,0,0,0,0,0,0,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);
allocate(1, "i8", ALLOC_STATIC);
allocate([0,0,0,0,36,7,80,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_NONE, 5244344);
allocate(1, "i8", ALLOC_NONE, 5244364);
allocate([0,0,0,0,48,7,80,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_NONE, 5244368);
allocate(1, "i8", ALLOC_NONE, 5244388);
allocate([0,0,0,0,56,7,80,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_NONE, 5244392);
allocate(1, "i8", ALLOC_NONE, 5244412);
allocate([0,0,0,0,68,7,80,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_NONE, 5244416);
allocate(1, "i8", ALLOC_NONE, 5244436);
allocate([0,0,0,0,80,7,80,0,0,0,0,0,0,0,0,0,0,0,0,0], "i8", ALLOC_NONE, 5244440);
allocate(1, "i8", ALLOC_NONE, 5244460);
allocate([83,116,57,98,97,100,95,97,108,108,111,99,0] /* St9bad_alloc\00 */, "i8", ALLOC_NONE, 5244464);
allocate([78,49,48,95,95,99,120,120,97,98,105,118,49,50,48,95,95,115,105,95,99,108,97,115,115,95,116,121,112,101,95,105,110,102,111,69,0] /* N10__cxxabiv120__si_ */, "i8", ALLOC_NONE, 5244480);
allocate([78,49,48,95,95,99,120,120,97,98,105,118,49,49,55,95,95,99,108,97,115,115,95,116,121,112,101,95,105,110,102,111,69,0] /* N10__cxxabiv117__cla */, "i8", ALLOC_NONE, 5244520);
allocate([78,49,48,95,95,99,120,120,97,98,105,118,49,49,54,95,95,115,104,105,109,95,116,121,112,101,95,105,110,102,111,69,0] /* N10__cxxabiv116__shi */, "i8", ALLOC_NONE, 5244556);
allocate([57,76,111,111,112,83,104,97,112,101,0] /* 9LoopShape\00 */, "i8", ALLOC_NONE, 5244592);
allocate([53,83,104,97,112,101,0] /* 5Shape\00 */, "i8", ALLOC_NONE, 5244604);
allocate([49,51,77,117,108,116,105,112,108,101,83,104,97,112,101,0] /* 13MultipleShape\00 */, "i8", ALLOC_NONE, 5244612);
allocate([49,50,76,97,98,101,108,101,100,83,104,97,112,101,0] /* 12LabeledShape\00 */, "i8", ALLOC_NONE, 5244628);
allocate([49,49,83,105,109,112,108,101,83,104,97,112,101,0] /* 11SimpleShape\00 */, "i8", ALLOC_NONE, 5244644);
allocate(12, "i8", ALLOC_NONE, 5244660);
allocate([0,0,0,0,0,0,0,0,12,7,80,0], "i8", ALLOC_NONE, 5244672);
allocate([0,0,0,0,0,0,0,0,24,7,80,0], "i8", ALLOC_NONE, 5244684);
allocate(12, "i8", ALLOC_NONE, 5244696);
allocate([0,0,0,0,0,0,0,0,68,7,80,0], "i8", ALLOC_NONE, 5244708);
allocate(8, "i8", ALLOC_NONE, 5244720);
allocate([0,0,0,0,0,0,0,0,68,7,80,0], "i8", ALLOC_NONE, 5244728);
allocate([0,0,0,0,0,0,0,0,48,7,80,0], "i8", ALLOC_NONE, 5244740);
allocate([0,0,0,0,0,0,0,0,48,7,80,0], "i8", ALLOC_NONE, 5244752);
allocate([1,0,0,0], "i8", ALLOC_NONE, 5244764);
allocate(4, "i8", ALLOC_NONE, 5244768);
allocate([1,0,0,0], "i8", ALLOC_NONE, 5244772);
allocate(4, "i8", ALLOC_NONE, 5244776);
allocate(4, "i8", ALLOC_NONE, 5244780);
allocate(4, "i8", ALLOC_NONE, 5244784);
allocate(4, "i8", ALLOC_NONE, 5244788);
allocate(4, "i8", ALLOC_NONE, 5244792);
HEAP32[((5244328)>>2)]=(42);
HEAP32[((5244332)>>2)]=(8);
HEAP32[((5244336)>>2)]=(16);
HEAP32[(((__ZTVN10__cxxabiv120__si_class_type_infoE)+(8))>>2)]=(44);
HEAP32[(((__ZTVN10__cxxabiv120__si_class_type_infoE)+(12))>>2)]=(50);
HEAP32[(((__ZTVN10__cxxabiv120__si_class_type_infoE)+(16))>>2)]=(38);
HEAP32[(((__ZTVN10__cxxabiv120__si_class_type_infoE)+(20))>>2)]=(52);
HEAP32[(((__ZTVN10__cxxabiv120__si_class_type_infoE)+(24))>>2)]=(28);
HEAP32[(((__ZTVN10__cxxabiv120__si_class_type_infoE)+(28))>>2)]=(30);
HEAP32[(((__ZTVN10__cxxabiv120__si_class_type_infoE)+(32))>>2)]=(18);
HEAP32[(((__ZTVN10__cxxabiv120__si_class_type_infoE)+(36))>>2)]=(56);
HEAP32[(((__ZTVN10__cxxabiv117__class_type_infoE)+(8))>>2)]=(10);
HEAP32[(((__ZTVN10__cxxabiv117__class_type_infoE)+(12))>>2)]=(14);
HEAP32[(((__ZTVN10__cxxabiv117__class_type_infoE)+(16))>>2)]=(38);
HEAP32[(((__ZTVN10__cxxabiv117__class_type_infoE)+(20))>>2)]=(52);
HEAP32[(((__ZTVN10__cxxabiv117__class_type_infoE)+(24))>>2)]=(28);
HEAP32[(((__ZTVN10__cxxabiv117__class_type_infoE)+(28))>>2)]=(4);
HEAP32[(((__ZTVN10__cxxabiv117__class_type_infoE)+(32))>>2)]=(32);
HEAP32[(((__ZTVN10__cxxabiv117__class_type_infoE)+(36))>>2)]=(46);
HEAP32[((5244352)>>2)]=(2);
HEAP32[((5244356)>>2)]=(26);
HEAP32[((5244360)>>2)]=(22);
HEAP32[((5244376)>>2)]=(58);
HEAP32[((5244380)>>2)]=(6);
HEAP32[((5244384)>>2)]=(60);
HEAP32[((5244400)>>2)]=(40);
HEAP32[((5244404)>>2)]=(62);
HEAP32[((5244408)>>2)]=(20);
HEAP32[((5244424)>>2)]=(48);
HEAP32[((5244428)>>2)]=(12);
HEAP32[((5244432)>>2)]=(60);
HEAP32[((5244448)>>2)]=(34);
HEAP32[((5244452)>>2)]=(36);
HEAP32[((5244456)>>2)]=(24);
HEAP32[((5244660)>>2)]=(((__ZTVN10__cxxabiv120__si_class_type_infoE+8)|0));
HEAP32[((5244664)>>2)]=((5244464)|0);
HEAP32[((5244668)>>2)]=__ZTISt9exception;
HEAP32[((5244672)>>2)]=(((__ZTVN10__cxxabiv120__si_class_type_infoE+8)|0));
HEAP32[((5244676)>>2)]=((5244480)|0);
HEAP32[((5244684)>>2)]=(((__ZTVN10__cxxabiv120__si_class_type_infoE+8)|0));
HEAP32[((5244688)>>2)]=((5244520)|0);
HEAP32[((5244696)>>2)]=(((__ZTVN10__cxxabiv120__si_class_type_infoE+8)|0));
HEAP32[((5244700)>>2)]=((5244556)|0);
HEAP32[((5244704)>>2)]=__ZTISt9type_info;
HEAP32[((5244708)>>2)]=(((__ZTVN10__cxxabiv120__si_class_type_infoE+8)|0));
HEAP32[((5244712)>>2)]=((5244592)|0);
HEAP32[((5244720)>>2)]=(((__ZTVN10__cxxabiv117__class_type_infoE+8)|0));
HEAP32[((5244724)>>2)]=((5244604)|0);
HEAP32[((5244728)>>2)]=(((__ZTVN10__cxxabiv120__si_class_type_infoE+8)|0));
HEAP32[((5244732)>>2)]=((5244612)|0);
HEAP32[((5244740)>>2)]=(((__ZTVN10__cxxabiv120__si_class_type_infoE+8)|0));
HEAP32[((5244744)>>2)]=((5244628)|0);
HEAP32[((5244752)>>2)]=(((__ZTVN10__cxxabiv120__si_class_type_infoE+8)|0));
HEAP32[((5244756)>>2)]=((5244644)|0);

  
  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 _strdup(ptr) {
      var len = _strlen(ptr);
      var newStr = _malloc(len + 1);
      _memcpy(newStr, ptr, len);
      HEAP8[((newStr)+(len))]=0;
      return newStr;
    }

  function ___gxx_personality_v0() {
    }
var __ZSt9terminatev; // stub for __ZSt9terminatev

  function ___assert_func(filename, line, func, condition) {
      throw 'Assertion failed: ' + (condition ? Pointer_stringify(condition) : 'unknown condition') + ', at: ' + [filename ? Pointer_stringify(filename) : 'unknown filename', line, func ? Pointer_stringify(func) : 'unknown function'] + ' at ' + new Error().stack;
    }

  function _strchr(ptr, chr) {
      ptr--;
      do {
        ptr++;
        var val = HEAP8[(ptr)];
        if (val == chr) return ptr;
      } while (val);
      return 0;
    }

  
  function _atexit(func, arg) {
      __ATEXIT__.unshift({ func: func, arg: arg });
    }var ___cxa_atexit;

  
  function _memcpy(dest, src, num) {
      dest = dest|0; src = src|0; num = num|0;
      var ret = 0;
      ret = dest|0;
      if ((dest&3) == (src&3)) {
        while (dest & 3) {
          if ((num|0) == 0) return ret|0;
          HEAP8[(dest)]=HEAP8[(src)];
          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)]=HEAP8[(src)];
        dest = (dest+1)|0;
        src = (src+1)|0;
        num = (num-1)|0;
      }
      return ret|0;
    }var _llvm_memcpy_p0i8_p0i8_i32;

  function ___cxa_call_unexpected(exception) {
      ABORT = true;
      throw exception;
    }

  
  function __ZSt18uncaught_exceptionv() { // std::uncaught_exception()
      return !!__ZSt18uncaught_exceptionv.uncaught_exception;
    }function ___cxa_begin_catch(ptr) {
      __ZSt18uncaught_exceptionv.uncaught_exception--;
      return ptr;
    }

  
  function _llvm_eh_exception() {
      return HEAP32[((_llvm_eh_exception.buf)>>2)];
    }
  
  
  function ___cxa_free_exception(ptr) {
      return _free(ptr);
    }function ___cxa_end_catch() {
      if (___cxa_end_catch.rethrown) {
        ___cxa_end_catch.rethrown = false;
        return;
      }
      // Clear state flag.
      __THREW__ = 0;
      // Clear type.
      HEAP32[(((_llvm_eh_exception.buf)+(4))>>2)]=0
      // Call destructor if one is registered then clear it.
      var ptr = HEAP32[((_llvm_eh_exception.buf)>>2)];
      var destructor = HEAP32[(((_llvm_eh_exception.buf)+(8))>>2)];
      if (destructor) {
        Runtime.dynCall('vi', destructor, [ptr]);
        HEAP32[(((_llvm_eh_exception.buf)+(8))>>2)]=0
      }
      // Free ptr if it isn't null.
      if (ptr) {
        ___cxa_free_exception(ptr);
        HEAP32[((_llvm_eh_exception.buf)>>2)]=0
      }
    }function ___cxa_rethrow() {
      ___cxa_end_catch.rethrown = true;
      throw HEAP32[((_llvm_eh_exception.buf)>>2)] + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch.";;
    }


  
  function _memmove(dest, src, num) {
      dest = dest|0; src = src|0; num = num|0;
      if (((src|0) < (dest|0)) & ((dest|0) < ((src + num)|0))) {
        // Unlikely case: Copy backwards in a safe manner
        src = (src + num)|0;
        dest = (dest + num)|0;
        while ((num|0) > 0) {
          dest = (dest - 1)|0;
          src = (src - 1)|0;
          num = (num - 1)|0;
          HEAP8[(dest)]=HEAP8[(src)];
        }
      } else {
        _memcpy(dest, src, num);
      }
    }var _llvm_memmove_p0i8_p0i8_i32;

  function ___cxa_pure_virtual() {
      ABORT = true;
      throw 'Pure virtual function called!';
    }


  function _strcpy(pdest, psrc) {
      var i = 0;
      do {
        HEAP8[(pdest+i)]=HEAP8[(psrc+i)];
        i ++;
      } while (HEAP8[((psrc)+(i-1))] != 0);
      return pdest;
    }
var _llvm_va_start; // stub for _llvm_va_start

  
  
  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)];
        if (curr === 0) break;
        next = HEAP8[(textIndex+1)];
        if (curr == '%'.charCodeAt(0)) {
          // Handle flags.
          var flagAlwaysSigned = false;
          var flagLeftAlign = false;
          var flagAlternative = false;
          var flagZeroPad = false;
          flagsLoop: while (1) {
            switch (next) {
              case '+'.charCodeAt(0):
                flagAlwaysSigned = true;
                break;
              case '-'.charCodeAt(0):
                flagLeftAlign = true;
                break;
              case '#'.charCodeAt(0):
                flagAlternative = true;
                break;
              case '0'.charCodeAt(0):
                if (flagZeroPad) {
                  break flagsLoop;
                } else {
                  flagZeroPad = true;
                  break;
                }
              default:
                break flagsLoop;
            }
            textIndex++;
            next = HEAP8[(textIndex+1)];
          }
  
          // Handle width.
          var width = 0;
          if (next == '*'.charCodeAt(0)) {
            width = getNextArg('i32');
            textIndex++;
            next = HEAP8[(textIndex+1)];
          } else {
            while (next >= '0'.charCodeAt(0) && next <= '9'.charCodeAt(0)) {
              width = width * 10 + (next - '0'.charCodeAt(0));
              textIndex++;
              next = HEAP8[(textIndex+1)];
            }
          }
  
          // Handle precision.
          var precisionSet = false;
          if (next == '.'.charCodeAt(0)) {
            var precision = 0;
            precisionSet = true;
            textIndex++;
            next = HEAP8[(textIndex+1)];
            if (next == '*'.charCodeAt(0)) {
              precision = getNextArg('i32');
              textIndex++;
            } else {
              while(1) {
                var precisionChr = HEAP8[(textIndex+1)];
                if (precisionChr < '0'.charCodeAt(0) ||
                    precisionChr > '9'.charCodeAt(0)) break;
                precision = precision * 10 + (precisionChr - '0'.charCodeAt(0));
                textIndex++;
              }
            }
            next = HEAP8[(textIndex+1)];
          } else {
            var precision = 6; // Standard default.
          }
  
          // Handle integer sizes. WARNING: These assume a 32-bit architecture!
          var argSize;
          switch (String.fromCharCode(next)) {
            case 'h':
              var nextNext = HEAP8[(textIndex+2)];
              if (nextNext == 'h'.charCodeAt(0)) {
                textIndex++;
                argSize = 1; // char (actually i32 in varargs)
              } else {
                argSize = 2; // short (actually i32 in varargs)
              }
              break;
            case 'l':
              var nextNext = HEAP8[(textIndex+2)];
              if (nextNext == 'l'.charCodeAt(0)) {
                textIndex++;
                argSize = 8; // long long
              } else {
                argSize = 4; // long
              }
              break;
            case 'L': // long long
            case 'q': // int64_t
            case 'j': // intmax_t
              argSize = 8;
              break;
            case 'z': // size_t
            case 't': // ptrdiff_t
            case 'I': // signed ptrdiff_t or unsigned size_t
              argSize = 4;
              break;
            default:
              argSize = null;
          }
          if (argSize) textIndex++;
          next = HEAP8[(textIndex+1)];
  
          // Handle type specifier.
          if (['d', 'i', 'u', 'o', 'x', 'X', 'p'].indexOf(String.fromCharCode(next)) != -1) {
            // Integer.
            var signed = next == 'd'.charCodeAt(0) || next == 'i'.charCodeAt(0);
            argSize = argSize || 4;
            var currArg = getNextArg('i' + (argSize * 8));
            var origArg = currArg;
            var argText;
            // Flatten i64-1 [low, high] into a (slightly rounded) double
            if (argSize == 8) {
              currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 'u'.charCodeAt(0));
            }
            // Truncate to requested size.
            if (argSize <= 4) {
              var limit = Math.pow(256, argSize) - 1;
              currArg = (signed ? reSign : unSign)(currArg & limit, argSize * 8);
            }
            // Format the number.
            var currAbsArg = Math.abs(currArg);
            var prefix = '';
            if (next == 'd'.charCodeAt(0) || next == 'i'.charCodeAt(0)) {
              if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], null); else
              argText = reSign(currArg, 8 * argSize, 1).toString(10);
            } else if (next == 'u'.charCodeAt(0)) {
              if (argSize == 8 && i64Math) argText = i64Math.stringify(origArg[0], origArg[1], true); else
              argText = unSign(currArg, 8 * argSize, 1).toString(10);
              currArg = Math.abs(currArg);
            } else if (next == 'o'.charCodeAt(0)) {
              argText = (flagAlternative ? '0' : '') + currAbsArg.toString(8);
            } else if (next == 'x'.charCodeAt(0) || next == 'X'.charCodeAt(0)) {
              prefix = flagAlternative ? '0x' : '';
              if (argSize == 8 && i64Math) argText = (origArg[1]>>>0).toString(16) + (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 == 'X'.charCodeAt(0)) {
                prefix = prefix.toUpperCase();
                argText = argText.toUpperCase();
              }
            } else if (next == 'p'.charCodeAt(0)) {
              if (currAbsArg === 0) {
                argText = '(nil)';
              } else {
                prefix = '0x';
                argText = currAbsArg.toString(16);
              }
            }
            if (precisionSet) {
              while (argText.length < precision) {
                argText = '0' + argText;
              }
            }
  
            // Add sign if needed
            if (flagAlwaysSigned) {
              if (currArg < 0) {
                prefix = '-' + prefix;
              } else {
                prefix = '+' + prefix;
              }
            }
  
            // Add padding.
            while (prefix.length + argText.length < width) {
              if (flagLeftAlign) {
                argText += ' ';
              } else {
                if (flagZeroPad) {
                  argText = '0' + argText;
                } else {
                  prefix = ' ' + prefix;
                }
              }
            }
  
            // Insert the result into the buffer.
            argText = prefix + argText;
            argText.split('').forEach(function(chr) {
              ret.push(chr.charCodeAt(0));
            });
          } else if (['f', 'F', 'e', 'E', 'g', 'G'].indexOf(String.fromCharCode(next)) != -1) {
            // Float.
            var currArg = getNextArg('double');
            var argText;
  
            if (isNaN(currArg)) {
              argText = 'nan';
              flagZeroPad = false;
            } else if (!isFinite(currArg)) {
              argText = (currArg < 0 ? '-' : '') + 'inf';
              flagZeroPad = false;
            } else {
              var isGeneral = false;
              var effectivePrecision = Math.min(precision, 20);
  
              // Convert g/G to f/F or e/E, as per:
              // http://pubs.opengroup.org/onlinepubs/9699919799/functions/printf.html
              if (next == 'g'.charCodeAt(0) || next == 'G'.charCodeAt(0)) {
                isGeneral = true;
                precision = precision || 1;
                var exponent = parseInt(currArg.toExponential(effectivePrecision).split('e')[1], 10);
                if (precision > exponent && exponent >= -4) {
                  next = ((next == 'g'.charCodeAt(0)) ? 'f' : 'F').charCodeAt(0);
                  precision -= exponent + 1;
                } else {
                  next = ((next == 'g'.charCodeAt(0)) ? 'e' : 'E').charCodeAt(0);
                  precision--;
                }
                effectivePrecision = Math.min(precision, 20);
              }
  
              if (next == 'e'.charCodeAt(0) || next == 'E'.charCodeAt(0)) {
                argText = currArg.toExponential(effectivePrecision);
                // Make sure the exponent has at least 2 digits.
                if (/[eE][-+]\d$/.test(argText)) {
                  argText = argText.slice(0, -1) + '0' + argText.slice(-1);
                }
              } else if (next == 'f'.charCodeAt(0) || next == 'F'.charCodeAt(0)) {
                argText = currArg.toFixed(effectivePrecision);
              }
  
              var parts = argText.split('e');
              if (isGeneral && !flagAlternative) {
                // Discard trailing zeros and periods.
                while (parts[0].length > 1 && parts[0].indexOf('.') != -1 &&
                       (parts[0].slice(-1) == '0' || parts[0].slice(-1) == '.')) {
                  parts[0] = parts[0].slice(0, -1);
                }
              } else {
                // Make sure we have a period in alternative mode.
                if (flagAlternative && argText.indexOf('.') == -1) parts[0] += '.';
                // Zero pad until required precision.
                while (precision > effectivePrecision++) parts[0] += '0';
              }
              argText = parts[0] + (parts.length > 1 ? 'e' + parts[1] : '');
  
              // Capitalize 'E' if needed.
              if (next == 'E'.charCodeAt(0)) argText = argText.toUpperCase();
  
              // Add sign.
              if (flagAlwaysSigned && currArg >= 0) {
                argText = '+' + argText;
              }
            }
  
            // Add padding.
            while (argText.length < width) {
              if (flagLeftAlign) {
                argText += ' ';
              } else {
                if (flagZeroPad && (argText[0] == '-' || argText[0] == '+')) {
                  argText = argText[0] + '0' + argText.slice(1);
                } else {
                  argText = (flagZeroPad ? '0' : ' ') + argText;
                }
              }
            }
  
            // Adjust case.
            if (next < 'a'.charCodeAt(0)) argText = argText.toUpperCase();
  
            // Insert the result into the buffer.
            argText.split('').forEach(function(chr) {
              ret.push(chr.charCodeAt(0));
            });
          } else if (next == 's'.charCodeAt(0)) {
            // String.
            var arg = getNextArg('i8*') || nullString;
            var argLength = _strlen(arg);
            if (precisionSet) argLength = Math.min(argLength, precision);
            if (!flagLeftAlign) {
              while (argLength < width--) {
                ret.push(' '.charCodeAt(0));
              }
            }
            for (var i = 0; i < argLength; i++) {
              ret.push(HEAPU8[(arg++)]);
            }
            if (flagLeftAlign) {
              while (argLength < width--) {
                ret.push(' '.charCodeAt(0));
              }
            }
          } else if (next == 'c'.charCodeAt(0)) {
            // Character.
            if (flagLeftAlign) ret.push(getNextArg('i8'));
            while (--width > 0) {
              ret.push(' '.charCodeAt(0));
            }
            if (!flagLeftAlign) ret.push(getNextArg('i8'));
          } else if (next == 'n'.charCodeAt(0)) {
            // Write the length written so far to the next parameter.
            var ptr = getNextArg('i32*');
            HEAP32[((ptr)>>2)]=ret.length
          } else if (next == '%'.charCodeAt(0)) {
            // Literal percent sign.
            ret.push(curr);
          } else {
            // Unknown specifiers remain untouched.
            for (var i = startTextIndex; i < textIndex + 2; i++) {
              ret.push(HEAP8[(i)]);
            }
          }
          textIndex += 2;
          // TODO: Support a/A (hex float) and m (last error) specifiers.
          // TODO: Support %1${specifier} for arg selection.
        } else {
          ret.push(curr);
          textIndex += 1;
        }
      }
      return ret;
    }function _snprintf(s, n, format, varargs) {
      // int snprintf(char *restrict s, size_t n, const char *restrict format, ...);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/printf.html
      var result = __formatString(format, varargs);
      var limit = (n === undefined) ? result.length
                                    : Math.min(result.length, Math.max(n - 1, 0));
      if (s < 0) {
        s = -s;
        var buf = _malloc(limit+1);
        HEAP32[((s)>>2)]=buf;
        s = buf;
      }
      for (var i = 0; i < limit; i++) {
        HEAP8[((s)+(i))]=result[i];
      }
      if (limit < n || (n === undefined)) HEAP8[((s)+(i))]=0;
      return result.length;
    }var _vsnprintf;

  function _llvm_va_end() {}

  var _llvm_memcpy_p0i8_p0i8_i64;

  function __ZNSt9type_infoD2Ev(){}

  
  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) {
        // This is unaligned, but quite large, so work hard to get to aligned settings
        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)) { // no need to check for stop, since we have large num
            HEAP8[(ptr)]=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)]=value;
        ptr = (ptr+1)|0;
      }
    }var _llvm_memset_p0i8_i64;

  function _abort() {
      ABORT = true;
      throw 'abort() at ' + (new Error().stack);
    }

  
  function ___setErrNo(value) {
      // For convenient setting and returning of errno.
      if (!___setErrNo.ret) ___setErrNo.ret = allocate([0], 'i32', ALLOC_STATIC);
      HEAP32[((___setErrNo.ret)>>2)]=value
      return value;
    }
  
  var ERRNO_CODES={E2BIG:7,EACCES:13,EADDRINUSE:98,EADDRNOTAVAIL:99,EAFNOSUPPORT:97,EAGAIN:11,EALREADY:114,EBADF:9,EBADMSG:74,EBUSY:16,ECANCELED:125,ECHILD:10,ECONNABORTED:103,ECONNREFUSED:111,ECONNRESET:104,EDEADLK:35,EDESTADDRREQ:89,EDOM:33,EDQUOT:122,EEXIST:17,EFAULT:14,EFBIG:27,EHOSTUNREACH:113,EIDRM:43,EILSEQ:84,EINPROGRESS:115,EINTR:4,EINVAL:22,EIO:5,EISCONN:106,EISDIR:21,ELOOP:40,EMFILE:24,EMLINK:31,EMSGSIZE:90,EMULTIHOP:72,ENAMETOOLONG:36,ENETDOWN:100,ENETRESET:102,ENETUNREACH:101,ENFILE:23,ENOBUFS:105,ENODATA:61,ENODEV:19,ENOENT:2,ENOEXEC:8,ENOLCK:37,ENOLINK:67,ENOMEM:12,ENOMSG:42,ENOPROTOOPT:92,ENOSPC:28,ENOSR:63,ENOSTR:60,ENOSYS:38,ENOTCONN:107,ENOTDIR:20,ENOTEMPTY:39,ENOTRECOVERABLE:131,ENOTSOCK:88,ENOTSUP:95,ENOTTY:25,ENXIO:6,EOVERFLOW:75,EOWNERDEAD:130,EPERM:1,EPIPE:32,EPROTO:71,EPROTONOSUPPORT:93,EPROTOTYPE:91,ERANGE:34,EROFS:30,ESPIPE:29,ESRCH:3,ESTALE:116,ETIME:62,ETIMEDOUT:110,ETXTBSY:26,EWOULDBLOCK:11,EXDEV:18};function _sysconf(name) {
      // long sysconf(int name);
      // http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html
      switch(name) {
        case 8: return PAGE_SIZE;
        case 54:
        case 56:
        case 21:
        case 61:
        case 63:
        case 22:
        case 67:
        case 23:
        case 24:
        case 25:
        case 26:
        case 27:
        case 69:
        case 28:
        case 101:
        case 70:
        case 71:
        case 29:
        case 30:
        case 199:
        case 75:
        case 76:
        case 32:
        case 43:
        case 44:
        case 80:
        case 46:
        case 47:
        case 45:
        case 48:
        case 49:
        case 42:
        case 82:
        case 33:
        case 7:
        case 108:
        case 109:
        case 107:
        case 112:
        case 119:
        case 121:
          return 200809;
        case 13:
        case 104:
        case 94:
        case 95:
        case 34:
        case 35:
        case 77:
        case 81:
        case 83:
        case 84:
        case 85:
        case 86:
        case 87:
        case 88:
        case 89:
        case 90:
        case 91:
        case 94:
        case 95:
        case 110:
        case 111:
        case 113:
        case 114:
        case 115:
        case 116:
        case 117:
        case 118:
        case 120:
        case 40:
        case 16:
        case 79:
        case 19:
          return -1;
        case 92:
        case 93:
        case 5:
        case 72:
        case 6:
        case 74:
        case 92:
        case 93:
        case 96:
        case 97:
        case 98:
        case 99:
        case 102:
        case 103:
        case 105:
          return 1;
        case 38:
        case 66:
        case 50:
        case 51:
        case 4:
          return 1024;
        case 15:
        case 64:
        case 41:
          return 32;
        case 55:
        case 37:
        case 17:
          return 2147483647;
        case 18:
        case 1:
          return 47839;
        case 59:
        case 57:
          return 99;
        case 68:
        case 58:
          return 2048;
        case 0: return 2097152;
        case 3: return 65536;
        case 14: return 32768;
        case 73: return 32767;
        case 39: return 16384;
        case 60: return 1000;
        case 106: return 700;
        case 52: return 256;
        case 62: return 255;
        case 2: return 100;
        case 65: return 64;
        case 36: return 20;
        case 100: return 16;
        case 20: return 6;
        case 53: return 4;
      }
      ___setErrNo(ERRNO_CODES.EINVAL);
      return -1;
    }

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

  
  function ___errno_location() {
      return ___setErrNo.ret;
    }var ___errno;

  function _sbrk(bytes) {
      // Implement a Linux-like 'memory area' for our 'process'.
      // Changes the size of the memory area by |bytes|; returns the
      // address of the previous top ('break') of the memory area
  
      // We need to make sure no one else allocates unfreeable memory!
      // We must control this entirely. So we don't even need to do
      // unfreeable allocations - the HEAP is ours, from STATICTOP up.
      // TODO: We could in theory slice off the top of the HEAP when
      //       sbrk gets a negative increment in |bytes|...
      var self = _sbrk;
      if (!self.called) {
        STATICTOP = alignMemoryPage(STATICTOP); // make sure we start out aligned
        self.called = true;
        _sbrk.DYNAMIC_START = STATICTOP;
      }
      var ret = STATICTOP;
      if (bytes != 0) Runtime.staticAlloc(bytes);
      return ret;  // Previous break location.
    }

  function ___cxa_allocate_exception(size) {
      return _malloc(size);
    }

  
  
  
  function ___cxa_is_number_type(type) {
      var isNumber = false;
      try { if (type == __ZTIi) isNumber = true } catch(e){}
      try { if (type == __ZTIj) isNumber = true } catch(e){}
      try { if (type == __ZTIl) isNumber = true } catch(e){}
      try { if (type == __ZTIm) isNumber = true } catch(e){}
      try { if (type == __ZTIx) isNumber = true } catch(e){}
      try { if (type == __ZTIy) isNumber = true } catch(e){}
      try { if (type == __ZTIf) isNumber = true } catch(e){}
      try { if (type == __ZTId) isNumber = true } catch(e){}
      try { if (type == __ZTIe) isNumber = true } catch(e){}
      try { if (type == __ZTIc) isNumber = true } catch(e){}
      try { if (type == __ZTIa) isNumber = true } catch(e){}
      try { if (type == __ZTIh) isNumber = true } catch(e){}
      try { if (type == __ZTIs) isNumber = true } catch(e){}
      try { if (type == __ZTIt) isNumber = true } catch(e){}
      return isNumber;
    }function ___cxa_does_inherit(definiteType, possibilityType, possibility) {
      if (possibility == 0) return false;
      if (possibilityType == 0 || possibilityType == definiteType)
        return true;
      var possibility_type_info;
      if (___cxa_is_number_type(possibilityType)) {
        possibility_type_info = possibilityType;
      } else {
        var possibility_type_infoAddr = HEAP32[((possibilityType)>>2)] - 8;
        possibility_type_info = HEAP32[((possibility_type_infoAddr)>>2)];
      }
      switch (possibility_type_info) {
      case 0: // possibility is a pointer
        // See if definite type is a pointer
        var definite_type_infoAddr = HEAP32[((definiteType)>>2)] - 8;
        var definite_type_info = HEAP32[((definite_type_infoAddr)>>2)];
        if (definite_type_info == 0) {
          // Also a pointer; compare base types of pointers
          var defPointerBaseAddr = definiteType+8;
          var defPointerBaseType = HEAP32[((defPointerBaseAddr)>>2)];
          var possPointerBaseAddr = possibilityType+8;
          var possPointerBaseType = HEAP32[((possPointerBaseAddr)>>2)];
          return ___cxa_does_inherit(defPointerBaseType, possPointerBaseType, possibility);
        } else
          return false; // one pointer and one non-pointer
      case 1: // class with no base class
        return false;
      case 2: // class with base class
        var parentTypeAddr = possibilityType + 8;
        var parentType = HEAP32[((parentTypeAddr)>>2)];
        return ___cxa_does_inherit(definiteType, parentType, possibility);
      default:
        return false; // some unencountered type
      }
    }function ___cxa_find_matching_catch(thrown, throwntype, typeArray) {
      // If throwntype is a pointer, this means a pointer has been
      // thrown. When a pointer is thrown, actually what's thrown
      // is a pointer to the pointer. We'll dereference it.
      if (throwntype != 0 && !___cxa_is_number_type(throwntype)) {
        var throwntypeInfoAddr= HEAP32[((throwntype)>>2)] - 8;
        var throwntypeInfo= HEAP32[((throwntypeInfoAddr)>>2)];
        if (throwntypeInfo == 0)
          thrown = HEAP32[((thrown)>>2)];
      }
      // The different catch blocks are denoted by different types.
      // Due to inheritance, those types may not precisely match the
      // type of the thrown object. Find one which matches, and
      // return the type of the catch block which should be called.
      for (var i = 0; i < typeArray.length; i++) {
        if (___cxa_does_inherit(typeArray[i], throwntype, thrown))
          return (tempRet0 = typeArray[i],thrown);
      }
      // Shouldn't happen unless we have bogus data in typeArray
      // or encounter a type for which emscripten doesn't have suitable
      // typeinfo defined. Best-efforts match just in case.
      return (tempRet0 = throwntype,thrown);
    }function ___cxa_throw(ptr, type, destructor) {
      if (!___cxa_throw.initialized) {
        try {
          HEAP32[((__ZTVN10__cxxabiv119__pointer_type_infoE)>>2)]=0; // Workaround for libcxxabi integration bug
        } catch(e){}
        try {
          HEAP32[((__ZTVN10__cxxabiv117__class_type_infoE)>>2)]=1; // Workaround for libcxxabi integration bug
        } catch(e){}
        try {
          HEAP32[((__ZTVN10__cxxabiv120__si_class_type_infoE)>>2)]=2; // Workaround for libcxxabi integration bug
        } catch(e){}
        ___cxa_throw.initialized = true;
      }
      HEAP32[((_llvm_eh_exception.buf)>>2)]=ptr
      HEAP32[(((_llvm_eh_exception.buf)+(4))>>2)]=type
      HEAP32[(((_llvm_eh_exception.buf)+(8))>>2)]=destructor
      if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) {
        __ZSt18uncaught_exceptionv.uncaught_exception = 1;
      } else {
        __ZSt18uncaught_exceptionv.uncaught_exception++;
      }
      throw ptr + " - Exception catching is disabled, this exception cannot be caught. Compile with -s DISABLE_EXCEPTION_CATCHING=0 or DISABLE_EXCEPTION_CATCHING=2 to catch.";;
    }

  function __ZNSt9exceptionD2Ev(){}





  
  
  
  
  var _stdin=allocate(1, "i32*", ALLOC_STACK);
  
  var _stdout=allocate(1, "i32*", ALLOC_STACK);
  
  var _stderr=allocate(1, "i32*", ALLOC_STACK);
  
  var __impure_ptr=allocate(1, "i32*", ALLOC_STACK);var FS={currentPath:"/",nextInode:2,streams:[null],ignorePermissions:true,joinPath:function (parts, forceRelative) {
        var ret = parts[0];
        for (var i = 1; i < parts.length; i++) {
          if (ret[ret.length-1] != '/') ret += '/';
          ret += parts[i];
        }
        if (forceRelative && ret[0] == '/') ret = ret.substr(1);
        return ret;
      },absolutePath:function (relative, base) {
        if (typeof relative !== 'string') return null;
        if (base === undefined) base = FS.currentPath;
        if (relative && relative[0] == '/') base = '';
        var full = base + '/' + relative;
        var parts = full.split('/').reverse();
        var absolute = [''];
        while (parts.length) {
          var part = parts.pop();
          if (part == '' || part == '.') {
            // Nothing.
          } else if (part == '..') {
            if (absolute.length > 1) absolute.pop();
          } else {
            absolute.push(part);
          }
        }
        return absolute.length == 1 ? '/' : absolute.join('/');
      },analyzePath:function (path, dontResolveLastLink, linksVisited) {
        var ret = {
          isRoot: false,
          exists: false,
          error: 0,
          name: null,
          path: null,
          object: null,
          parentExists: false,
          parentPath: null,
          parentObject: null
        };
        path = FS.absolutePath(path);
        if (path == '/') {
          ret.isRoot = true;
          ret.exists = ret.parentExists = true;
          ret.name = '/';
          ret.path = ret.parentPath = '/';
          ret.object = ret.parentObject = FS.root;
        } else if (path !== null) {
          linksVisited = linksVisited || 0;
          path = path.slice(1).split('/');
          var current = FS.root;
          var traversed = [''];
          while (path.length) {
            if (path.length == 1 && current.isFolder) {
              ret.parentExists = true;
              ret.parentPath = traversed.length == 1 ? '/' : traversed.join('/');
              ret.parentObject = current;
              ret.name = path[0];
            }
            var target = path.shift();
            if (!current.isFolder) {
              ret.error = ERRNO_CODES.ENOTDIR;
              break;
            } else if (!current.read) {
              ret.error = ERRNO_CODES.EACCES;
              break;
            } else if (!current.contents.hasOwnProperty(target)) {
              ret.error = ERRNO_CODES.ENOENT;
              break;
            }
            current = current.contents[target];
            if (current.link && !(dontResolveLastLink && path.length == 0)) {
              if (linksVisited > 40) { // Usual Linux SYMLOOP_MAX.
                ret.error = ERRNO_CODES.ELOOP;
                break;
              }
              var link = FS.absolutePath(current.link, traversed.join('/'));
              ret = FS.analyzePath([link].concat(path).join('/'),
                                   dontResolveLastLink, linksVisited + 1);
              return ret;
            }
            traversed.push(target);
            if (path.length == 0) {
              ret.exists = true;
              ret.path = traversed.join('/');
              ret.object = current;
            }
          }
        }
        return ret;
      },findObject:function (path, dontResolveLastLink) {
        FS.ensureRoot();
        var ret = FS.analyzePath(path, dontResolveLastLink);
        if (ret.exists) {
          return ret.object;
        } else {
          ___setErrNo(ret.error);
          return null;
        }
      },createObject:function (parent, name, properties, canRead, canWrite) {
        if (!parent) parent = '/';
        if (typeof parent === 'string') parent = FS.findObject(parent);
  
        if (!parent) {
          ___setErrNo(ERRNO_CODES.EACCES);
          throw new Error('Parent path must exist.');
        }
        if (!parent.isFolder) {
          ___setErrNo(ERRNO_CODES.ENOTDIR);
          throw new Error('Parent must be a folder.');
        }
        if (!parent.write && !FS.ignorePermissions) {
          ___setErrNo(ERRNO_CODES.EACCES);
          throw new Error('Parent folder must be writeable.');
        }
        if (!name || name == '.' || name == '..') {
          ___setErrNo(ERRNO_CODES.ENOENT);
          throw new Error('Name must not be empty.');
        }
        if (parent.contents.hasOwnProperty(name)) {
          ___setErrNo(ERRNO_CODES.EEXIST);
          throw new Error("Can't overwrite object.");
        }
  
        parent.contents[name] = {
          read: canRead === undefined ? true : canRead,
          write: canWrite === undefined ? false : canWrite,
          timestamp: Date.now(),
          inodeNumber: FS.nextInode++
        };
        for (var key in properties) {
          if (properties.hasOwnProperty(key)) {
            parent.contents[name][key] = properties[key];
          }
        }
  
        return parent.contents[name];
      },createFolder:function (parent, name, canRead, canWrite) {
        var properties = {isFolder: true, isDevice: false, contents: {}};
        return FS.createObject(parent, name, properties, canRead, canWrite);
      },createPath:function (parent, path, canRead, canWrite) {
        var current = FS.findObject(parent);
        if (current === null) throw new Error('Invalid parent.');
        path = path.split('/').reverse();
        while (path.length) {
          var part = path.pop();
          if (!part) continue;
          if (!current.contents.hasOwnProperty(part)) {
            FS.createFolder(current, part, canRead, canWrite);
          }
          current = current.contents[part];
        }
        return current;
      },createFile:function (parent, name, properties, canRead, canWrite) {
        properties.isFolder = false;
        return FS.createObject(parent, name, properties, canRead, canWrite);
      },createDataFile:function (parent, name, data, canRead, canWrite) {
        if (typeof data === 'string') {
          var dataArray = new Array(data.length);
          for (var i = 0, len = data.length; i < len; ++i) dataArray[i] = data.charCodeAt(i);
          data = dataArray;
        }
        var properties = {
          isDevice: false,
          contents: data.subarray ? data.subarray(0) : data // as an optimization, create a new array wrapper (not buffer) here, to help JS engines understand this object
        };
        return FS.createFile(parent, name, properties, canRead, canWrite);
      },createLazyFile:function (parent, name, url, canRead, canWrite) {
  
        if (typeof XMLHttpRequest !== 'undefined') {
          if (!ENVIRONMENT_IS_WORKER) throw 'Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc';
          // Lazy chunked Uint8Array (implements get and length from Uint8Array). Actual getting is abstracted away for eventual reuse.
          var LazyUint8Array = function(chunkSize, length) {
            this.length = length;
            this.chunkSize = chunkSize;
            this.chunks = []; // Loaded chunks. Index is the chunk number
          }
          LazyUint8Array.prototype.get = function(idx) {
            if (idx > this.length-1 || idx < 0) {
              return undefined;
            }
            var chunkOffset = idx % chunkSize;
            var chunkNum = Math.floor(idx / chunkSize);
            return this.getter(chunkNum)[chunkOffset];
          }
          LazyUint8Array.prototype.setDataGetter = function(getter) {
            this.getter = getter;
          }
    
          // Find length
          var xhr = new XMLHttpRequest();
          xhr.open('HEAD', url, false);
          xhr.send(null);
          if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
          var datalength = Number(xhr.getResponseHeader("Content-length"));
          var header;
          var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
          var chunkSize = 1024*1024; // Chunk size in bytes
          if (!hasByteServing) chunkSize = datalength;
    
          // Function to get a range from the remote URL.
          var doXHR = (function(from, to) {
            if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
            if (to > datalength-1) throw new Error("only " + datalength + " bytes available! programmer error!");
    
            // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
            var xhr = new XMLHttpRequest();
            xhr.open('GET', url, false);
            if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
    
            // Some hints to the browser that we want binary data.
            if (typeof Uint8Array != 'undefined') xhr.responseType = 'arraybuffer';
            if (xhr.overrideMimeType) {
              xhr.overrideMimeType('text/plain; charset=x-user-defined');
            }
    
            xhr.send(null);
            if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
            if (xhr.response !== undefined) {
              return new Uint8Array(xhr.response || []);
            } else {
              return intArrayFromString(xhr.responseText || '', true);
            }
          });
    
          var lazyArray = new LazyUint8Array(chunkSize, datalength);
          lazyArray.setDataGetter(function(chunkNum) {
            var start = chunkNum * lazyArray.chunkSize;
            var end = (chunkNum+1) * lazyArray.chunkSize - 1; // including this byte
            end = Math.min(end, datalength-1); // if datalength-1 is selected, this is the last block
            if (typeof(lazyArray.chunks[chunkNum]) === "undefined") {
              lazyArray.chunks[chunkNum] = doXHR(start, end);
            }
            if (typeof(lazyArray.chunks[chunkNum]) === "undefined") throw new Error("doXHR failed!");
            return lazyArray.chunks[chunkNum];
          });
          var properties = { isDevice: false, contents: lazyArray };
        } else {
          var properties = { isDevice: false, url: url };
        }
  
        return FS.createFile(parent, name, properties, canRead, canWrite);
      },createPreloadedFile:function (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile) {
        Browser.ensureObjects();
        var fullname = FS.joinPath([parent, name], true);
        function processData(byteArray) {
          function finish(byteArray) {
            if (!dontCreateFile) {
              FS.createDataFile(parent, name, byteArray, canRead, canWrite);
            }
            if (onload) onload();
            removeRunDependency('cp ' + fullname);
          }
          var handled = false;
          Module['preloadPlugins'].forEach(function(plugin) {
            if (handled) return;
            if (plugin['canHandle'](fullname)) {
              plugin['handle'](byteArray, fullname, finish, function() {
                if (onerror) onerror();
                removeRunDependency('cp ' + fullname);
              });
              handled = true;
            }
          });
          if (!handled) finish(byteArray);
        }
        addRunDependency('cp ' + fullname);
        if (typeof url == 'string') {
          Browser.asyncLoad(url, function(byteArray) {
            processData(byteArray);
          }, onerror);
        } else {
          processData(url);
        }
      },createLink:function (parent, name, target, canRead, canWrite) {
        var properties = {isDevice: false, link: target};
        return FS.createFile(parent, name, properties, canRead, canWrite);
      },createDevice:function (parent, name, input, output) {
        if (!(input || output)) {
          throw new Error('A device must have at least one callback defined.');
        }
        var ops = {isDevice: true, input: input, output: output};
        return FS.createFile(parent, name, ops, Boolean(input), Boolean(output));
      },forceLoadFile:function (obj) {
        if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
        var success = true;
        if (typeof XMLHttpRequest !== 'undefined') {
          throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
        } else if (Module['read']) {
          // Command-line.
          try {
            // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
            //          read() will try to parse UTF8.
            obj.contents = intArrayFromString(Module['read'](obj.url), true);
          } catch (e) {
            success = false;
          }
        } else {
          throw new Error('Cannot load without read() or XMLHttpRequest.');
        }
        if (!success) ___setErrNo(ERRNO_CODES.EIO);
        return success;
      },ensureRoot:function () {
        if (FS.root) return;
        // The main file system tree. All the contents are inside this.
        FS.root = {
          read: true,
          write: true,
          isFolder: true,
          isDevice: false,
          timestamp: Date.now(),
          inodeNumber: 1,
          contents: {}
        };
      },init:function (input, output, error) {
        // Make sure we initialize only once.
        assert(!FS.init.initialized, 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)');
        FS.init.initialized = true;
  
        FS.ensureRoot();
  
        // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
        input = input || Module['stdin'];
        output = output || Module['stdout'];
        error = error || Module['stderr'];
  
        // Default handlers.
        var stdinOverridden = true, stdoutOverridden = true, stderrOverridden = true;
        if (!input) {
          stdinOverridden = false;
          input = function() {
            if (!input.cache || !input.cache.length) {
              var result;
              if (typeof window != 'undefined' &&
                  typeof window.prompt == 'function') {
                // Browser.
                result = window.prompt('Input: ');
                if (result === null) result = String.fromCharCode(0); // cancel ==> EOF
              } else if (typeof readline == 'function') {
                // Command line.
                result = readline();
              }
              if (!result) result = '';
              input.cache = intArrayFromString(result + '\n', true);
            }
            return input.cache.shift();
          };
        }
        var utf8 = new Runtime.UTF8Processor();
        function simpleOutput(val) {
          if (val === null || val === '\n'.charCodeAt(0)) {
            output.printer(output.buffer.join(''));
            output.buffer = [];
          } else {
            output.buffer.push(utf8.processCChar(val));
          }
        }
        if (!output) {
          stdoutOverridden = false;
          output = simpleOutput;
        }
        if (!output.printer) output.printer = Module['print'];
        if (!output.buffer) output.buffer = [];
        if (!error) {
          stderrOverridden = false;
          error = simpleOutput;
        }
        if (!error.printer) error.printer = Module['print'];
        if (!error.buffer) error.buffer = [];
  
        // Create the temporary folder, if not already created
        try {
          FS.createFolder('/', 'tmp', true, true);
        } catch(e) {}
  
        // Create the I/O devices.
        var devFolder = FS.createFolder('/', 'dev', true, true);
        var stdin = FS.createDevice(devFolder, 'stdin', input);
        var stdout = FS.createDevice(devFolder, 'stdout', null, output);
        var stderr = FS.createDevice(devFolder, 'stderr', null, error);
        FS.createDevice(devFolder, 'tty', input, output);
  
        // Create default streams.
        FS.streams[1] = {
          path: '/dev/stdin',
          object: stdin,
          position: 0,
          isRead: true,
          isWrite: false,
          isAppend: false,
          isTerminal: !stdinOverridden,
          error: false,
          eof: false,
          ungotten: []
        };
        FS.streams[2] = {
          path: '/dev/stdout',
          object: stdout,
          position: 0,
          isRead: false,
          isWrite: true,
          isAppend: false,
          isTerminal: !stdoutOverridden,
          error: false,
          eof: false,
          ungotten: []
        };
        FS.streams[3] = {
          path: '/dev/stderr',
          object: stderr,
          position: 0,
          isRead: false,
          isWrite: true,
          isAppend: false,
          isTerminal: !stderrOverridden,
          error: false,
          eof: false,
          ungotten: []
        };
        assert(Math.max(_stdin, _stdout, _stderr) < 128); // make sure these are low, we flatten arrays with these
        HEAP32[((_stdin)>>2)]=1;
        HEAP32[((_stdout)>>2)]=2;
        HEAP32[((_stderr)>>2)]=3;
  
        // Other system paths
        FS.createPath('/', 'dev/shm/tmp', true, true); // temp files
  
        // Newlib initialization
        for (var i = FS.streams.length; i < Math.max(_stdin, _stdout, _stderr) + 4; i++) {
          FS.streams[i] = null; // Make sure to keep FS.streams dense
        }
        FS.streams[_stdin] = FS.streams[1];
        FS.streams[_stdout] = FS.streams[2];
        FS.streams[_stderr] = FS.streams[3];
        allocate([ allocate(
          [0, 0, 0, 0, _stdin, 0, 0, 0, _stdout, 0, 0, 0, _stderr, 0, 0, 0],
          'void*', ALLOC_STATIC) ], 'void*', ALLOC_NONE, __impure_ptr);
      },quit:function () {
        if (!FS.init.initialized) return;
        // Flush any partially-printed lines in stdout and stderr. Careful, they may have been closed
        if (FS.streams[2] && FS.streams[2].object.output.buffer.length > 0) FS.streams[2].object.output('\n'.charCodeAt(0));
        if (FS.streams[3] && FS.streams[3].object.output.buffer.length > 0) FS.streams[3].object.output('\n'.charCodeAt(0));
      },standardizePath:function (path) {
        if (path.substr(0, 2) == './') path = path.substr(2);
        return path;
      },deleteFile:function (path) {
        path = FS.analyzePath(path);
        if (!path.parentExists || !path.exists) {
          throw 'Invalid path ' + path;
        }
        delete path.parentObject.contents[path.name];
      }};
  
  function _pwrite(fildes, buf, nbyte, offset) {
      // ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
      var stream = FS.streams[fildes];
      if (!stream || stream.object.isDevice) {
        ___setErrNo(ERRNO_CODES.EBADF);
        return -1;
      } else if (!stream.isWrite) {
        ___setErrNo(ERRNO_CODES.EACCES);
        return -1;
      } else if (stream.object.isFolder) {
        ___setErrNo(ERRNO_CODES.EISDIR);
        return -1;
      } else if (nbyte < 0 || offset < 0) {
        ___setErrNo(ERRNO_CODES.EINVAL);
        return -1;
      } else {
        var contents = stream.object.contents;
        while (contents.length < offset) contents.push(0);
        for (var i = 0; i < nbyte; i++) {
          contents[offset + i] = HEAPU8[((buf)+(i))];
        }
        stream.object.timestamp = Date.now();
        return i;
      }
    }function _write(fildes, buf, nbyte) {
      // ssize_t write(int fildes, const void *buf, size_t nbyte);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/write.html
      var stream = FS.streams[fildes];
      if (!stream) {
        ___setErrNo(ERRNO_CODES.EBADF);
        return -1;
      } else if (!stream.isWrite) {
        ___setErrNo(ERRNO_CODES.EACCES);
        return -1;
      } else if (nbyte < 0) {
        ___setErrNo(ERRNO_CODES.EINVAL);
        return -1;
      } else {
        if (stream.object.isDevice) {
          if (stream.object.output) {
            for (var i = 0; i < nbyte; i++) {
              try {
                stream.object.output(HEAP8[((buf)+(i))]);
              } catch (e) {
                ___setErrNo(ERRNO_CODES.EIO);
                return -1;
              }
            }
            stream.object.timestamp = Date.now();
            return i;
          } else {
            ___setErrNo(ERRNO_CODES.ENXIO);
            return -1;
          }
        } else {
          var bytesWritten = _pwrite(fildes, buf, nbyte, stream.position);
          if (bytesWritten != -1) stream.position += bytesWritten;
          return bytesWritten;
        }
      }
    }function _fputs(s, stream) {
      // int fputs(const char *restrict s, FILE *restrict stream);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputs.html
      return _write(stream, s, _strlen(s));
    }
  
  function _fputc(c, stream) {
      // int fputc(int c, FILE *stream);
      // http://pubs.opengroup.org/onlinepubs/000095399/functions/fputc.html
      var chr = unSign(c & 0xFF);
      HEAP8[(_fputc.ret)]=chr
      var ret = _write(stream, _fputc.ret, 1);
      if (ret == -1) {
        if (FS.streams[stream]) FS.streams[stream].error = true;
        return -1;
      } else {
        return chr;
      }
    }function _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('\n'.charCodeAt(0), stdout);
        return (newlineRet < 0) ? -1 : ret + 1;
      }
    }
_llvm_eh_exception.buf = allocate(12, "void*", ALLOC_STATIC);
___setErrNo(0);
__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;
_fputc.ret = allocate([0], "i8", ALLOC_STATIC);


var FUNCTION_TABLE = [0,0,__ZN9LoopShapeD1Ev,0,__ZNK10__cxxabiv117__class_type_info16search_above_dstEPNS_19__dynamic_cast_infoEPKvS4_ib,0,__ZN5ShapeD0Ev,0,__ZNSt9bad_allocD0Ev,0,__ZN10__cxxabiv117__class_type_infoD1Ev,0,__ZN12LabeledShapeD0Ev,0,__ZN10__cxxabiv117__class_type_infoD0Ev,0,__ZNKSt9bad_alloc4whatEv,0,__ZNK10__cxxabiv120__si_class_type_info16search_below_dstEPNS_19__dynamic_cast_infoEPKvib,0,__ZN13MultipleShape6RenderEb,0,__ZN9LoopShape6RenderEb,0,__ZN11SimpleShape6RenderEb,0,__ZN9LoopShapeD0Ev,0,__ZNK10__cxxabiv117__class_type_info9can_catchEPKNS_16__shim_type_infoERPv,0,__ZNK10__cxxabiv120__si_class_type_info16search_above_dstEPNS_19__dynamic_cast_infoEPKvS4_ib,0,__ZNK10__cxxabiv117__class_type_info16search_below_dstEPNS_19__dynamic_cast_infoEPKvib,0,__ZN11SimpleShapeD1Ev,0,__ZN11SimpleShapeD0Ev,0,__ZNK10__cxxabiv116__shim_type_info5noop1Ev,0,__ZN13MultipleShapeD1Ev,0,__ZNSt9bad_allocD1Ev,0,__ZN10__cxxabiv120__si_class_type_infoD1Ev,0,__ZNK10__cxxabiv117__class_type_info27has_unambiguous_public_baseEPNS_19__dynamic_cast_infoEPvi,0,__ZN12LabeledShapeD1Ev,0,__ZN10__cxxabiv120__si_class_type_infoD0Ev,0,__ZNK10__cxxabiv116__shim_type_info5noop2Ev,0,__ZNSt3__13mapIPviNS_4lessIS1_EENS_9allocatorINS_4pairIKS1_iEEEEED1Ev,0,__ZNK10__cxxabiv120__si_class_type_info27has_unambiguous_public_baseEPNS_19__dynamic_cast_infoEPvi,0,__ZN5ShapeD1Ev,0,___cxa_pure_virtual,0,__ZN13MultipleShapeD0Ev,0];

function __ZN10ministring4sizeEv(r1) {
  return r1;
}
function __ZN10ministring5c_strEv(r1) {
  return r1;
}
function __ZN8Indenter6IndentEv() {
  HEAP32[1311191] = HEAP32[1311191] + 1 | 0;
  return;
}
function __ZN8Indenter8UnindentEv() {
  HEAP32[1311191] = HEAP32[1311191] - 1 | 0;
  return;
}
function __ZN5Shape10IsMultipleEPS_(r1) {
  var r2;
  do {
    if ((r1 | 0) == 0) {
      r2 = 0;
    } else {
      if ((HEAP32[r1 + 12 >> 2] | 0) != 1) {
        r2 = 0;
        break;
      }
      r2 = r1;
    }
  } while (0);
  return r2;
}
function __ZN6BranchC1EPKcS1_(r1, r2, r3) {
  __ZN6BranchC2EPKcS1_(r1, r2, r3);
  return;
}
function __ZN6BranchC2EPKcS1_(r1, r2, r3) {
  var r4, r5, r6;
  HEAP32[r1 >> 2] = 0;
  HEAP8[r1 + 8 | 0] = 0;
  if ((r2 | 0) == 0) {
    r4 = 0;
  } else {
    r4 = _strdup(r2);
  }
  HEAP32[r1 + 12 >> 2] = r4;
  if ((r3 | 0) == 0) {
    r5 = 0;
    r6 = r1 + 16 | 0;
    HEAP32[r6 >> 2] = r5;
    return;
  }
  r5 = _strdup(r3);
  r6 = r1 + 16 | 0;
  HEAP32[r6 >> 2] = r5;
  return;
}
function __ZN6BranchD1Ev(r1) {
  __ZN6BranchD2Ev(r1);
  return;
}
function __ZN6BranchD2Ev(r1) {
  var r2;
  r2 = HEAP32[r1 + 12 >> 2];
  if ((r2 | 0) != 0) {
    _free(r2);
  }
  r2 = HEAP32[r1 + 16 >> 2];
  if ((r2 | 0) == 0) {
    return;
  }
  _free(r2);
  return;
}
function __ZN6Branch6RenderEP5Blockb(r1, r2, r3) {
  var r4, r5;
  r4 = STACKTOP;
  r5 = HEAP32[r1 + 16 >> 2];
  if ((r5 | 0) != 0) {
    __ZL13PrintIndentedPKcz(5243504, (tempInt = STACKTOP, STACKTOP = STACKTOP + 4 | 0, HEAP32[tempInt >> 2] = r5, tempInt));
  }
  if (r3) {
    __ZL13PrintIndentedPKcz(5243488, (tempInt = STACKTOP, STACKTOP = STACKTOP + 4 | 0, HEAP32[tempInt >> 2] = HEAP32[r2 + 52 >> 2], tempInt));
  }
  r2 = HEAP32[r1 >> 2];
  if ((r2 | 0) == 0) {
    STACKTOP = r4;
    return;
  }
  r3 = HEAP32[r1 + 4 >> 2];
  if ((r3 | 0) == 0) {
    STACKTOP = r4;
    return;
  }
  r5 = (r3 | 0) == 1 ? 5243212 : 5243012;
  if ((HEAP8[r1 + 8 | 0] & 1) << 24 >> 24 == 0) {
    __ZL13PrintIndentedPKcz(5243004, (tempInt = STACKTOP, STACKTOP = STACKTOP + 4 | 0, HEAP32[tempInt >> 2] = r5, tempInt));
    STACKTOP = r4;
    return;
  } else {
    r1 = HEAP32[r2 + 4 >> 2];
    __ZL13PrintIndentedPKcz(5243364, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = r5, HEAP32[tempInt + 4 >> 2] = r1, tempInt));
    STACKTOP = r4;
    return;
  }
}
function __ZL13PrintIndentedPKcz(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 4 | 0;
  r4 = r3;
  r5 = HEAP32[1311198];
  if ((r5 | 0) == 0) {
    ___assert_func(5242980, 36, 5244248, 5243148);
    r6 = HEAP32[1311198];
  } else {
    r6 = r5;
  }
  r5 = HEAP32[1311191];
  if (((r5 << 1) + r6 - HEAP32[1311196] | 0) < (HEAP32[1311195] | 0)) {
    r7 = r5;
  } else {
    ___assert_func(5242980, 37, 5244248, 5243072);
    r7 = HEAP32[1311191];
  }
  r5 = r7 << 1;
  r7 = HEAP32[1311198];
  L52 : do {
    if ((r5 | 0) > 0) {
      r6 = 0;
      r8 = r7;
      while (1) {
        HEAP8[r8] = 32;
        r9 = r6 + 1 | 0;
        r10 = r8 + 1 | 0;
        HEAP32[1311198] = r10;
        if ((r9 | 0) < (r5 | 0)) {
          r6 = r9;
          r8 = r10;
        } else {
          r11 = r10;
          break L52;
        }
      }
    } else {
      r11 = r7;
    }
  } while (0);
  HEAP32[r4 >> 2] = r2;
  r2 = HEAP32[1311196] - r11 + HEAP32[1311195] | 0;
  r7 = _snprintf(r11, r2, r1, HEAP32[r4 >> 2]);
  if ((r7 | 0) < (r2 | 0)) {
    r12 = HEAP32[1311198];
    r13 = r12 + r7 | 0;
    HEAP32[1311198] = r13;
    STACKTOP = r3;
    return;
  }
  ___assert_func(5242980, 43, 5244248, 5243024);
  r12 = HEAP32[1311198];
  r13 = r12 + r7 | 0;
  HEAP32[1311198] = r13;
  STACKTOP = r3;
  return;
}
__ZL13PrintIndentedPKcz["X"] = 1;
function __ZN5BlockC1EPKc(r1, r2) {
  __ZN5BlockC2EPKc(r1, r2);
  return;
}
function __ZN5BlockC2EPKc(r1, r2) {
  var r3;
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC1ERKSA_(r1 | 0);
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC1ERKSA_(r1 + 12 | 0);
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC1ERKSA_(r1 + 24 | 0);
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC1ERKSA_(r1 + 36 | 0);
  HEAP32[r1 + 48 >> 2] = 0;
  r3 = HEAP32[1311193];
  HEAP32[1311193] = r3 + 1 | 0;
  HEAP32[r1 + 52 >> 2] = r3;
  HEAP32[r1 + 60 >> 2] = 0;
  HEAP8[r1 + 64 | 0] = 0;
  HEAP32[r1 + 56 >> 2] = _strdup(r2);
  return;
}
function __ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED1Ev(r1) {
  __ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED2Ev(r1);
  return;
}
function __ZN5BlockD1Ev(r1) {
  __ZN5BlockD2Ev(r1);
  return;
}
function __ZN5BlockD2Ev(r1) {
  var r2, r3, r4, r5, r6, r7, r8;
  r2 = HEAP32[r1 + 56 >> 2];
  if ((r2 | 0) != 0) {
    _free(r2);
  }
  r2 = r1 + 36 | 0;
  r3 = HEAP32[r2 >> 2];
  r4 = r1 + 40 | 0;
  L68 : do {
    if ((r3 | 0) != (r4 | 0)) {
      r5 = r4;
      r6 = r3;
      while (1) {
        r7 = HEAP32[r6 + 20 >> 2];
        if ((r7 | 0) != 0) {
          __ZN6BranchD1Ev(r7);
          __ZdlPv(r7);
        }
        r7 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r6 | 0);
        if ((r7 | 0) == (r5 | 0)) {
          break L68;
        } else {
          r6 = r7;
        }
      }
    }
  } while (0);
  r3 = r1 + 24 | 0;
  r4 = HEAP32[r3 >> 2];
  r6 = r1 + 28 | 0;
  L76 : do {
    if ((r4 | 0) != (r6 | 0)) {
      r5 = r6;
      r7 = r4;
      while (1) {
        r8 = HEAP32[r7 + 20 >> 2];
        if ((r8 | 0) != 0) {
          __ZN6BranchD1Ev(r8);
          __ZdlPv(r8);
        }
        r8 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r7 | 0);
        if ((r8 | 0) == (r5 | 0)) {
          break L76;
        } else {
          r7 = r8;
        }
      }
    }
  } while (0);
  __ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED1Ev(r2);
  __ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED1Ev(r3);
  __ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED1Ev(r1 + 12 | 0);
  __ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED1Ev(r1 | 0);
  return;
}
__ZN5BlockD2Ev["X"] = 1;
function __ZN5Block11AddBranchToEPS_PKcS2_(r1, r2, r3, r4) {
  var r5, r6, r7;
  r5 = STACKTOP;
  STACKTOP = STACKTOP + 8 | 0;
  r6 = r5;
  r7 = r5 + 4;
  HEAP32[r7 >> 2] = r2;
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_(r6, r1 | 0, r7);
  if ((HEAP32[r6 >> 2] | 0) != (r1 + 4 | 0)) {
    ___assert_func(5242980, 117, 5244184, 5242932);
  }
  r6 = __Znwj(20);
  __ZN6BranchC1EPKcS1_(r6, r3, r4);
  HEAP32[__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(r1 | 0, r7) >> 2] = r6;
  STACKTOP = r5;
  return;
}
function __ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 16 | 0;
  r4 = r3;
  r5 = r3 + 4;
  r6 = __ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEE16__find_equal_keyERPNS_16__tree_node_baseIPvEERS9_(r1, r4, r2);
  r7 = HEAP32[r6 >> 2];
  if ((r7 | 0) != 0) {
    r8 = r7;
    r9 = r8 + 20 | 0;
    STACKTOP = r3;
    return r9;
  }
  __ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEE16__construct_nodeERS9_(r5, r1, r2);
  r2 = r5 | 0;
  r5 = HEAP32[r2 >> 2];
  HEAP32[r2 >> 2] = 0;
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSH_SH_(r1 | 0, HEAP32[r4 >> 2], r6, r5 | 0);
  r8 = r5;
  r9 = r8 + 20 | 0;
  STACKTOP = r3;
  return r9;
}
function __ZN5Block6RenderEb(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36;
  r3 = 0;
  r4 = STACKTOP;
  STACKTOP = STACKTOP + 24 | 0;
  r5 = r4;
  r6 = r4 + 4;
  r7 = r4 + 8;
  r8 = r4 + 20, r9 = r8 >> 2;
  if (!((HEAP8[r1 + 64 | 0] & 1) << 24 >> 24 == 0 | r2 ^ 1)) {
    __ZL13PrintIndentedPKcz(5242920, (tempInt = STACKTOP, STACKTOP = STACKTOP + 1 | 0, STACKTOP = STACKTOP + 3 >> 2 << 2, HEAP32[tempInt >> 2] = 0, tempInt));
  }
  r10 = HEAP32[r1 + 56 >> 2];
  L97 : do {
    if ((r10 | 0) != 0) {
      if (HEAP8[r10] << 24 >> 24 == 0) {
        break;
      } else {
        r11 = r10;
      }
      while (1) {
        r12 = _strchr(r11, 10);
        if ((r12 | 0) == 0) {
          break;
        }
        HEAP8[r12] = 0;
        __ZL11PutIndentedPKc(r11);
        HEAP8[r12] = 10;
        r13 = r12 + 1 | 0;
        if (HEAP8[r13] << 24 >> 24 == 0) {
          break L97;
        } else {
          r11 = r13;
        }
      }
      __ZL11PutIndentedPKc(r11);
    }
  } while (0);
  r11 = r1 + 24 | 0;
  r10 = r1 + 32 | 0;
  r13 = HEAP32[r10 >> 2];
  if ((r13 | 0) == 1) {
    r14 = (HEAP32[HEAP32[HEAP32[r11 >> 2] + 20 >> 2] + 4 >> 2] | 0) != 0 & 1;
  } else if ((r13 | 0) == 0) {
    STACKTOP = r4;
    return;
  } else {
    r14 = 1;
  }
  r13 = HEAP32[r1 + 48 >> 2] + 8 | 0;
  r12 = HEAP32[r13 >> 2];
  r15 = __ZN5Shape10IsMultipleEPS_(r12);
  r16 = (r15 | 0) != 0;
  do {
    if (r16) {
      HEAP32[r13 >> 2] = HEAP32[r12 + 8 >> 2];
      __ZN13MultipleShape16RenderLoopPrefixEv(r15);
      if (r14 << 24 >> 24 == 0) {
        r17 = 0;
        break;
      }
      r17 = (HEAP32[r15 + 28 >> 2] | 0) == (HEAP32[r10 >> 2] | 0) ? 0 : r14;
    } else {
      r17 = r14;
    }
  } while (0);
  r14 = r11 | 0;
  r10 = HEAP32[r14 >> 2];
  r12 = r1 + 28 | 0;
  r13 = r12;
  r18 = r1 + 60 | 0, r1 = r18 >> 2;
  L112 : do {
    if ((r10 | 0) != (r13 | 0)) {
      r19 = r12;
      r20 = r10;
      while (1) {
        if ((HEAP32[HEAP32[r20 + 20 >> 2] + 12 >> 2] | 0) == 0) {
          if ((HEAP32[r1] | 0) != 0) {
            ___assert_func(5242980, 185, 5244156, 5242904);
          }
          HEAP32[r1] = HEAP32[r20 + 16 >> 2];
        }
        r21 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r20 | 0);
        if ((r21 | 0) == (r19 | 0)) {
          break L112;
        } else {
          r20 = r21;
        }
      }
    }
  } while (0);
  if ((HEAP32[r1] | 0) == 0) {
    ___assert_func(5242980, 189, 5244156, 5243472);
  }
  __ZN10ministringC1Ev(r7);
  r10 = (r17 & 1) << 24 >> 24 == 0;
  r17 = r15 + 20 | 0;
  r12 = r5 | 0;
  r20 = r15 + 24 | 0;
  r19 = r6 | 0;
  r21 = r7 | 0;
  r22 = r7 + 4 | 0;
  r23 = 1;
  r24 = HEAP32[r14 >> 2];
  while (1) {
    r14 = (r24 | 0) == (r13 | 0);
    do {
      if (r14) {
        r25 = HEAP32[r1];
        HEAP32[r9] = r25;
        r26 = HEAP32[__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(r11, r18) >> 2], r27 = r26 >> 2;
        r28 = r25;
        r3 = 103;
        break;
      } else {
        r25 = HEAP32[r24 + 16 >> 2];
        HEAP32[r9] = r25;
        if ((r25 | 0) == (HEAP32[r1] | 0)) {
          r29 = r23;
          break;
        }
        r30 = HEAP32[r24 + 20 >> 2];
        if ((HEAP32[r30 + 12 >> 2] | 0) != 0) {
          r26 = r30, r27 = r26 >> 2;
          r28 = r25;
          r3 = 103;
          break;
        }
        ___assert_func(5242980, 200, 5244156, 5243452);
        r26 = r30, r27 = r26 >> 2;
        r28 = r25;
        r3 = 103;
        break;
      }
    } while (0);
    if (r3 == 103) {
      r3 = 0;
      if (r10) {
        r31 = 0;
      } else {
        r31 = (HEAP8[r28 + 64 | 0] & 1) << 24 >> 24 != 0;
      }
      if (r16) {
        __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_(r5, r17, r8);
        r32 = (HEAP32[r12 >> 2] | 0) != (r20 | 0);
      } else {
        r32 = 0;
      }
      do {
        if (r31) {
          r33 = 1;
        } else {
          if ((HEAP32[r27 + 1] | 0) != 0 | r32) {
            r33 = 1;
            break;
          }
          r33 = (HEAP32[r27 + 4] | 0) != 0;
        }
      } while (0);
      do {
        if (r14) {
          if (!r33) {
            r3 = 123;
            break;
          }
          r25 = (r23 & 1) << 24 >> 24 != 0;
          if ((__ZN10ministring4sizeEv(HEAP32[r21 >> 2]) | 0) <= 0) {
            if (r25) {
              r3 = 123;
              break;
            }
            __ZL13PrintIndentedPKcz(5243352, (tempInt = STACKTOP, STACKTOP = STACKTOP + 1 | 0, STACKTOP = STACKTOP + 3 >> 2 << 2, HEAP32[tempInt >> 2] = 0, tempInt));
            r3 = 123;
            break;
          }
          r30 = __ZN10ministring5c_strEv(HEAP32[r22 >> 2]);
          if (r25) {
            __ZL13PrintIndentedPKcz(5243396, (tempInt = STACKTOP, STACKTOP = STACKTOP + 4 | 0, HEAP32[tempInt >> 2] = r30, tempInt));
            r34 = 0;
            r3 = 124;
            break;
          } else {
            __ZL13PrintIndentedPKcz(5243376, (tempInt = STACKTOP, STACKTOP = STACKTOP + 4 | 0, HEAP32[tempInt >> 2] = r30, tempInt));
            r3 = 123;
            break;
          }
        } else {
          if (r33) {
            r30 = HEAP32[r27 + 3];
            __ZL13PrintIndentedPKcz(5243436, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = (r23 & 1) << 24 >> 24 != 0 ? 5243432 : 5243424, HEAP32[tempInt + 4 >> 2] = r30, tempInt));
            r34 = 0;
            r3 = 124;
            break;
          }
          if ((__ZN10ministring4sizeEv(HEAP32[r21 >> 2]) | 0) > 0) {
            __ZN10ministringpLEPKc(r7, 5243416);
          }
          __ZN10ministringpLEPKc(r7, 5243412);
          __ZN10ministringpLEPKc(r7, HEAP32[r27 + 3]);
          __ZN10ministringpLEPKc(r7, 5243408);
          r3 = 123;
          break;
        }
      } while (0);
      do {
        if (r3 == 123) {
          r3 = 0;
          if ((r23 & 1) << 24 >> 24 == 0) {
            r34 = r23;
            r3 = 124;
            break;
          } else {
            r35 = r23;
            r36 = 1;
            break;
          }
        }
      } while (0);
      if (r3 == 124) {
        r3 = 0;
        __ZN8Indenter6IndentEv();
        r35 = r34;
        r36 = 0;
      }
      __ZN6Branch6RenderEP5Blockb(r26, HEAP32[r9], r31);
      if (r32) {
        __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_(r6, r17, r8);
        r30 = HEAP32[HEAP32[r19 >> 2] + 20 >> 2];
        FUNCTION_TABLE[HEAP32[HEAP32[r30 >> 2] + 8 >> 2]](r30, r2);
      }
      if (!r36) {
        __ZN8Indenter8UnindentEv();
      }
      if (r14) {
        break;
      } else {
        r29 = r35;
      }
    }
    r23 = r29;
    r24 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r24 | 0);
  }
  if (!r36) {
    __ZL13PrintIndentedPKcz(5243348, (tempInt = STACKTOP, STACKTOP = STACKTOP + 1 | 0, STACKTOP = STACKTOP + 3 >> 2 << 2, HEAP32[tempInt >> 2] = 0, tempInt));
  }
  if (r16) {
    __ZN13MultipleShape17RenderLoopPostfixEv(HEAP32[r15 + 32 >> 2]);
  }
  __ZN10ministringD1Ev(HEAP32[r22 >> 2]);
  STACKTOP = r4;
  return;
}
__ZN5Block6RenderEb["X"] = 1;
function __ZL11PutIndentedPKc(r1) {
  var r2, r3, r4, r5, r6, r7, r8, r9;
  r2 = HEAP32[1311198];
  if ((r2 | 0) == 0) {
    ___assert_func(5242980, 49, 5244288, 5243148);
    r3 = HEAP32[1311198];
  } else {
    r3 = r2;
  }
  r2 = HEAP32[1311191];
  if (((r2 << 1) + r3 - HEAP32[1311196] | 0) < (HEAP32[1311195] | 0)) {
    r4 = r2;
    r5 = r3;
  } else {
    ___assert_func(5242980, 50, 5244288, 5243072);
    r4 = HEAP32[1311191];
    r5 = HEAP32[1311198];
  }
  r3 = r4 << 1;
  L191 : do {
    if ((r3 | 0) > 0) {
      r4 = 0;
      r2 = r5;
      while (1) {
        HEAP8[r2] = 32;
        r6 = r4 + 1 | 0;
        r7 = r2 + 1 | 0;
        HEAP32[1311198] = r7;
        if ((r6 | 0) < (r3 | 0)) {
          r4 = r6;
          r2 = r7;
        } else {
          r8 = r7;
          break L191;
        }
      }
    } else {
      r8 = r5;
    }
  } while (0);
  r5 = HEAP32[1311195] - r8 + HEAP32[1311196] | 0;
  if ((_strlen(r1) + 1 | 0) < (r5 | 0)) {
    r9 = r8;
  } else {
    ___assert_func(5242980, 54, 5244288, 5243040);
    r9 = HEAP32[1311198];
  }
  _strcpy(r9, r1);
  r9 = _strlen(r1);
  r1 = HEAP32[1311198];
  r8 = r9 + (r1 + 1) | 0;
  HEAP32[1311198] = r8;
  HEAP8[r1 + r9 | 0] = 10;
  HEAP8[r8] = 0;
  return;
}
__ZL11PutIndentedPKc["X"] = 1;
function __ZN13MultipleShape16RenderLoopPrefixEv(r1) {
  var r2;
  r2 = STACKTOP;
  if ((HEAP32[r1 + 32 >> 2] | 0) == 0) {
    STACKTOP = r2;
    return;
  }
  if ((HEAP8[r1 + 16 | 0] & 1) << 24 >> 24 == 0) {
    __ZL13PrintIndentedPKcz(5243328, (tempInt = STACKTOP, STACKTOP = STACKTOP + 1 | 0, STACKTOP = STACKTOP + 3 >> 2 << 2, HEAP32[tempInt >> 2] = 0, tempInt));
  } else {
    __ZL13PrintIndentedPKcz(5243336, (tempInt = STACKTOP, STACKTOP = STACKTOP + 4 | 0, HEAP32[tempInt >> 2] = HEAP32[r1 + 4 >> 2], tempInt));
  }
  __ZN8Indenter6IndentEv();
  STACKTOP = r2;
  return;
}
function __ZN10ministringC1Ev(r1) {
  __ZN10ministringC2Ev(r1);
  return;
}
function __ZN10ministringpLEPKc(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14;
  r3 = _strlen(r2);
  r4 = (r1 | 0) >> 2;
  r5 = HEAP32[r4];
  r6 = r1 + 8 | 0;
  r7 = HEAP32[r6 >> 2];
  if ((r5 + (r3 + 2) | 0) <= (r7 | 0)) {
    r8 = r5;
    r9 = HEAP32[r1 + 4 >> 2];
    r10 = r9 + r8 | 0;
    r11 = _strcpy(r10, r2);
    r12 = HEAP32[r4];
    r13 = r12 + r3 | 0;
    HEAP32[r4] = r13;
    return;
  }
  r5 = r7 + r3 << 1;
  r7 = 1024 - (r5 | 0) % 1024 + r5 | 0;
  HEAP32[r6 >> 2] = r7;
  r6 = r1 + 4 | 0;
  r1 = HEAP32[r6 >> 2];
  if ((r1 | 0) == 0) {
    r14 = _malloc(r7);
  } else {
    r14 = _realloc(r1, r7);
  }
  HEAP32[r6 >> 2] = r14;
  r8 = HEAP32[r4];
  r9 = r14;
  r10 = r9 + r8 | 0;
  r11 = _strcpy(r10, r2);
  r12 = HEAP32[r4];
  r13 = r12 + r3 | 0;
  HEAP32[r4] = r13;
  return;
}
function __ZN13MultipleShape17RenderLoopPostfixEv(r1) {
  var r2;
  r2 = STACKTOP;
  if ((r1 | 0) == 0) {
    STACKTOP = r2;
    return;
  }
  __ZN8Indenter8UnindentEv();
  __ZL13PrintIndentedPKcz(5243312, (tempInt = STACKTOP, STACKTOP = STACKTOP + 1 | 0, STACKTOP = STACKTOP + 3 >> 2 << 2, HEAP32[tempInt >> 2] = 0, tempInt));
  STACKTOP = r2;
  return;
}
function __ZN10ministringD1Ev(r1) {
  __ZN10ministringD2Ev(r1);
  return;
}
function __ZN13MultipleShape6RenderEb(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9;
  r3 = STACKTOP;
  __ZN13MultipleShape16RenderLoopPrefixEv(r1);
  r4 = HEAP32[r1 + 20 >> 2];
  r5 = r1 + 24 | 0;
  L225 : do {
    if ((r4 | 0) != (r5 | 0)) {
      r6 = r5;
      r7 = r4;
      r8 = 5243432;
      while (1) {
        r9 = HEAP32[HEAP32[r7 + 16 >> 2] + 52 >> 2];
        if ((HEAP32[1311194] | 0) == 0) {
          __ZL13PrintIndentedPKcz(5243252, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = r8, HEAP32[tempInt + 4 >> 2] = r9, tempInt));
        } else {
          __ZL13PrintIndentedPKcz(5243284, (tempInt = STACKTOP, STACKTOP = STACKTOP + 8 | 0, HEAP32[tempInt >> 2] = r8, HEAP32[tempInt + 4 >> 2] = r9, tempInt));
        }
        __ZN8Indenter6IndentEv();
        r9 = HEAP32[r7 + 20 >> 2];
        FUNCTION_TABLE[HEAP32[HEAP32[r9 >> 2] + 8 >> 2]](r9, r2);
        __ZN8Indenter8UnindentEv();
        __ZL13PrintIndentedPKcz(5243348, (tempInt = STACKTOP, STACKTOP = STACKTOP + 1 | 0, STACKTOP = STACKTOP + 3 >> 2 << 2, HEAP32[tempInt >> 2] = 0, tempInt));
        r9 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r7 | 0);
        if ((r9 | 0) == (r6 | 0)) {
          break L225;
        } else {
          r7 = r9;
          r8 = 5243276;
        }
      }
    }
  } while (0);
  __ZN13MultipleShape17RenderLoopPostfixEv(HEAP32[r1 + 32 >> 2]);
  r4 = HEAP32[r1 + 8 >> 2];
  if ((r4 | 0) == 0) {
    STACKTOP = r3;
    return;
  }
  FUNCTION_TABLE[HEAP32[HEAP32[r4 >> 2] + 8 >> 2]](r4, r2);
  STACKTOP = r3;
  return;
}
__ZN13MultipleShape6RenderEb["X"] = 1;
function __ZN9LoopShape6RenderEb(r1, r2) {
  var r3, r4;
  r3 = STACKTOP;
  if ((HEAP8[r1 + 16 | 0] & 1) << 24 >> 24 == 0) {
    __ZL13PrintIndentedPKcz(5243220, (tempInt = STACKTOP, STACKTOP = STACKTOP + 1 | 0, STACKTOP = STACKTOP + 3 >> 2 << 2, HEAP32[tempInt >> 2] = 0, tempInt));
  } else {
    __ZL13PrintIndentedPKcz(5243232, (tempInt = STACKTOP, STACKTOP = STACKTOP + 4 | 0, HEAP32[tempInt >> 2] = HEAP32[r1 + 4 >> 2], tempInt));
  }
  __ZN8Indenter6IndentEv();
  r4 = HEAP32[r1 + 20 >> 2];
  FUNCTION_TABLE[HEAP32[HEAP32[r4 >> 2] + 8 >> 2]](r4, 1);
  __ZN8Indenter8UnindentEv();
  __ZL13PrintIndentedPKcz(5243348, (tempInt = STACKTOP, STACKTOP = STACKTOP + 1 | 0, STACKTOP = STACKTOP + 3 >> 2 << 2, HEAP32[tempInt >> 2] = 0, tempInt));
  r4 = HEAP32[r1 + 8 >> 2];
  if ((r4 | 0) == 0) {
    STACKTOP = r3;
    return;
  }
  FUNCTION_TABLE[HEAP32[HEAP32[r4 >> 2] + 8 >> 2]](r4, r2);
  STACKTOP = r3;
  return;
}
function __ZN8RelooperC1Ev(r1) {
  __ZN8RelooperC2Ev(r1);
  return;
}
function __ZN8RelooperC2Ev(r1) {
  var r2, r3;
  r2 = r1;
  for (r1 = r2 >> 2, r3 = r1 + 13; r1 < r3; r1++) {
    HEAP32[r1] = 0;
  }
  return;
}
function __ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEED1Ev(r1) {
  __ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEED2Ev(r1);
  return;
}
function __ZN8RelooperD1Ev(r1) {
  __ZN8RelooperD2Ev(r1);
  return;
}
function __ZN8RelooperD2Ev(r1) {
  var r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13;
  r2 = r1 | 0;
  r3 = r1 + 20 | 0;
  r4 = HEAP32[r3 >> 2];
  L252 : do {
    if ((r4 | 0) != 0) {
      r5 = r1 + 16 | 0;
      r6 = r1 + 4 | 0;
      r7 = 0;
      r8 = r4;
      while (1) {
        r9 = HEAP32[r5 >> 2] + r7 | 0;
        r10 = HEAP32[HEAP32[HEAP32[r6 >> 2] + (r9 >>> 10 << 2) >> 2] + ((r9 & 1023) << 2) >> 2];
        if ((r10 | 0) == 0) {
          r11 = r8;
        } else {
          __ZN5BlockD1Ev(r10);
          __ZdlPv(r10);
          r11 = HEAP32[r3 >> 2];
        }
        r10 = r7 + 1 | 0;
        if (r10 >>> 0 < r11 >>> 0) {
          r7 = r10;
          r8 = r11;
        } else {
          break L252;
        }
      }
    }
  } while (0);
  r11 = r1 + 44 | 0;
  r3 = HEAP32[r11 >> 2];
  if ((r3 | 0) == 0) {
    r12 = r1 + 24 | 0;
    __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEED1Ev(r12);
    __ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEED1Ev(r2);
    return;
  }
  r4 = r1 + 40 | 0;
  r8 = r1 + 28 | 0;
  r7 = 0;
  r6 = r3;
  while (1) {
    r3 = HEAP32[r4 >> 2] + r7 | 0;
    r5 = HEAP32[HEAP32[HEAP32[r8 >> 2] + (r3 >>> 10 << 2) >> 2] + ((r3 & 1023) << 2) >> 2];
    if ((r5 | 0) == 0) {
      r13 = r6;
    } else {
      FUNCTION_TABLE[HEAP32[HEAP32[r5 >> 2] + 4 >> 2]](r5);
      r13 = HEAP32[r11 >> 2];
    }
    r5 = r7 + 1 | 0;
    if (r5 >>> 0 < r13 >>> 0) {
      r7 = r5;
      r6 = r13;
    } else {
      break;
    }
  }
  r12 = r1 + 24 | 0;
  __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEED1Ev(r12);
  __ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEED1Ev(r2);
  return;
}
__ZN8RelooperD2Ev["X"] = 1;
function __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEED1Ev(r1) {
  __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEED2Ev(r1);
  return;
}
function __ZN8Relooper8AddBlockEP5Block(r1, r2) {
  var r3, r4;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 4 | 0;
  r4 = r3;
  HEAP32[r4 >> 2] = r2;
  __ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEE9push_backERKS2_(r1 | 0, r4);
  STACKTOP = r3;
  return;
}
function __ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEE9push_backERKS2_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 8 | 0;
  r4 = r3;
  r5 = HEAP32[r1 + 8 >> 2];
  r6 = HEAP32[r1 + 4 >> 2];
  if ((r5 | 0) == (r6 | 0)) {
    r7 = 0;
  } else {
    r7 = (r5 - r6 << 8) - 1 | 0;
  }
  r6 = (r1 + 20 | 0) >> 2;
  if ((r7 | 0) == (HEAP32[r6] + HEAP32[r1 + 16 >> 2] | 0)) {
    __ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEE19__add_back_capacityEv(r1);
  }
  __ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEE3endEv(r4, r1 | 0);
  r1 = HEAP32[r4 + 4 >> 2];
  if ((r1 | 0) == 0) {
    r8 = HEAP32[r6];
    r9 = r8 + 1 | 0;
    HEAP32[r6] = r9;
    STACKTOP = r3;
    return;
  }
  HEAP32[r1 >> 2] = HEAP32[r2 >> 2];
  r8 = HEAP32[r6];
  r9 = r8 + 1 | 0;
  HEAP32[r6] = r9;
  STACKTOP = r3;
  return;
}
function __ZN8Relooper9CalculateEP5Block(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 80 | 0;
  r4 = r3;
  r5 = r3 + 8;
  r6 = r3 + 16;
  r7 = r3 + 20;
  r8 = r3 + 24;
  r9 = r3 + 40, r10 = r9 >> 2;
  r11 = r3 + 44;
  r12 = r3 + 56;
  r13 = r3 + 68;
  r14 = r3 + 72;
  HEAP32[r7 >> 2] = r2;
  __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizerC1EPS_(r8, r1);
  __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizer8FindLiveES1_(r8, r2);
  r2 = (r1 + 20 | 0) >> 2;
  L285 : do {
    if ((HEAP32[r2] | 0) != 0) {
      r15 = r1 + 16 | 0;
      r16 = r1 + 4 | 0;
      r17 = r8 + 4 | 0;
      r18 = r6 | 0;
      r19 = r8 + 8 | 0;
      r20 = 0;
      while (1) {
        r21 = HEAP32[r15 >> 2] + r20 | 0;
        HEAP32[r10] = HEAP32[HEAP32[HEAP32[r16 >> 2] + (r21 >>> 10 << 2) >> 2] + ((r21 & 1023) << 2) >> 2];
        __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r6, r17, r9);
        L289 : do {
          if ((HEAP32[r18 >> 2] | 0) != (r19 | 0)) {
            r21 = HEAP32[r10];
            r22 = HEAP32[r21 >> 2];
            if ((r22 | 0) == (r21 + 4 | 0)) {
              break;
            } else {
              r23 = r22;
            }
            while (1) {
              r22 = __Znwj(20);
              __ZN6BranchC1EPKcS1_(r22, 0, 0);
              HEAP32[__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(HEAP32[r23 + 16 >> 2] + 12 | 0, r9) >> 2] = r22;
              r22 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r23 | 0);
              if ((r22 | 0) == (HEAP32[r10] + 4 | 0)) {
                break L289;
              } else {
                r23 = r22;
              }
            }
          }
        } while (0);
        r22 = r20 + 1 | 0;
        if (r22 >>> 0 < HEAP32[r2] >>> 0) {
          r20 = r22;
        } else {
          break L285;
        }
      }
    }
  } while (0);
  __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizer13SplitDeadEndsEv(r8);
  r23 = r11 | 0;
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS4_(r23);
  L298 : do {
    if ((HEAP32[r2] | 0) != 0) {
      r10 = r1 + 16 | 0;
      r9 = r1 + 4 | 0;
      r6 = 0;
      while (1) {
        r20 = HEAP32[r10 >> 2] + r6 | 0;
        __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r5, r23, ((r20 & 1023) << 2) + HEAP32[HEAP32[r9 >> 2] + (r20 >>> 10 << 2) >> 2] | 0);
        r20 = r6 + 1 | 0;
        if (r20 >>> 0 < HEAP32[r2] >>> 0) {
          r6 = r20;
        } else {
          break L298;
        }
      }
    }
  } while (0);
  r2 = r12 | 0;
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS4_(r2);
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r4, r2, r7);
  __ZZN8Relooper9CalculateEP5BlockEN8AnalyzerC1E_0PS_(r13, r1);
  r7 = r1 + 48 | 0;
  HEAP32[r7 >> 2] = __ZZN8Relooper9CalculateEP5BlockEN8Analyzer7ProcessE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_P5Shape(r13, r11, r12);
  __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizerC1E_1PS_(r14, r1);
  __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer7ProcessE_1P5Shape(r14, HEAP32[r7 >> 2]);
  __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r12);
  __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r11);
  __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizerD1Ev(r8);
  STACKTOP = r3;
  return;
}
__ZN8Relooper9CalculateEP5Block["X"] = 1;
function __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizerC1EPS_(r1, r2) {
  __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizerC2EPS_(r1, r2);
  return;
}
function __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizer8FindLiveES1_(r1, r2) {
  var r3, r4, r5;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 16 | 0;
  r4 = r3 + 8;
  r5 = r3 + 12;
  HEAP32[r5 >> 2] = r2;
  r2 = r1 + 4 | 0;
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r4, r2, r5);
  if ((HEAP32[r4 >> 2] | 0) != (r1 + 8 | 0)) {
    STACKTOP = r3;
    return;
  }
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r3, r2, r5);
  r2 = HEAP32[r5 >> 2];
  r5 = HEAP32[r2 >> 2];
  r4 = r2 + 4 | 0;
  if ((r5 | 0) == (r4 | 0)) {
    STACKTOP = r3;
    return;
  }
  r2 = r4;
  r4 = r5;
  while (1) {
    __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizer8FindLiveES1_(r1, HEAP32[r4 + 16 >> 2]);
    r5 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r4 | 0);
    if ((r5 | 0) == (r2 | 0)) {
      break;
    } else {
      r4 = r5;
    }
  }
  STACKTOP = r3;
  return;
}
function __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizer13SplitDeadEndsEv(r1) {
  var r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18;
  r2 = STACKTOP;
  STACKTOP = STACKTOP + 20 | 0;
  r3 = r2;
  r4 = r2 + 8;
  r5 = r2 + 12;
  r6 = r2 + 16;
  r7 = r1 + 4 | 0;
  r8 = HEAP32[r7 >> 2];
  r9 = r1 + 8 | 0;
  if ((r8 | 0) == (r9 | 0)) {
    STACKTOP = r2;
    return;
  }
  r10 = r9;
  r9 = r8;
  r11 = 0;
  while (1) {
    r12 = _strlen(HEAP32[HEAP32[r9 + 16 >> 2] + 56 >> 2]) + r11 | 0;
    r13 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r9 | 0);
    if ((r13 | 0) == (r10 | 0)) {
      break;
    } else {
      r9 = r13;
      r11 = r12;
    }
  }
  r11 = (r12 | 0) / 5 & -1;
  r12 = r1 | 0;
  r1 = r8;
  while (1) {
    r8 = HEAP32[r1 + 16 >> 2], r9 = r8 >> 2;
    HEAP32[r4 >> 2] = r8;
    r13 = HEAP32[r9 + 5];
    L327 : do {
      if (r13 >>> 0 >= 2) {
        if ((HEAP32[r9 + 2] | 0) != 0) {
          break;
        }
        if ((_strlen(HEAP32[r9 + 14]) * (r13 - 1) & -1) >>> 0 > r11 >>> 0) {
          break;
        }
        r14 = HEAP32[r9 + 3];
        if ((r14 | 0) == (r8 + 16 | 0)) {
          break;
        } else {
          r15 = r14;
          r16 = r8;
        }
        while (1) {
          HEAP32[r5 >> 2] = HEAP32[r15 + 16 >> 2];
          r14 = __Znwj(68);
          r17 = r14;
          __ZN5BlockC1EPKc(r17, HEAP32[r16 + 56 >> 2]);
          HEAP32[r6 >> 2] = r17;
          r17 = __Znwj(20);
          __ZN6BranchC1EPKcS1_(r17, 0, 0);
          HEAP32[__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(r14 + 12 | 0, r5) >> 2] = r17;
          r17 = __Znwj(20);
          r14 = HEAP32[r5 >> 2];
          r18 = r14 | 0;
          __ZN6BranchC1EPKcS1_(r17, HEAP32[HEAP32[__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(r18, r4) >> 2] + 12 >> 2], HEAP32[HEAP32[__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(r18, r4) >> 2] + 16 >> 2]);
          HEAP32[__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(r18, r6) >> 2] = r17;
          __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__erase_uniqueIS3_EEjRKT_(r14 | 0, r4);
          __ZN8Relooper8AddBlockEP5Block(HEAP32[r12 >> 2], HEAP32[r6 >> 2]);
          __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r3, r7, r6);
          r14 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r15 | 0);
          r17 = HEAP32[r4 >> 2];
          if ((r14 | 0) == (r17 + 16 | 0)) {
            break L327;
          } else {
            r15 = r14;
            r16 = r17;
          }
        }
      }
    } while (0);
    r8 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r1 | 0);
    if ((r8 | 0) == (r10 | 0)) {
      break;
    } else {
      r1 = r8;
    }
  }
  STACKTOP = r2;
  return;
}
__ZZN8Relooper9CalculateEP5BlockEN12PreOptimizer13SplitDeadEndsEv["X"] = 1;
function __ZZN8Relooper9CalculateEP5BlockEN8AnalyzerC1E_0PS_(r1, r2) {
  __ZZN8Relooper9CalculateEP5BlockEN8AnalyzerC2E_0PS_(r1, r2);
  return;
}
function __ZN8Relooper15SetOutputBufferEPci(r1, r2) {
  HEAP32[1311198] = r1;
  HEAP32[1311196] = r1;
  HEAP32[1311195] = r2;
  return;
}
function __ZN8Relooper12SetAsmJSModeEi(r1) {
  HEAP32[1311194] = r1;
  return;
}
function __ZN9LoopShapeD1Ev(r1) {
  return;
}
function __ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEEC2ERKS7_() {
  HEAP32[1310995] = 0;
  HEAP32[1310996] = 0;
  HEAP32[1310994] = 5243980;
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEESD_RKT_(r1, r2, r3) {
  var r4, r5, r6, r7, r8, r9;
  r4 = 0;
  r5 = r1 + 4 | 0;
  r1 = r5 | 0;
  r6 = HEAP32[r1 >> 2];
  if ((r6 | 0) == 0) {
    HEAP32[r2 >> 2] = r5;
    r7 = r1;
    return r7;
  }
  r1 = HEAP32[r3 >> 2];
  r3 = r6;
  while (1) {
    r6 = HEAP32[r3 + 16 >> 2];
    if (r1 >>> 0 < r6 >>> 0) {
      r8 = r3 | 0;
      r5 = HEAP32[r8 >> 2];
      if ((r5 | 0) == 0) {
        r4 = 284;
        break;
      } else {
        r3 = r5;
        continue;
      }
    }
    if (r6 >>> 0 >= r1 >>> 0) {
      r4 = 288;
      break;
    }
    r9 = r3 + 4 | 0;
    r6 = HEAP32[r9 >> 2];
    if ((r6 | 0) == 0) {
      r4 = 287;
      break;
    } else {
      r3 = r6;
    }
  }
  if (r4 == 287) {
    HEAP32[r2 >> 2] = r3;
    r7 = r9;
    return r7;
  } else if (r4 == 284) {
    HEAP32[r2 >> 2] = r3;
    r7 = r8;
    return r7;
  } else if (r4 == 288) {
    HEAP32[r2 >> 2] = r3;
    r7 = r2;
    return r7;
  }
}
function __ZNSt3__118__tree_left_rotateIPNS_16__tree_node_baseIPvEEEEvT_(r1) {
  var r2, r3, r4, r5, r6;
  r2 = r1 + 4 | 0;
  r3 = HEAP32[r2 >> 2];
  r4 = (r3 | 0) >> 2;
  r5 = HEAP32[r4];
  HEAP32[r2 >> 2] = r5;
  if ((r5 | 0) != 0) {
    HEAP32[r5 + 8 >> 2] = r1;
  }
  r5 = (r1 + 8 | 0) >> 2;
  HEAP32[r3 + 8 >> 2] = HEAP32[r5];
  r2 = HEAP32[r5];
  r6 = r2 | 0;
  if ((HEAP32[r6 >> 2] | 0) == (r1 | 0)) {
    HEAP32[r6 >> 2] = r3;
    HEAP32[r4] = r1;
    HEAP32[r5] = r3;
    return;
  } else {
    HEAP32[r2 + 4 >> 2] = r3;
    HEAP32[r4] = r1;
    HEAP32[r5] = r3;
    return;
  }
}
function __ZNSt3__119__tree_right_rotateIPNS_16__tree_node_baseIPvEEEEvT_(r1) {
  var r2, r3, r4, r5, r6;
  r2 = r1 | 0;
  r3 = HEAP32[r2 >> 2];
  r4 = (r3 + 4 | 0) >> 2;
  r5 = HEAP32[r4];
  HEAP32[r2 >> 2] = r5;
  if ((r5 | 0) != 0) {
    HEAP32[r5 + 8 >> 2] = r1;
  }
  r5 = (r1 + 8 | 0) >> 2;
  HEAP32[r3 + 8 >> 2] = HEAP32[r5];
  r2 = HEAP32[r5];
  r6 = r2 | 0;
  if ((HEAP32[r6 >> 2] | 0) == (r1 | 0)) {
    HEAP32[r6 >> 2] = r3;
    HEAP32[r4] = r1;
    HEAP32[r5] = r3;
    return;
  } else {
    HEAP32[r2 + 4 >> 2] = r3;
    HEAP32[r4] = r1;
    HEAP32[r5] = r3;
    return;
  }
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE13__lower_boundIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_SD_SD_(r1, r2, r3, r4) {
  var r5, r6, r7, r8, r9, r10, r11;
  L379 : do {
    if ((r3 | 0) == 0) {
      r5 = r4;
    } else {
      r6 = HEAP32[r2 >> 2];
      r7 = r3;
      r8 = r4;
      while (1) {
        r9 = r7, r10 = r9 >> 2;
        while (1) {
          if (HEAP32[r10 + 4] >>> 0 >= r6 >>> 0) {
            break;
          }
          r11 = HEAP32[r10 + 1];
          if ((r11 | 0) == 0) {
            r5 = r8;
            break L379;
          } else {
            r9 = r11, r10 = r9 >> 2;
          }
        }
        r11 = HEAP32[r10];
        if ((r11 | 0) == 0) {
          r5 = r9;
          break L379;
        } else {
          r7 = r11;
          r8 = r9;
        }
      }
    }
  } while (0);
  HEAP32[r1 >> 2] = r5;
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC2ERKS4_(r1) {
  var r2;
  r2 = r1 + 4 | 0;
  HEAP32[r2 >> 2] = 0;
  HEAP32[r1 + 8 >> 2] = 0;
  HEAP32[r1 >> 2] = r2;
  return;
}
function __ZZN8Relooper9CalculateEP5BlockEN8Analyzer7ProcessE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_P5Shape(r1, r2, r3) {
  var r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58;
  r4 = 0;
  r5 = STACKTOP;
  STACKTOP = STACKTOP + 64 | 0;
  r6 = r5;
  r7 = r5 + 4;
  r8 = r5 + 8;
  r9 = r5 + 12, r10 = r9 >> 2;
  r11 = r5 + 36;
  r12 = r5 + 48;
  r13 = r5 + 52;
  r14 = r5 + 56;
  r15 = r5 + 60;
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS4_(r9 | 0);
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS4_(r9 + 12 | 0);
  r16 = r11 | 0;
  r17 = (r11 + 8 | 0) >> 2;
  r18 = r11 | 0;
  r19 = r11 + 4 | 0;
  r20 = r19;
  r21 = r6 | 0;
  r22 = r8 | 0;
  r23 = r19;
  r19 = 0;
  r24 = r3;
  r3 = 0;
  r25 = 0;
  L390 : while (1) {
    r26 = r19, r27 = r26 >> 2;
    r28 = r24;
    r29 = r3;
    r30 = r25;
    while (1) {
      r31 = 1 - r29 | 0;
      r32 = r9 + r31 * 12 | 0;
      __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE5clearEv(r32 | 0);
      r33 = HEAP32[r28 + 8 >> 2];
      if ((r33 | 0) == 0) {
        r34 = r30;
        r4 = 370;
        break L390;
      } else if ((r33 | 0) != 1) {
        break;
      }
      r33 = HEAP32[HEAP32[r28 >> 2] + 16 >> 2];
      if ((HEAP32[r33 + 20 >> 2] | 0) == 0) {
        r35 = __ZZN8Relooper9CalculateEP5BlockEN8Analyzer10MakeSimpleE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEES1_SA_(r1, r2, r33, r32);
        if ((r26 | 0) != 0) {
          HEAP32[r27 + 2] = r35;
        }
        r33 = (r30 | 0) == 0 ? r35 : r30;
        if ((HEAP32[r10 + (r31 * 3 | 0) + 2] | 0) == 0) {
          r34 = r33;
          r4 = 369;
          break L390;
        } else {
          r26 = r35, r27 = r26 >> 2;
          r28 = r32;
          r29 = r31;
          r30 = r33;
          continue;
        }
      } else {
        r33 = __ZZN8Relooper9CalculateEP5BlockEN8Analyzer8MakeLoopE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_SA_(r1, r2, r28, r32);
        if ((r26 | 0) != 0) {
          HEAP32[r27 + 2] = r33;
        }
        r35 = (r30 | 0) == 0 ? r33 : r30;
        if ((HEAP32[r10 + (r31 * 3 | 0) + 2] | 0) == 0) {
          r34 = r35;
          r4 = 371;
          break L390;
        } else {
          r26 = r33, r27 = r26 >> 2;
          r28 = r32;
          r29 = r31;
          r30 = r35;
          continue;
        }
      }
    }
    __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEEC1ERKSC_(r16);
    __ZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEE(r28, r11);
    r29 = HEAP32[r17];
    do {
      if ((r29 | 0) == 0) {
        r4 = 362;
      } else {
        r35 = HEAP32[r18 >> 2];
        if ((r35 | 0) == (r20 | 0)) {
          r36 = r29;
        } else {
          r33 = r35;
          while (1) {
            r35 = HEAP32[r33 + 16 >> 2];
            r37 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r33 | 0);
            r38 = r37;
            r39 = HEAP32[r35 + 12 >> 2];
            r40 = r35 + 16 | 0;
            L413 : do {
              if ((r39 | 0) != (r40 | 0)) {
                r35 = r33 + 20 | 0;
                r41 = r33 + 24 | 0;
                r42 = r40;
                r43 = r39;
                while (1) {
                  HEAP32[r12 >> 2] = HEAP32[r43 + 16 >> 2];
                  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r8, r35, r12);
                  if ((HEAP32[r22 >> 2] | 0) == (r41 | 0)) {
                    break;
                  }
                  r44 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r43 | 0);
                  if ((r44 | 0) == (r42 | 0)) {
                    break L413;
                  } else {
                    r43 = r44;
                  }
                }
                __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE5eraseENS_21__tree_const_iteratorISA_PKNS_11__tree_nodeISA_PvEEiEE(r7, r16, r33);
              }
            } while (0);
            if ((r37 | 0) == (r23 | 0)) {
              break;
            } else {
              r33 = r38;
            }
          }
          r36 = HEAP32[r17];
        }
        if ((r36 | 0) == 2) {
          r33 = HEAP32[r18 >> 2];
          r39 = HEAP32[r33 + 16 >> 2];
          HEAP32[r13 >> 2] = r39;
          r40 = HEAP32[r33 + 28 >> 2];
          r43 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r33 | 0);
          r33 = HEAP32[r43 + 16 >> 2];
          HEAP32[r14 >> 2] = r33;
          r42 = HEAP32[r43 + 28 >> 2];
          L424 : do {
            if ((r40 | 0) != (r42 | 0)) {
              if ((r40 | 0) > (r42 | 0)) {
                HEAP32[r13 >> 2] = r33;
                HEAP32[r14 >> 2] = r39;
              }
              r43 = __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEEixERSA_(r11, r13);
              r41 = r43 | 0;
              r35 = HEAP32[r43 >> 2];
              r44 = r43 + 4 | 0;
              r43 = r44;
              L430 : do {
                if ((r35 | 0) != (r43 | 0)) {
                  r45 = r44;
                  r46 = r35;
                  while (1) {
                    r47 = HEAP32[r46 + 16 >> 2];
                    r48 = HEAP32[r47 >> 2];
                    r49 = r47 + 4 | 0;
                    L434 : do {
                      if ((r48 | 0) != (r49 | 0)) {
                        r47 = r49;
                        r50 = r48;
                        while (1) {
                          HEAP32[r15 >> 2] = HEAP32[r50 + 16 >> 2];
                          __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r6, r41, r15);
                          if ((HEAP32[r21 >> 2] | 0) == (r43 | 0)) {
                            break L424;
                          }
                          r51 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r50 | 0);
                          if ((r51 | 0) == (r47 | 0)) {
                            break L434;
                          } else {
                            r50 = r51;
                          }
                        }
                      }
                    } while (0);
                    r48 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r46 | 0);
                    if ((r48 | 0) == (r45 | 0)) {
                      break L430;
                    } else {
                      r46 = r48;
                    }
                  }
                }
              } while (0);
              __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE14__erase_uniqueIS3_EEjRKT_(r16, r14);
            }
          } while (0);
          r52 = HEAP32[r17];
        } else {
          r52 = r36;
        }
        if ((r52 | 0) == 0) {
          r4 = 362;
          break;
        }
        r39 = __ZZN8Relooper9CalculateEP5BlockEN8Analyzer12MakeMultipleE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEP5ShapeSA_(r1, r2, r28, r11, r26, r32);
        if ((r26 | 0) != 0) {
          HEAP32[r27 + 2] = r39;
        }
        r33 = (r30 | 0) == 0 ? r39 : r30;
        r42 = (HEAP32[r10 + (r31 * 3 | 0) + 2] | 0) == 0;
        r53 = r42 ? r33 : r54;
        r55 = r42 ? r26 : r39;
        r56 = r42 ? r28 : r32;
        r57 = r33;
        r58 = r42 ? 1 : 2;
        break;
      }
    } while (0);
    if (r4 == 362) {
      r4 = 0;
      r29 = __ZZN8Relooper9CalculateEP5BlockEN8Analyzer8MakeLoopE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_SA_(r1, r2, r28, r32);
      if ((r26 | 0) != 0) {
        HEAP32[r27 + 2] = r29;
      }
      r42 = (r30 | 0) == 0 ? r29 : r30;
      r33 = (HEAP32[r10 + (r31 * 3 | 0) + 2] | 0) == 0;
      r53 = r33 ? r42 : r54;
      r55 = r33 ? r26 : r29;
      r56 = r33 ? r28 : r32;
      r57 = r42;
      r58 = r33 ? 1 : 2;
    }
    __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEED1Ev(r11);
    if ((r58 | 0) == 2) {
      r54 = r53;
      r19 = r55;
      r24 = r56;
      r3 = r31;
      r25 = r57;
    } else {
      r34 = r53;
      r4 = 372;
      break;
    }
  }
  if (r4 == 369) {
    r53 = r9 + 12 | 0;
    __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r53);
    r57 = r9 | 0;
    __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r57);
    STACKTOP = r5;
    return r34;
  } else if (r4 == 370) {
    r53 = r9 + 12 | 0;
    __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r53);
    r57 = r9 | 0;
    __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r57);
    STACKTOP = r5;
    return r34;
  } else if (r4 == 371) {
    r53 = r9 + 12 | 0;
    __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r53);
    r57 = r9 | 0;
    __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r57);
    STACKTOP = r5;
    return r34;
  } else if (r4 == 372) {
    r53 = r9 + 12 | 0;
    __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r53);
    r57 = r9 | 0;
    __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r57);
    STACKTOP = r5;
    return r34;
  }
}
__ZZN8Relooper9CalculateEP5BlockEN8Analyzer7ProcessE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_P5Shape["X"] = 1;
function __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizerC1E_1PS_(r1, r2) {
  __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizerC2E_1PS_(r1, r2);
  return;
}
function __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer7ProcessE_1P5Shape(r1, r2) {
  __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer19RemoveUnneededFlowsE_1P5ShapeS4_(r2, 0);
  __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer16FindLabeledLoopsE_1P5Shape(r1, r2);
  return;
}
function __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r1) {
  __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED2Ev(r1);
  return;
}
function __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizerD1Ev(r1) {
  __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizerD2Ev(r1);
  return;
}
function __ZN8Relooper6RenderEv(r1) {
  var r2;
  HEAP32[1311198] = HEAP32[1311196];
  r2 = HEAP32[r1 + 48 >> 2];
  FUNCTION_TABLE[HEAP32[HEAP32[r2 >> 2] + 8 >> 2]](r2, 0);
  return;
}
function ___cxx_global_var_init() {
  __ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEEC1ERKS7_();
  _atexit(54, 5243976, ___dso_handle);
  return;
}
function __ZNSt3__13mapIPviNS_4lessIS1_EENS_9allocatorINS_4pairIKS1_iEEEEED1Ev(r1) {
  __ZNSt3__13mapIPviNS_4lessIS1_EENS_9allocatorINS_4pairIKS1_iEEEEED2Ev(r1);
  return;
}
function _rl_set_output_buffer(r1, r2) {
  __ZN8Relooper15SetOutputBufferEPci(r1, r2);
  return;
}
Module["_rl_set_output_buffer"] = _rl_set_output_buffer;
function _rl_make_output_buffer(r1) {
  __ZN8Relooper15SetOutputBufferEPci(_malloc(r1), r1);
  return;
}
Module["_rl_make_output_buffer"] = _rl_make_output_buffer;
function _rl_set_asm_js_mode(r1) {
  __ZN8Relooper12SetAsmJSModeEi(r1);
  return;
}
Module["_rl_set_asm_js_mode"] = _rl_set_asm_js_mode;
function _rl_new_block(r1) {
  var r2;
  r2 = __Znwj(68);
  __ZN5BlockC1EPKc(r2, r1);
  return r2;
}
Module["_rl_new_block"] = _rl_new_block;
function _rl_delete_block(r1) {
  if ((r1 | 0) == 0) {
    return;
  }
  __ZN5BlockD1Ev(r1);
  __ZdlPv(r1);
  return;
}
Module["_rl_delete_block"] = _rl_delete_block;
function _rl_block_add_branch_to(r1, r2, r3, r4) {
  __ZN5Block11AddBranchToEPS_PKcS2_(r1, r2, r3, r4);
  return;
}
Module["_rl_block_add_branch_to"] = _rl_block_add_branch_to;
function _rl_new_relooper() {
  var r1;
  r1 = __Znwj(52);
  __ZN8RelooperC1Ev(r1);
  return r1;
}
Module["_rl_new_relooper"] = _rl_new_relooper;
function _rl_delete_relooper(r1) {
  if ((r1 | 0) == 0) {
    return;
  }
  __ZN8RelooperD1Ev(r1);
  __ZdlPv(r1);
  return;
}
Module["_rl_delete_relooper"] = _rl_delete_relooper;
function _rl_relooper_add_block(r1, r2) {
  __ZN8Relooper8AddBlockEP5Block(r1, r2);
  return;
}
Module["_rl_relooper_add_block"] = _rl_relooper_add_block;
function _rl_relooper_calculate(r1, r2) {
  __ZN8Relooper9CalculateEP5Block(r1, r2);
  return;
}
Module["_rl_relooper_calculate"] = _rl_relooper_calculate;
function _rl_relooper_render(r1) {
  __ZN8Relooper6RenderEv(r1);
  return;
}
Module["_rl_relooper_render"] = _rl_relooper_render;
function __ZN13MultipleShapeD1Ev(r1) {
  __ZN13MultipleShapeD2Ev(r1);
  return;
}
function __ZN13MultipleShapeD0Ev(r1) {
  __ZN13MultipleShapeD1Ev(r1);
  __ZdlPv(r1);
  return;
}
function __ZN9LoopShapeD0Ev(r1) {
  __ZdlPv(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEEC1ERKS7_() {
  __ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEEC2ERKS7_();
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r1, r2, r3) {
  var r4, r5, r6, r7, r8, r9, r10;
  r4 = STACKTOP;
  STACKTOP = STACKTOP + 16 | 0;
  r5 = r4;
  r6 = r4 + 4;
  r7 = __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEESD_RKT_(r2, r5, r3);
  r8 = HEAP32[r7 >> 2];
  if ((r8 | 0) == 0) {
    __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE16__construct_nodeERKS2_(r6, r2, r3);
    r3 = r6 | 0;
    r6 = HEAP32[r3 >> 2];
    HEAP32[r3 >> 2] = 0;
    __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSB_SB_(r2, HEAP32[r5 >> 2], r7, r6 | 0);
    r9 = r6;
    r10 = 1;
  } else {
    r9 = r8;
    r10 = 0;
  }
  HEAP32[r1 >> 2] = r9;
  HEAP8[r1 + 4 | 0] = r10;
  STACKTOP = r4;
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE16__construct_nodeERKS2_(r1, r2, r3) {
  var r4, r5, r6, r7;
  r4 = STACKTOP;
  STACKTOP = STACKTOP + 8 | 0;
  r5 = __Znwj(20);
  r6 = r4 + 4 | 0;
  r7 = r4 | 0;
  HEAP8[r7] = HEAP8[r6];
  HEAP8[r7 + 1] = HEAP8[r6 + 1];
  HEAP8[r7 + 2] = HEAP8[r6 + 2];
  r6 = r5 + 16 | 0;
  if ((r6 | 0) != 0) {
    HEAP32[r6 >> 2] = HEAP32[r3 >> 2];
  }
  HEAP32[r1 >> 2] = r5;
  HEAP32[r1 + 4 >> 2] = r2 + 4 | 0;
  HEAP8[r1 + 8 | 0] = 1;
  r2 = r1 + 9 | 0;
  HEAP8[r2] = HEAP8[r7];
  HEAP8[r2 + 1] = HEAP8[r7 + 1];
  HEAP8[r2 + 2] = HEAP8[r7 + 2];
  STACKTOP = r4;
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSB_SB_(r1, r2, r3, r4) {
  var r5, r6;
  HEAP32[r4 >> 2] = 0;
  HEAP32[r4 + 4 >> 2] = 0;
  HEAP32[r4 + 8 >> 2] = r2;
  HEAP32[r3 >> 2] = r4;
  r2 = r1 | 0;
  r5 = HEAP32[HEAP32[r2 >> 2] >> 2];
  if ((r5 | 0) == 0) {
    r6 = r4;
  } else {
    HEAP32[r2 >> 2] = r5;
    r6 = HEAP32[r3 >> 2];
  }
  __ZNSt3__127__tree_balance_after_insertIPNS_16__tree_node_baseIPvEEEEvT_S5_(HEAP32[r1 + 4 >> 2], r6);
  r6 = r1 + 8 | 0;
  HEAP32[r6 >> 2] = HEAP32[r6 >> 2] + 1 | 0;
  return;
}
function __ZNSt3__127__tree_balance_after_insertIPNS_16__tree_node_baseIPvEEEEvT_S5_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14;
  r3 = 0;
  r4 = (r2 | 0) == (r1 | 0);
  HEAP8[r2 + 12 | 0] = r4 & 1;
  if (r4) {
    return;
  } else {
    r5 = r2;
  }
  while (1) {
    r6 = HEAP32[r5 + 8 >> 2];
    r2 = r6 + 12 | 0;
    if ((HEAP8[r2] & 1) << 24 >> 24 != 0) {
      r3 = 435;
      break;
    }
    r7 = (r6 + 8 | 0) >> 2;
    r8 = HEAP32[r7];
    r4 = HEAP32[r8 >> 2];
    if ((r6 | 0) == (r4 | 0)) {
      r9 = HEAP32[r8 + 4 >> 2];
      if ((r9 | 0) == 0) {
        r3 = 420;
        break;
      }
      r10 = r9 + 12 | 0;
      if ((HEAP8[r10] & 1) << 24 >> 24 != 0) {
        r3 = 420;
        break;
      }
      HEAP8[r2] = 1;
      HEAP8[r8 + 12 | 0] = (r8 | 0) == (r1 | 0) & 1;
      HEAP8[r10] = 1;
    } else {
      if ((r4 | 0) == 0) {
        r3 = 427;
        break;
      }
      r10 = r4 + 12 | 0;
      if ((HEAP8[r10] & 1) << 24 >> 24 != 0) {
        r3 = 427;
        break;
      }
      HEAP8[r2] = 1;
      HEAP8[r8 + 12 | 0] = (r8 | 0) == (r1 | 0) & 1;
      HEAP8[r10] = 1;
    }
    if ((r8 | 0) == (r1 | 0)) {
      r3 = 432;
      break;
    } else {
      r5 = r8;
    }
  }
  if (r3 == 420) {
    if ((r5 | 0) == (HEAP32[r6 >> 2] | 0)) {
      r11 = r6;
      r12 = r8;
    } else {
      __ZNSt3__118__tree_left_rotateIPNS_16__tree_node_baseIPvEEEEvT_(r6);
      r1 = HEAP32[r7];
      r11 = r1;
      r12 = HEAP32[r1 + 8 >> 2];
    }
    HEAP8[r11 + 12 | 0] = 1;
    HEAP8[r12 + 12 | 0] = 0;
    __ZNSt3__119__tree_right_rotateIPNS_16__tree_node_baseIPvEEEEvT_(r12);
    return;
  } else if (r3 == 427) {
    if ((r5 | 0) == (HEAP32[r6 >> 2] | 0)) {
      __ZNSt3__119__tree_right_rotateIPNS_16__tree_node_baseIPvEEEEvT_(r6);
      r5 = HEAP32[r7];
      r13 = r5;
      r14 = HEAP32[r5 + 8 >> 2];
    } else {
      r13 = r6;
      r14 = r8;
    }
    HEAP8[r13 + 12 | 0] = 1;
    HEAP8[r14 + 12 | 0] = 0;
    __ZNSt3__118__tree_left_rotateIPNS_16__tree_node_baseIPvEEEEvT_(r14);
    return;
  } else if (r3 == 435) {
    return;
  } else if (r3 == 432) {
    return;
  }
}
__ZNSt3__127__tree_balance_after_insertIPNS_16__tree_node_baseIPvEEEEvT_S5_["X"] = 1;
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r1, r2, r3) {
  var r4, r5, r6;
  r4 = STACKTOP;
  STACKTOP = STACKTOP + 4 | 0;
  r5 = r4;
  r6 = r2 + 4 | 0;
  r2 = r6;
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE13__lower_boundIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_SD_SD_(r5, r3, HEAP32[r6 >> 2], r2);
  r6 = HEAP32[r5 >> 2];
  do {
    if ((r6 | 0) != (r2 | 0)) {
      if (HEAP32[r3 >> 2] >>> 0 < HEAP32[r6 + 16 >> 2] >>> 0) {
        break;
      }
      HEAP32[r1 >> 2] = r6;
      STACKTOP = r4;
      return;
    }
  } while (0);
  HEAP32[r1 >> 2] = r2;
  STACKTOP = r4;
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS4_(r1) {
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC2ERKS4_(r1);
  return;
}
function __ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEE3endEv(r1, r2) {
  var r3, r4, r5, r6;
  r3 = HEAP32[r2 + 16 >> 2] + HEAP32[r2 + 20 >> 2] | 0;
  r4 = HEAP32[r2 + 4 >> 2];
  r5 = (r3 >>> 10 << 2) + r4 | 0;
  if ((HEAP32[r2 + 8 >> 2] | 0) == (r4 | 0)) {
    r6 = 0;
  } else {
    r6 = ((r3 & 1023) << 2) + HEAP32[r5 >> 2] | 0;
  }
  HEAP32[r1 >> 2] = r5;
  HEAP32[r1 + 4 >> 2] = r6;
  return;
}
function __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r1, r2, r3) {
  var r4, r5, r6, r7;
  if ((r3 | 0) == (r2 | 0)) {
    return;
  }
  r4 = (r1 + 8 | 0) >> 2;
  r1 = r2;
  r2 = HEAP32[r4];
  while (1) {
    if ((r2 | 0) == 0) {
      r5 = 0;
    } else {
      HEAP32[r2 >> 2] = HEAP32[r1 >> 2];
      r5 = HEAP32[r4];
    }
    r6 = r5 + 4 | 0;
    HEAP32[r4] = r6;
    r7 = r1 + 4 | 0;
    if ((r7 | 0) == (r3 | 0)) {
      break;
    } else {
      r1 = r7;
      r2 = r6;
    }
  }
  return;
}
function __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r1) {
  var r2, r3, r4;
  r2 = HEAP32[r1 + 4 >> 2];
  if ((r2 | 0) == 0) {
    r3 = r1;
    while (1) {
      r1 = HEAP32[r3 + 8 >> 2];
      if ((r3 | 0) == (HEAP32[r1 >> 2] | 0)) {
        r4 = r1;
        break;
      } else {
        r3 = r1;
      }
    }
    return r4;
  } else {
    r3 = r2;
    while (1) {
      r2 = HEAP32[r3 >> 2];
      if ((r2 | 0) == 0) {
        r4 = r3;
        break;
      } else {
        r3 = r2;
      }
    }
    return r4;
  }
}
function __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE13__lower_boundIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_SJ_SJ_(r1, r2, r3, r4) {
  var r5, r6, r7, r8, r9, r10, r11;
  L561 : do {
    if ((r3 | 0) == 0) {
      r5 = r4;
    } else {
      r6 = HEAP32[r2 >> 2];
      r7 = r3;
      r8 = r4;
      while (1) {
        r9 = r7, r10 = r9 >> 2;
        while (1) {
          if (HEAP32[r10 + 4] >>> 0 >= r6 >>> 0) {
            break;
          }
          r11 = HEAP32[r10 + 1];
          if ((r11 | 0) == 0) {
            r5 = r8;
            break L561;
          } else {
            r9 = r11, r10 = r9 >> 2;
          }
        }
        r11 = HEAP32[r10];
        if ((r11 | 0) == 0) {
          r5 = r9;
          break L561;
        } else {
          r7 = r11;
          r8 = r9;
        }
      }
    }
  } while (0);
  HEAP32[r1 >> 2] = r5;
  return;
}
function __ZNSt3__114__split_bufferIPP5BlockNS_9allocatorIS3_EEE10push_frontERKS3_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 20 | 0;
  r4 = r3;
  r5 = (r1 + 4 | 0) >> 2;
  r6 = HEAP32[r5];
  r7 = (r1 | 0) >> 2;
  do {
    if ((r6 | 0) == (HEAP32[r7] | 0)) {
      r8 = (r1 + 8 | 0) >> 2;
      r9 = HEAP32[r8];
      r10 = r1 + 12 | 0;
      r11 = (r10 | 0) >> 2;
      r12 = HEAP32[r11];
      r13 = r12;
      if (r9 >>> 0 < r12 >>> 0) {
        r12 = r9;
        r14 = (r13 - r12 + 4 >> 2 | 0) / 2 & -1;
        r15 = r12 - r6 | 0;
        r12 = (r14 - (r15 >> 2) << 2) + r9 | 0;
        _memmove(r12, r6, r15, 4, 0);
        HEAP32[r5] = r12;
        HEAP32[r8] = (r14 << 2) + HEAP32[r8] | 0;
        r16 = r12;
        break;
      } else {
        r12 = r13 - r6 >> 1;
        r13 = (r12 | 0) == 0 ? 1 : r12;
        __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEEC1EjjS6_(r4, r13, (r13 + 3 | 0) >>> 2, r10);
        __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r4, HEAP32[r5], HEAP32[r8]);
        r10 = r4 | 0;
        r13 = HEAP32[r7];
        HEAP32[r7] = HEAP32[r10 >> 2];
        HEAP32[r10 >> 2] = r13;
        r13 = r4 + 4 | 0;
        r10 = HEAP32[r5];
        HEAP32[r5] = HEAP32[r13 >> 2];
        HEAP32[r13 >> 2] = r10;
        r10 = r4 + 8 | 0;
        r13 = HEAP32[r8];
        HEAP32[r8] = HEAP32[r10 >> 2];
        HEAP32[r10 >> 2] = r13;
        r13 = r4 + 12 | 0;
        r10 = HEAP32[r11];
        HEAP32[r11] = HEAP32[r13 >> 2];
        HEAP32[r13 >> 2] = r10;
        __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEED1Ev(r4);
        r16 = HEAP32[r5];
        break;
      }
    } else {
      r16 = r6;
    }
  } while (0);
  r6 = r16 - 4 | 0;
  if ((r6 | 0) == 0) {
    r17 = r16;
    r18 = r17 - 4 | 0;
    HEAP32[r5] = r18;
    STACKTOP = r3;
    return;
  }
  HEAP32[r6 >> 2] = HEAP32[r2 >> 2];
  r17 = HEAP32[r5];
  r18 = r17 - 4 | 0;
  HEAP32[r5] = r18;
  STACKTOP = r3;
  return;
}
__ZNSt3__114__split_bufferIPP5BlockNS_9allocatorIS3_EEE10push_frontERKS3_["X"] = 1;
function __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEEC1EjjS6_(r1, r2, r3, r4) {
  __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEEC2EjjS6_(r1, r2, r3, r4);
  return;
}
function __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEE10push_frontERKS3_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 20 | 0;
  r4 = r3;
  r5 = (r1 + 4 | 0) >> 2;
  r6 = HEAP32[r5];
  r7 = (r1 | 0) >> 2;
  do {
    if ((r6 | 0) == (HEAP32[r7] | 0)) {
      r8 = (r1 + 8 | 0) >> 2;
      r9 = HEAP32[r8];
      r10 = (r1 + 12 | 0) >> 2;
      r11 = HEAP32[r10];
      r12 = r11;
      if (r9 >>> 0 < r11 >>> 0) {
        r11 = r9;
        r13 = (r12 - r11 + 4 >> 2 | 0) / 2 & -1;
        r14 = r11 - r6 | 0;
        r11 = (r13 - (r14 >> 2) << 2) + r9 | 0;
        _memmove(r11, r6, r14, 4, 0);
        HEAP32[r5] = r11;
        HEAP32[r8] = (r13 << 2) + HEAP32[r8] | 0;
        r15 = r11;
        break;
      } else {
        r11 = r12 - r6 >> 1;
        r12 = (r11 | 0) == 0 ? 1 : r11;
        __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEEC1EjjS6_(r4, r12, (r12 + 3 | 0) >>> 2, HEAP32[r1 + 16 >> 2]);
        __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r4, HEAP32[r5], HEAP32[r8]);
        r12 = r4 | 0;
        r11 = HEAP32[r7];
        HEAP32[r7] = HEAP32[r12 >> 2];
        HEAP32[r12 >> 2] = r11;
        r11 = r4 + 4 | 0;
        r12 = HEAP32[r5];
        HEAP32[r5] = HEAP32[r11 >> 2];
        HEAP32[r11 >> 2] = r12;
        r12 = r4 + 8 | 0;
        r11 = HEAP32[r8];
        HEAP32[r8] = HEAP32[r12 >> 2];
        HEAP32[r12 >> 2] = r11;
        r11 = r4 + 12 | 0;
        r12 = HEAP32[r10];
        HEAP32[r10] = HEAP32[r11 >> 2];
        HEAP32[r11 >> 2] = r12;
        __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEED1Ev(r4);
        r15 = HEAP32[r5];
        break;
      }
    } else {
      r15 = r6;
    }
  } while (0);
  r6 = r15 - 4 | 0;
  if ((r6 | 0) == 0) {
    r16 = r15;
    r17 = r16 - 4 | 0;
    HEAP32[r5] = r17;
    STACKTOP = r3;
    return;
  }
  HEAP32[r6 >> 2] = HEAP32[r2 >> 2];
  r16 = HEAP32[r5];
  r17 = r16 - 4 | 0;
  HEAP32[r5] = r17;
  STACKTOP = r3;
  return;
}
__ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEE10push_frontERKS3_["X"] = 1;
function __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEED1Ev(r1) {
  __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEED2Ev(r1);
  return;
}
function __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEED2Ev(r1) {
  var r2;
  HEAP32[r1 + 8 >> 2] = HEAP32[r1 + 4 >> 2];
  r2 = HEAP32[r1 >> 2];
  if ((r2 | 0) == 0) {
    return;
  }
  __ZdlPv(r2);
  return;
}
function __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEEC2EjjS6_(r1, r2, r3, r4) {
  var r5, r6;
  r5 = r1 + 12 | 0;
  HEAP32[r5 >> 2] = 0;
  HEAP32[r1 + 16 >> 2] = r4;
  if ((r2 | 0) == 0) {
    r6 = 0;
  } else {
    r6 = __Znwj(r2 << 2);
  }
  HEAP32[r1 >> 2] = r6;
  r4 = (r3 << 2) + r6 | 0;
  HEAP32[r1 + 8 >> 2] = r4;
  HEAP32[r1 + 4 >> 2] = r4;
  HEAP32[r5 >> 2] = (r2 << 2) + r6 | 0;
  return;
}
function __ZNSt3__114__split_bufferIPP5ShapeNS_9allocatorIS3_EEED1Ev(r1) {
  __ZNSt3__114__split_bufferIPP5ShapeNS_9allocatorIS3_EEED2Ev(r1);
  return;
}
function __ZNSt3__114__split_bufferIPP5ShapeNS_9allocatorIS3_EEED2Ev(r1) {
  var r2;
  HEAP32[r1 + 8 >> 2] = HEAP32[r1 + 4 >> 2];
  r2 = HEAP32[r1 >> 2];
  if ((r2 | 0) == 0) {
    return;
  }
  __ZdlPv(r2);
  return;
}
function __ZNSt3__114__split_bufferIPP5BlockNS_9allocatorIS3_EEED1Ev(r1) {
  __ZNSt3__114__split_bufferIPP5BlockNS_9allocatorIS3_EEED2Ev(r1);
  return;
}
function __ZNSt3__114__split_bufferIPP5BlockNS_9allocatorIS3_EEED2Ev(r1) {
  var r2;
  HEAP32[r1 + 8 >> 2] = HEAP32[r1 + 4 >> 2];
  r2 = HEAP32[r1 >> 2];
  if ((r2 | 0) == 0) {
    return;
  }
  __ZdlPv(r2);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_(r1, r2, r3) {
  var r4, r5, r6;
  r4 = STACKTOP;
  STACKTOP = STACKTOP + 4 | 0;
  r5 = r4;
  r6 = r2 + 4 | 0;
  r2 = r6;
  __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE13__lower_boundIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_SJ_SJ_(r5, r3, HEAP32[r6 >> 2], r2);
  r6 = HEAP32[r5 >> 2];
  do {
    if ((r6 | 0) != (r2 | 0)) {
      if (HEAP32[r3 >> 2] >>> 0 < HEAP32[r6 + 16 >> 2] >>> 0) {
        break;
      }
      HEAP32[r1 >> 2] = r6;
      STACKTOP = r4;
      return;
    }
  } while (0);
  HEAP32[r1 >> 2] = r2;
  STACKTOP = r4;
  return;
}
function __ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEE19__add_back_capacityEv(r1) {
  var r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32;
  r2 = STACKTOP;
  STACKTOP = STACKTOP + 104 | 0;
  r3 = r2;
  r4 = r2 + 20;
  r5 = r2 + 40;
  r6 = r2 + 60;
  r7 = r2 + 80;
  r8 = r2 + 84;
  r9 = r1 + 16 | 0;
  r10 = HEAP32[r9 >> 2];
  if (r10 >>> 0 > 1023) {
    HEAP32[r9 >> 2] = r10 - 1024 | 0;
    r10 = (r1 + 4 | 0) >> 2;
    r9 = HEAP32[r10];
    r11 = HEAP32[r9 >> 2];
    r12 = r9 + 4 | 0;
    HEAP32[r10] = r12;
    r13 = (r1 + 8 | 0) >> 2;
    r14 = HEAP32[r13];
    r15 = r1 + 12 | 0;
    r16 = (r15 | 0) >> 2;
    do {
      if ((r14 | 0) == (HEAP32[r16] | 0)) {
        r17 = (r1 | 0) >> 2;
        r18 = HEAP32[r17];
        if (r12 >>> 0 > r18 >>> 0) {
          r19 = r12;
          r20 = (r19 - r18 + 4 >> 2 | 0) / -2 & -1;
          r21 = r20 + 1 | 0;
          r22 = r14 - r19 | 0;
          _memmove((r21 << 2) + r9 | 0, r12, r22, 4, 0);
          r19 = ((r22 >> 2) + r21 << 2) + r9 | 0;
          HEAP32[r13] = r19;
          HEAP32[r10] = (r20 << 2) + HEAP32[r10] | 0;
          r23 = r19;
          break;
        } else {
          r19 = r14 - r18 >> 1;
          r18 = (r19 | 0) == 0 ? 1 : r19;
          __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEEC1EjjS6_(r6, r18, r18 >>> 2, r15);
          __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r6, HEAP32[r10], HEAP32[r13]);
          r18 = r6 | 0;
          r19 = HEAP32[r17];
          HEAP32[r17] = HEAP32[r18 >> 2];
          HEAP32[r18 >> 2] = r19;
          r19 = r6 + 4 | 0;
          r18 = HEAP32[r10];
          HEAP32[r10] = HEAP32[r19 >> 2];
          HEAP32[r19 >> 2] = r18;
          r18 = r6 + 8 | 0;
          r19 = HEAP32[r13];
          HEAP32[r13] = HEAP32[r18 >> 2];
          HEAP32[r18 >> 2] = r19;
          r19 = r6 + 12 | 0;
          r18 = HEAP32[r16];
          HEAP32[r16] = HEAP32[r19 >> 2];
          HEAP32[r19 >> 2] = r18;
          __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEED1Ev(r6);
          r23 = HEAP32[r13];
          break;
        }
      } else {
        r23 = r14;
      }
    } while (0);
    if ((r23 | 0) == 0) {
      r24 = 0;
    } else {
      HEAP32[r23 >> 2] = r11;
      r24 = HEAP32[r13];
    }
    HEAP32[r13] = r24 + 4 | 0;
    STACKTOP = r2;
    return;
  }
  r24 = r1 | 0;
  r13 = (r1 + 8 | 0) >> 2;
  r11 = HEAP32[r13];
  r23 = (r1 + 4 | 0) >> 2;
  r14 = r11 - HEAP32[r23] >> 2;
  r6 = r1 + 12 | 0;
  r16 = (r6 | 0) >> 2;
  r10 = HEAP32[r16];
  r15 = (r1 | 0) >> 2;
  r1 = r10 - HEAP32[r15] | 0;
  if (r14 >>> 0 >= r1 >> 2 >>> 0) {
    r9 = r1 >> 1;
    __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEEC1EjjS6_(r8, (r9 | 0) == 0 ? 1 : r9, r14, r6);
    r14 = __Znwj(4096);
    r9 = (r8 + 8 | 0) >> 2;
    r1 = HEAP32[r9];
    r12 = (r8 + 12 | 0) >> 2;
    do {
      if ((r1 | 0) == (HEAP32[r12] | 0)) {
        r18 = (r8 + 4 | 0) >> 2;
        r19 = HEAP32[r18];
        r17 = r8 | 0;
        r20 = HEAP32[r17 >> 2];
        if (r19 >>> 0 > r20 >>> 0) {
          r21 = r19;
          r22 = (r21 - r20 + 4 >> 2 | 0) / -2 & -1;
          r25 = (r22 << 2) + r19 | 0;
          r26 = r1 - r21 | 0;
          _memmove(r25, r19, r26, 4, 0);
          r21 = ((r26 >> 2) + r22 << 2) + r19 | 0;
          HEAP32[r9] = r21;
          HEAP32[r18] = r25;
          r27 = r21;
          break;
        }
        r21 = r1 - r20 >> 1;
        r25 = (r21 | 0) == 0 ? 1 : r21;
        __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEEC1EjjS6_(r3, r25, r25 >>> 2, HEAP32[r8 + 16 >> 2]);
        __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r3, r19, r1);
        r25 = r3 | 0;
        HEAP32[r17 >> 2] = HEAP32[r25 >> 2];
        HEAP32[r25 >> 2] = r20;
        r20 = r3 + 4 | 0;
        HEAP32[r18] = HEAP32[r20 >> 2];
        HEAP32[r20 >> 2] = r19;
        r19 = r3 + 8 | 0;
        r20 = HEAP32[r19 >> 2];
        HEAP32[r9] = r20;
        HEAP32[r19 >> 2] = r1;
        r19 = r3 + 12 | 0;
        HEAP32[r12] = HEAP32[r19 >> 2];
        HEAP32[r19 >> 2] = r1;
        __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEED1Ev(r3);
        r27 = r20;
      } else {
        r27 = r1;
      }
    } while (0);
    if ((r27 | 0) == 0) {
      r28 = 0;
    } else {
      HEAP32[r27 >> 2] = r14;
      r28 = r27;
    }
    HEAP32[r9] = r28 + 4 | 0;
    r28 = HEAP32[r13];
    while (1) {
      if ((r28 | 0) == (HEAP32[r23] | 0)) {
        break;
      }
      r27 = r28 - 4 | 0;
      __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEE10push_frontERKS3_(r8, r27);
      r28 = r27;
    }
    r27 = r8 | 0;
    r14 = HEAP32[r15];
    HEAP32[r15] = HEAP32[r27 >> 2];
    HEAP32[r27 >> 2] = r14;
    r14 = r8 + 4 | 0;
    HEAP32[r23] = HEAP32[r14 >> 2];
    HEAP32[r14 >> 2] = r28;
    r28 = HEAP32[r13];
    HEAP32[r13] = HEAP32[r9];
    HEAP32[r9] = r28;
    r28 = HEAP32[r16];
    HEAP32[r16] = HEAP32[r12];
    HEAP32[r12] = r28;
    __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEED1Ev(r8);
    STACKTOP = r2;
    return;
  }
  r8 = __Znwj(4096);
  if ((r10 | 0) == (r11 | 0)) {
    HEAP32[r7 >> 2] = r8;
    __ZNSt3__114__split_bufferIPP5BlockNS_9allocatorIS3_EEE10push_frontERKS3_(r24, r7);
    r7 = HEAP32[r23];
    r24 = HEAP32[r7 >> 2];
    r11 = r7 + 4 | 0;
    HEAP32[r23] = r11;
    r10 = HEAP32[r13];
    do {
      if ((r10 | 0) == (HEAP32[r16] | 0)) {
        r28 = HEAP32[r15];
        if (r11 >>> 0 > r28 >>> 0) {
          r12 = r11;
          r9 = (r12 - r28 + 4 >> 2 | 0) / -2 & -1;
          r14 = r9 + 1 | 0;
          r27 = r10 - r12 | 0;
          _memmove((r14 << 2) + r7 | 0, r11, r27, 4, 0);
          r12 = ((r27 >> 2) + r14 << 2) + r7 | 0;
          HEAP32[r13] = r12;
          HEAP32[r23] = (r9 << 2) + HEAP32[r23] | 0;
          r29 = r12;
          break;
        } else {
          r12 = r10 - r28 >> 1;
          r28 = (r12 | 0) == 0 ? 1 : r12;
          __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEEC1EjjS6_(r4, r28, r28 >>> 2, r6);
          __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r4, HEAP32[r23], HEAP32[r13]);
          r28 = r4 | 0;
          r12 = HEAP32[r15];
          HEAP32[r15] = HEAP32[r28 >> 2];
          HEAP32[r28 >> 2] = r12;
          r12 = r4 + 4 | 0;
          r28 = HEAP32[r23];
          HEAP32[r23] = HEAP32[r12 >> 2];
          HEAP32[r12 >> 2] = r28;
          r28 = r4 + 8 | 0;
          r12 = HEAP32[r13];
          HEAP32[r13] = HEAP32[r28 >> 2];
          HEAP32[r28 >> 2] = r12;
          r12 = r4 + 12 | 0;
          r28 = HEAP32[r16];
          HEAP32[r16] = HEAP32[r12 >> 2];
          HEAP32[r12 >> 2] = r28;
          __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEED1Ev(r4);
          r29 = HEAP32[r13];
          break;
        }
      } else {
        r29 = r10;
      }
    } while (0);
    if ((r29 | 0) == 0) {
      r30 = 0;
    } else {
      HEAP32[r29 >> 2] = r24;
      r30 = HEAP32[r13];
    }
    HEAP32[r13] = r30 + 4 | 0;
    STACKTOP = r2;
    return;
  } else {
    r30 = HEAP32[r13];
    do {
      if ((r30 | 0) == (HEAP32[r16] | 0)) {
        r24 = HEAP32[r23];
        r29 = HEAP32[r15];
        if (r24 >>> 0 > r29 >>> 0) {
          r10 = r24;
          r4 = (r10 - r29 + 4 >> 2 | 0) / -2 & -1;
          r7 = r30 - r10 | 0;
          _memmove((r4 << 2) + r24 | 0, r24, r7, 4, 0);
          r10 = ((r7 >> 2) + r4 << 2) + r24 | 0;
          HEAP32[r13] = r10;
          HEAP32[r23] = (r4 << 2) + HEAP32[r23] | 0;
          r31 = r10;
          break;
        } else {
          r10 = r30 - r29 >> 1;
          r29 = (r10 | 0) == 0 ? 1 : r10;
          __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEEC1EjjS6_(r5, r29, r29 >>> 2, r6);
          __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r5, HEAP32[r23], HEAP32[r13]);
          r29 = r5 | 0;
          r10 = HEAP32[r15];
          HEAP32[r15] = HEAP32[r29 >> 2];
          HEAP32[r29 >> 2] = r10;
          r10 = r5 + 4 | 0;
          r29 = HEAP32[r23];
          HEAP32[r23] = HEAP32[r10 >> 2];
          HEAP32[r10 >> 2] = r29;
          r29 = r5 + 8 | 0;
          r10 = HEAP32[r13];
          HEAP32[r13] = HEAP32[r29 >> 2];
          HEAP32[r29 >> 2] = r10;
          r10 = r5 + 12 | 0;
          r29 = HEAP32[r16];
          HEAP32[r16] = HEAP32[r10 >> 2];
          HEAP32[r10 >> 2] = r29;
          __ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEED1Ev(r5);
          r31 = HEAP32[r13];
          break;
        }
      } else {
        r31 = r30;
      }
    } while (0);
    if ((r31 | 0) == 0) {
      r32 = 0;
    } else {
      HEAP32[r31 >> 2] = r8;
      r32 = HEAP32[r13];
    }
    HEAP32[r13] = r32 + 4 | 0;
    STACKTOP = r2;
    return;
  }
}
__ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEE19__add_back_capacityEv["X"] = 1;
function __ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEE16__find_equal_keyERPNS_16__tree_node_baseIPvEERS9_(r1, r2, r3) {
  var r4, r5, r6, r7, r8, r9;
  r4 = 0;
  r5 = r1 + 4 | 0;
  r1 = r5 | 0;
  r6 = HEAP32[r1 >> 2];
  if ((r6 | 0) == 0) {
    HEAP32[r2 >> 2] = r5;
    r7 = r1;
    return r7;
  }
  r1 = HEAP32[r3 >> 2];
  r3 = r6;
  while (1) {
    r6 = HEAP32[r3 + 16 >> 2];
    if (r1 >>> 0 < r6 >>> 0) {
      r8 = r3 | 0;
      r5 = HEAP32[r8 >> 2];
      if ((r5 | 0) == 0) {
        r4 = 566;
        break;
      } else {
        r3 = r5;
        continue;
      }
    }
    if (r6 >>> 0 >= r1 >>> 0) {
      r4 = 570;
      break;
    }
    r9 = r3 + 4 | 0;
    r6 = HEAP32[r9 >> 2];
    if ((r6 | 0) == 0) {
      r4 = 569;
      break;
    } else {
      r3 = r6;
    }
  }
  if (r4 == 570) {
    HEAP32[r2 >> 2] = r3;
    r7 = r2;
    return r7;
  } else if (r4 == 569) {
    HEAP32[r2 >> 2] = r3;
    r7 = r9;
    return r7;
  } else if (r4 == 566) {
    HEAP32[r2 >> 2] = r3;
    r7 = r8;
    return r7;
  }
}
function __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE13__lower_boundIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_SJ_SJ_(r1, r2, r3, r4) {
  var r5, r6, r7, r8, r9, r10, r11;
  L697 : do {
    if ((r3 | 0) == 0) {
      r5 = r4;
    } else {
      r6 = HEAP32[r2 >> 2];
      r7 = r3;
      r8 = r4;
      while (1) {
        r9 = r7, r10 = r9 >> 2;
        while (1) {
          if (HEAP32[r10 + 4] >>> 0 >= r6 >>> 0) {
            break;
          }
          r11 = HEAP32[r10 + 1];
          if ((r11 | 0) == 0) {
            r5 = r8;
            break L697;
          } else {
            r9 = r11, r10 = r9 >> 2;
          }
        }
        r11 = HEAP32[r10];
        if ((r11 | 0) == 0) {
          r5 = r9;
          break L697;
        } else {
          r7 = r11;
          r8 = r9;
        }
      }
    }
  } while (0);
  HEAP32[r1 >> 2] = r5;
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC2ERKSA_(r1) {
  var r2;
  r2 = r1 + 4 | 0;
  HEAP32[r2 >> 2] = 0;
  HEAP32[r1 + 8 >> 2] = 0;
  HEAP32[r1 >> 2] = r2;
  return;
}
function __ZN5Shape8IsSimpleEPS_(r1) {
  var r2;
  do {
    if ((r1 | 0) == 0) {
      r2 = 0;
    } else {
      if ((HEAP32[r1 + 12 >> 2] | 0) != 0) {
        r2 = 0;
        break;
      }
      r2 = r1;
    }
  } while (0);
  return r2;
}
function __ZN5Shape6IsLoopEPS_(r1) {
  var r2;
  do {
    if ((r1 | 0) == 0) {
      r2 = 0;
    } else {
      if ((HEAP32[r1 + 12 >> 2] | 0) != 2) {
        r2 = 0;
        break;
      }
      r2 = r1;
    }
  } while (0);
  return r2;
}
function __ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEE16__construct_nodeERS9_(r1, r2, r3) {
  var r4, r5;
  r4 = __Znwj(24);
  r5 = r4 + 16 | 0;
  if ((r5 | 0) != 0) {
    HEAP32[r5 >> 2] = HEAP32[r3 >> 2];
  }
  r3 = r4 + 20 | 0;
  if ((r3 | 0) != 0) {
    HEAP32[r3 >> 2] = 0;
  }
  HEAP32[r1 >> 2] = r4;
  HEAP32[r1 + 4 >> 2] = r2 + 4 | 0;
  HEAP8[r1 + 8 | 0] = 1;
  HEAP8[r1 + 9 | 0] = 1;
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSH_SH_(r1, r2, r3, r4) {
  var r5, r6;
  HEAP32[r4 >> 2] = 0;
  HEAP32[r4 + 4 >> 2] = 0;
  HEAP32[r4 + 8 >> 2] = r2;
  HEAP32[r3 >> 2] = r4;
  r2 = r1 | 0;
  r5 = HEAP32[HEAP32[r2 >> 2] >> 2];
  if ((r5 | 0) == 0) {
    r6 = r4;
  } else {
    HEAP32[r2 >> 2] = r5;
    r6 = HEAP32[r3 >> 2];
  }
  __ZNSt3__127__tree_balance_after_insertIPNS_16__tree_node_baseIPvEEEEvT_S5_(HEAP32[r1 + 4 >> 2], r6);
  r6 = r1 + 8 | 0;
  HEAP32[r6 >> 2] = HEAP32[r6 >> 2] + 1 | 0;
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_(r1, r2, r3) {
  var r4, r5, r6;
  r4 = STACKTOP;
  STACKTOP = STACKTOP + 4 | 0;
  r5 = r4;
  r6 = r2 + 4 | 0;
  r2 = r6;
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE13__lower_boundIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_SJ_SJ_(r5, r3, HEAP32[r6 >> 2], r2);
  r6 = HEAP32[r5 >> 2];
  do {
    if ((r6 | 0) != (r2 | 0)) {
      if (HEAP32[r3 >> 2] >>> 0 < HEAP32[r6 + 16 >> 2] >>> 0) {
        break;
      }
      HEAP32[r1 >> 2] = r6;
      STACKTOP = r4;
      return;
    }
  } while (0);
  HEAP32[r1 >> 2] = r2;
  STACKTOP = r4;
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC1ERKSA_(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC2ERKSA_(r1);
  return;
}
function __ZN13MultipleShapeD2Ev(r1) {
  HEAP32[r1 >> 2] = 5244400;
  __ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED1Ev(r1 + 20 | 0);
  return;
}
function __ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED1Ev(r1) {
  __ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED2Ev(r1);
  return;
}
function __ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED2Ev(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEED1Ev(HEAP32[r1 + 4 >> 2]);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEED1Ev(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEED2Ev(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEED2Ev(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE(r1) {
  if ((r1 | 0) == 0) {
    return;
  } else {
    __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE(HEAP32[r1 >> 2]);
    __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE(HEAP32[r1 + 4 >> 2]);
    __ZdlPv(r1);
    return;
  }
}
function __ZNSt3__13mapIPviNS_4lessIS1_EENS_9allocatorINS_4pairIKS1_iEEEEED2Ev(r1) {
  __ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEED1Ev(HEAP32[r1 + 4 >> 2]);
  return;
}
function __ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEED1Ev(r1) {
  __ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEED2Ev(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEED2Ev(r1) {
  __ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEE7destroyEPNS_11__tree_nodeIS3_S2_EE(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEE7destroyEPNS_11__tree_nodeIS3_S2_EE(r1) {
  if ((r1 | 0) == 0) {
    return;
  } else {
    __ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEE7destroyEPNS_11__tree_nodeIS3_S2_EE(HEAP32[r1 >> 2]);
    __ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEE7destroyEPNS_11__tree_nodeIS3_S2_EE(HEAP32[r1 + 4 >> 2]);
    __ZdlPv(r1);
    return;
  }
}
function __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizerD2Ev(r1) {
  __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r1 + 4 | 0);
  return;
}
function __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED2Ev(r1) {
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(HEAP32[r1 + 4 >> 2]);
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r1) {
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED2Ev(r1);
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED2Ev(r1) {
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE7destroyEPNS_11__tree_nodeIS2_PvEE(r1);
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE7destroyEPNS_11__tree_nodeIS2_PvEE(r1) {
  if ((r1 | 0) == 0) {
    return;
  } else {
    __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE7destroyEPNS_11__tree_nodeIS2_PvEE(HEAP32[r1 >> 2]);
    __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE7destroyEPNS_11__tree_nodeIS2_PvEE(HEAP32[r1 + 4 >> 2]);
    __ZdlPv(r1);
    return;
  }
}
function __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer19RemoveUnneededFlowsE_1P5ShapeS4_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11;
  r3 = 0;
  r4 = r1;
  while (1) {
    r5 = __ZN5Shape8IsSimpleEPS_(r4);
    if ((r5 | 0) != 0) {
      r1 = HEAP32[r5 + 8 >> 2];
      if ((r1 | 0) == 0) {
        break;
      } else {
        r4 = r1;
        continue;
      }
    }
    r1 = __ZN5Shape10IsMultipleEPS_(r4);
    if ((r1 | 0) == 0) {
      r6 = __ZN5Shape6IsLoopEPS_(r4);
      if ((r6 | 0) == 0) {
        r3 = 647;
        break;
      }
      r7 = HEAP32[r6 + 20 >> 2];
      __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer19RemoveUnneededFlowsE_1P5ShapeS4_(r7, r7);
      r4 = HEAP32[r6 + 8 >> 2];
      continue;
    }
    r6 = HEAP32[r1 + 20 >> 2];
    r7 = r1 + 24 | 0;
    r8 = r1 + 8 | 0;
    L770 : do {
      if ((r6 | 0) != (r7 | 0)) {
        r1 = r7;
        r9 = r6;
        while (1) {
          __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer19RemoveUnneededFlowsE_1P5ShapeS4_(HEAP32[r9 + 20 >> 2], HEAP32[r8 >> 2]);
          r10 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r9 | 0);
          if ((r10 | 0) == (r1 | 0)) {
            break L770;
          } else {
            r9 = r10;
          }
        }
      }
    } while (0);
    r4 = HEAP32[r8 >> 2];
  }
  if (r3 == 647) {
    return;
  }
  r3 = r5 + 16 | 0;
  r5 = HEAP32[r3 >> 2];
  r4 = HEAP32[r5 + 24 >> 2];
  if ((r4 | 0) == (r5 + 28 | 0)) {
    return;
  } else {
    r11 = r4;
  }
  while (1) {
    r4 = HEAP32[r11 + 20 >> 2];
    r5 = r4 + 4 | 0;
    do {
      if ((HEAP32[r5 >> 2] | 0) != 0) {
        if ((HEAP32[HEAP32[r11 + 16 >> 2] + 48 >> 2] | 0) != (r2 | 0)) {
          break;
        }
        HEAP32[r5 >> 2] = 0;
        r6 = __ZN5Shape10IsMultipleEPS_(HEAP32[r4 >> 2]);
        if ((r6 | 0) == 0) {
          break;
        }
        r7 = r6 + 32 | 0;
        HEAP32[r7 >> 2] = HEAP32[r7 >> 2] - 1 | 0;
      }
    } while (0);
    r4 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r11 | 0);
    if ((r4 | 0) == (HEAP32[r3 >> 2] + 28 | 0)) {
      break;
    } else {
      r11 = r4;
    }
  }
  return;
}
__ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer19RemoveUnneededFlowsE_1P5ShapeS4_["X"] = 1;
function __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer16FindLabeledLoopsE_1P5Shape(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 12 | 0;
  r4 = r3;
  r5 = r3 + 4;
  r6 = r3 + 8;
  r7 = (r1 + 4 | 0) >> 2;
  r8 = HEAP32[r7];
  r9 = (r8 | 0) == 0;
  if (r9) {
    r10 = __Znwj(24), r11 = r10 >> 2;
    HEAP32[r11] = 0;
    HEAP32[r11 + 1] = 0;
    HEAP32[r11 + 2] = 0;
    HEAP32[r11 + 3] = 0;
    HEAP32[r11 + 4] = 0;
    HEAP32[r11 + 5] = 0;
    HEAP32[r7] = r10;
    r12 = r10;
  } else {
    r12 = r8;
  }
  r8 = __ZN5Shape8IsSimpleEPS_(r2);
  L792 : do {
    if ((r8 | 0) == 0) {
      r10 = __ZN5Shape10IsMultipleEPS_(r2);
      if ((r10 | 0) == 0) {
        r11 = __ZN5Shape6IsLoopEPS_(r2);
        if ((r11 | 0) == 0) {
          break;
        }
        HEAP32[r6 >> 2] = r11 | 0;
        r13 = r12;
        __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE9push_backERKS2_(r13, r6);
        __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer16FindLabeledLoopsE_1P5Shape(r1, HEAP32[r11 + 20 >> 2]);
        __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE8pop_backEv(r13);
        r13 = HEAP32[r2 + 8 >> 2];
        if ((r13 | 0) == 0) {
          break;
        }
        __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer16FindLabeledLoopsE_1P5Shape(r1, r13);
        break;
      }
      r13 = r10 + 32 | 0;
      if ((HEAP32[r13 >> 2] | 0) != 0) {
        HEAP32[r5 >> 2] = r10 | 0;
        __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE9push_backERKS2_(r12, r5);
      }
      r11 = HEAP32[r10 + 20 >> 2];
      r14 = r10 + 24 | 0;
      L830 : do {
        if ((r11 | 0) != (r14 | 0)) {
          r10 = r14;
          r15 = r11;
          while (1) {
            __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer16FindLabeledLoopsE_1P5Shape(r1, HEAP32[r15 + 20 >> 2]);
            r16 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r15 | 0);
            if ((r16 | 0) == (r10 | 0)) {
              break L830;
            } else {
              r15 = r16;
            }
          }
        }
      } while (0);
      if ((HEAP32[r13 >> 2] | 0) != 0) {
        __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE8pop_backEv(r12);
      }
      r11 = HEAP32[r2 + 8 >> 2];
      if ((r11 | 0) == 0) {
        break;
      }
      __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer16FindLabeledLoopsE_1P5Shape(r1, r11);
    } else {
      r11 = r2 + 8 | 0;
      r14 = __ZN5Shape10IsMultipleEPS_(HEAP32[r11 >> 2]), r15 = r14 >> 2;
      r10 = (r14 | 0) != 0;
      L794 : do {
        if (r10) {
          if ((HEAP32[r15 + 8] | 0) == 0) {
            break;
          }
          HEAP32[r4 >> 2] = r14 | 0;
          __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE9push_backERKS2_(r12, r4);
          r16 = HEAP32[r15 + 5];
          r17 = r14 + 24 | 0;
          if ((r16 | 0) == (r17 | 0)) {
            break;
          }
          r18 = r17;
          r17 = r16;
          while (1) {
            __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer16FindLabeledLoopsE_1P5Shape(r1, HEAP32[r17 + 20 >> 2]);
            r16 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r17 | 0);
            if ((r16 | 0) == (r18 | 0)) {
              break L794;
            } else {
              r17 = r16;
            }
          }
        }
      } while (0);
      r14 = r8 + 16 | 0;
      r13 = HEAP32[r14 >> 2];
      r17 = HEAP32[r13 + 24 >> 2];
      L801 : do {
        if ((r17 | 0) != (r13 + 28 | 0)) {
          r18 = r12 + 20 | 0;
          r16 = r12 + 16 | 0;
          r19 = r12 + 4 | 0;
          r20 = r17;
          while (1) {
            r21 = HEAP32[r20 + 20 >> 2];
            do {
              if ((HEAP32[r21 + 4 >> 2] | 0) != 0) {
                r22 = HEAP32[r18 >> 2];
                if ((r22 | 0) == 0) {
                  ___assert_func(5242980, 923, 5244080, 5243188);
                  r23 = HEAP32[r18 >> 2];
                } else {
                  r23 = r22;
                }
                r22 = HEAP32[r21 >> 2];
                r24 = r23 - 1 + HEAP32[r16 >> 2] | 0;
                if ((r22 | 0) == (HEAP32[HEAP32[HEAP32[r19 >> 2] + (r24 >>> 10 << 2) >> 2] + ((r24 & 1023) << 2) >> 2] | 0)) {
                  HEAP8[r21 + 8 | 0] = 0;
                  break;
                } else {
                  HEAP8[__ZN5Shape9IsLabeledEPS_(r22) + 16 | 0] = 1;
                  HEAP8[r21 + 8 | 0] = 1;
                  break;
                }
              }
            } while (0);
            r21 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r20 | 0);
            if ((r21 | 0) == (HEAP32[r14 >> 2] + 28 | 0)) {
              break L801;
            } else {
              r20 = r21;
            }
          }
        }
      } while (0);
      do {
        if (r10) {
          if ((HEAP32[r15 + 8] | 0) == 0) {
            break;
          }
          __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE8pop_backEv(r12);
          r14 = HEAP32[r15 + 2];
          if ((r14 | 0) == 0) {
            break L792;
          }
          __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer16FindLabeledLoopsE_1P5Shape(r1, r14);
          break L792;
        }
      } while (0);
      r15 = HEAP32[r11 >> 2];
      if ((r15 | 0) == 0) {
        break;
      }
      __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer16FindLabeledLoopsE_1P5Shape(r1, r15);
    }
  } while (0);
  if (!r9) {
    STACKTOP = r3;
    return;
  }
  r9 = HEAP32[r7];
  if ((r9 | 0) == 0) {
    STACKTOP = r3;
    return;
  }
  __ZNSt3__15stackIP5ShapeNS_5dequeIS2_NS_9allocatorIS2_EEEEED1Ev(r9);
  __ZdlPv(r9);
  STACKTOP = r3;
  return;
}
__ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer16FindLabeledLoopsE_1P5Shape["X"] = 1;
function __ZN5Shape9IsLabeledEPS_(r1) {
  var r2;
  do {
    if ((__ZN5Shape10IsMultipleEPS_(r1) | 0) == 0) {
      if ((__ZN5Shape6IsLoopEPS_(r1) | 0) == 0) {
        r2 = 0;
      } else {
        break;
      }
      return r2;
    }
  } while (0);
  r2 = r1;
  return r2;
}
function __ZNSt3__15stackIP5ShapeNS_5dequeIS2_NS_9allocatorIS2_EEEEED1Ev(r1) {
  __ZNSt3__15stackIP5ShapeNS_5dequeIS2_NS_9allocatorIS2_EEEEED2Ev(r1);
  return;
}
function __ZNSt3__15stackIP5ShapeNS_5dequeIS2_NS_9allocatorIS2_EEEEED2Ev(r1) {
  __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEED1Ev(r1 | 0);
  return;
}
function __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE8pop_backEv(r1) {
  var r2, r3, r4, r5, r6;
  r2 = r1 + 20 | 0;
  r3 = HEAP32[r2 >> 2] - 1 | 0;
  HEAP32[r2 >> 2] = r3;
  r2 = (r1 + 8 | 0) >> 2;
  r4 = HEAP32[r2];
  r5 = HEAP32[r1 + 4 >> 2];
  if ((r4 | 0) == (r5 | 0)) {
    r6 = 0;
  } else {
    r6 = (r4 - r5 << 8) - 1 | 0;
  }
  if ((r6 - HEAP32[r1 + 16 >> 2] - r3 | 0) >>> 0 <= 2047) {
    return;
  }
  __ZdlPv(HEAP32[r4 - 4 >> 2]);
  HEAP32[r2] = HEAP32[r2] - 4 | 0;
  return;
}
function __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE9push_backERKS2_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 8 | 0;
  r4 = r3;
  r5 = HEAP32[r1 + 8 >> 2];
  r6 = HEAP32[r1 + 4 >> 2];
  if ((r5 | 0) == (r6 | 0)) {
    r7 = 0;
  } else {
    r7 = (r5 - r6 << 8) - 1 | 0;
  }
  r6 = (r1 + 20 | 0) >> 2;
  if ((r7 | 0) == (HEAP32[r6] + HEAP32[r1 + 16 >> 2] | 0)) {
    __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE19__add_back_capacityEv(r1);
  }
  __ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEE3endEv(r4, r1 | 0);
  r1 = HEAP32[r4 + 4 >> 2];
  if ((r1 | 0) == 0) {
    r8 = HEAP32[r6];
    r9 = r8 + 1 | 0;
    HEAP32[r6] = r9;
    STACKTOP = r3;
    return;
  }
  HEAP32[r1 >> 2] = HEAP32[r2 >> 2];
  r8 = HEAP32[r6];
  r9 = r8 + 1 | 0;
  HEAP32[r6] = r9;
  STACKTOP = r3;
  return;
}
function __ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEE3endEv(r1, r2) {
  var r3, r4, r5, r6;
  r3 = HEAP32[r2 + 16 >> 2] + HEAP32[r2 + 20 >> 2] | 0;
  r4 = HEAP32[r2 + 4 >> 2];
  r5 = (r3 >>> 10 << 2) + r4 | 0;
  if ((HEAP32[r2 + 8 >> 2] | 0) == (r4 | 0)) {
    r6 = 0;
  } else {
    r6 = ((r3 & 1023) << 2) + HEAP32[r5 >> 2] | 0;
  }
  HEAP32[r1 >> 2] = r5;
  HEAP32[r1 + 4 >> 2] = r6;
  return;
}
function __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r1, r2, r3) {
  var r4, r5, r6, r7;
  if ((r3 | 0) == (r2 | 0)) {
    return;
  }
  r4 = (r1 + 8 | 0) >> 2;
  r1 = r2;
  r2 = HEAP32[r4];
  while (1) {
    if ((r2 | 0) == 0) {
      r5 = 0;
    } else {
      HEAP32[r2 >> 2] = HEAP32[r1 >> 2];
      r5 = HEAP32[r4];
    }
    r6 = r5 + 4 | 0;
    HEAP32[r4] = r6;
    r7 = r1 + 4 | 0;
    if ((r7 | 0) == (r3 | 0)) {
      break;
    } else {
      r1 = r7;
      r2 = r6;
    }
  }
  return;
}
function __ZZN8Relooper9CalculateEP5BlockEN13PostOptimizerC2E_1PS_(r1, r2) {
  HEAP32[r1 >> 2] = r2;
  HEAP32[r1 + 4 >> 2] = 0;
  return;
}
function __ZNSt3__114__split_bufferIPP5ShapeNS_9allocatorIS3_EEE10push_frontERKS3_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 20 | 0;
  r4 = r3;
  r5 = (r1 + 4 | 0) >> 2;
  r6 = HEAP32[r5];
  r7 = (r1 | 0) >> 2;
  do {
    if ((r6 | 0) == (HEAP32[r7] | 0)) {
      r8 = (r1 + 8 | 0) >> 2;
      r9 = HEAP32[r8];
      r10 = r1 + 12 | 0;
      r11 = (r10 | 0) >> 2;
      r12 = HEAP32[r11];
      r13 = r12;
      if (r9 >>> 0 < r12 >>> 0) {
        r12 = r9;
        r14 = (r13 - r12 + 4 >> 2 | 0) / 2 & -1;
        r15 = r12 - r6 | 0;
        r12 = (r14 - (r15 >> 2) << 2) + r9 | 0;
        _memmove(r12, r6, r15, 4, 0);
        HEAP32[r5] = r12;
        HEAP32[r8] = (r14 << 2) + HEAP32[r8] | 0;
        r16 = r12;
        break;
      } else {
        r12 = r13 - r6 >> 1;
        r13 = (r12 | 0) == 0 ? 1 : r12;
        __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEEC1EjjS6_(r4, r13, (r13 + 3 | 0) >>> 2, r10);
        __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r4, HEAP32[r5], HEAP32[r8]);
        r10 = r4 | 0;
        r13 = HEAP32[r7];
        HEAP32[r7] = HEAP32[r10 >> 2];
        HEAP32[r10 >> 2] = r13;
        r13 = r4 + 4 | 0;
        r10 = HEAP32[r5];
        HEAP32[r5] = HEAP32[r13 >> 2];
        HEAP32[r13 >> 2] = r10;
        r10 = r4 + 8 | 0;
        r13 = HEAP32[r8];
        HEAP32[r8] = HEAP32[r10 >> 2];
        HEAP32[r10 >> 2] = r13;
        r13 = r4 + 12 | 0;
        r10 = HEAP32[r11];
        HEAP32[r11] = HEAP32[r13 >> 2];
        HEAP32[r13 >> 2] = r10;
        __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEED1Ev(r4);
        r16 = HEAP32[r5];
        break;
      }
    } else {
      r16 = r6;
    }
  } while (0);
  r6 = r16 - 4 | 0;
  if ((r6 | 0) == 0) {
    r17 = r16;
    r18 = r17 - 4 | 0;
    HEAP32[r5] = r18;
    STACKTOP = r3;
    return;
  }
  HEAP32[r6 >> 2] = HEAP32[r2 >> 2];
  r17 = HEAP32[r5];
  r18 = r17 - 4 | 0;
  HEAP32[r5] = r18;
  STACKTOP = r3;
  return;
}
__ZNSt3__114__split_bufferIPP5ShapeNS_9allocatorIS3_EEE10push_frontERKS3_["X"] = 1;
function __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEEC1EjjS6_(r1, r2, r3, r4) {
  __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEEC2EjjS6_(r1, r2, r3, r4);
  return;
}
function __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEE10push_frontERKS3_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 20 | 0;
  r4 = r3;
  r5 = (r1 + 4 | 0) >> 2;
  r6 = HEAP32[r5];
  r7 = (r1 | 0) >> 2;
  do {
    if ((r6 | 0) == (HEAP32[r7] | 0)) {
      r8 = (r1 + 8 | 0) >> 2;
      r9 = HEAP32[r8];
      r10 = (r1 + 12 | 0) >> 2;
      r11 = HEAP32[r10];
      r12 = r11;
      if (r9 >>> 0 < r11 >>> 0) {
        r11 = r9;
        r13 = (r12 - r11 + 4 >> 2 | 0) / 2 & -1;
        r14 = r11 - r6 | 0;
        r11 = (r13 - (r14 >> 2) << 2) + r9 | 0;
        _memmove(r11, r6, r14, 4, 0);
        HEAP32[r5] = r11;
        HEAP32[r8] = (r13 << 2) + HEAP32[r8] | 0;
        r15 = r11;
        break;
      } else {
        r11 = r12 - r6 >> 1;
        r12 = (r11 | 0) == 0 ? 1 : r11;
        __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEEC1EjjS6_(r4, r12, (r12 + 3 | 0) >>> 2, HEAP32[r1 + 16 >> 2]);
        __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r4, HEAP32[r5], HEAP32[r8]);
        r12 = r4 | 0;
        r11 = HEAP32[r7];
        HEAP32[r7] = HEAP32[r12 >> 2];
        HEAP32[r12 >> 2] = r11;
        r11 = r4 + 4 | 0;
        r12 = HEAP32[r5];
        HEAP32[r5] = HEAP32[r11 >> 2];
        HEAP32[r11 >> 2] = r12;
        r12 = r4 + 8 | 0;
        r11 = HEAP32[r8];
        HEAP32[r8] = HEAP32[r12 >> 2];
        HEAP32[r12 >> 2] = r11;
        r11 = r4 + 12 | 0;
        r12 = HEAP32[r10];
        HEAP32[r10] = HEAP32[r11 >> 2];
        HEAP32[r11 >> 2] = r12;
        __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEED1Ev(r4);
        r15 = HEAP32[r5];
        break;
      }
    } else {
      r15 = r6;
    }
  } while (0);
  r6 = r15 - 4 | 0;
  if ((r6 | 0) == 0) {
    r16 = r15;
    r17 = r16 - 4 | 0;
    HEAP32[r5] = r17;
    STACKTOP = r3;
    return;
  }
  HEAP32[r6 >> 2] = HEAP32[r2 >> 2];
  r16 = HEAP32[r5];
  r17 = r16 - 4 | 0;
  HEAP32[r5] = r17;
  STACKTOP = r3;
  return;
}
__ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEE10push_frontERKS3_["X"] = 1;
function __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEED1Ev(r1) {
  __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEED2Ev(r1);
  return;
}
function __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEED2Ev(r1) {
  var r2;
  HEAP32[r1 + 8 >> 2] = HEAP32[r1 + 4 >> 2];
  r2 = HEAP32[r1 >> 2];
  if ((r2 | 0) == 0) {
    return;
  }
  __ZdlPv(r2);
  return;
}
function __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEEC2EjjS6_(r1, r2, r3, r4) {
  var r5, r6;
  r5 = r1 + 12 | 0;
  HEAP32[r5 >> 2] = 0;
  HEAP32[r1 + 16 >> 2] = r4;
  if ((r2 | 0) == 0) {
    r6 = 0;
  } else {
    r6 = __Znwj(r2 << 2);
  }
  HEAP32[r1 >> 2] = r6;
  r4 = (r3 << 2) + r6 | 0;
  HEAP32[r1 + 8 >> 2] = r4;
  HEAP32[r1 + 4 >> 2] = r4;
  HEAP32[r5 >> 2] = (r2 << 2) + r6 | 0;
  return;
}
function __ZZN8Relooper9CalculateEP5BlockEN8Analyzer10MakeSimpleE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEES1_SA_(r1, r2, r3, r4) {
  var r5, r6, r7, r8, r9;
  r5 = STACKTOP;
  STACKTOP = STACKTOP + 24 | 0;
  r6 = r5 + 8;
  r7 = r5 + 12;
  HEAP32[r6 >> 2] = r3;
  r8 = __Znwj(20);
  __ZN11SimpleShapeC1Ev(r8);
  r9 = r8;
  __ZZN8Relooper9CalculateEP5BlockEN8Analyzer6NoticeE_0P5Shape(HEAP32[r1 >> 2], r9);
  HEAP32[r8 + 16 >> 2] = r3;
  HEAP32[r3 + 48 >> 2] = r9;
  if (HEAP32[r2 + 8 >> 2] >>> 0 <= 1) {
    STACKTOP = r5;
    return r9;
  }
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE14__erase_uniqueIS2_EEjRKT_(r2 | 0, r6);
  __ZZN8Relooper9CalculateEP5BlockEN8Analyzer12GetBlocksOutE_0S1_RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEEPS9_(HEAP32[r6 >> 2], r4, r2);
  r2 = r7 | 0;
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS4_(r2);
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r5, r2, r6);
  r6 = HEAP32[r4 >> 2];
  r2 = r4 + 4 | 0;
  L927 : do {
    if ((r6 | 0) != (r2 | 0)) {
      r4 = r2;
      r3 = r6;
      while (1) {
        __ZZN8Relooper9CalculateEP5BlockEN8Analyzer9SolipsizeE_0S1_N6Branch8FlowTypeEP5ShapeRNSt3__13setIS1_NS7_4lessIS1_EENS7_9allocatorIS1_EEEE(HEAP32[r3 + 16 >> 2], 0, r9, r7);
        r8 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r3 | 0);
        if ((r8 | 0) == (r4 | 0)) {
          break L927;
        } else {
          r3 = r8;
        }
      }
    }
  } while (0);
  __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r7);
  STACKTOP = r5;
  return r9;
}
__ZZN8Relooper9CalculateEP5BlockEN8Analyzer10MakeSimpleE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEES1_SA_["X"] = 1;
function __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE19__add_back_capacityEv(r1) {
  var r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32;
  r2 = STACKTOP;
  STACKTOP = STACKTOP + 104 | 0;
  r3 = r2;
  r4 = r2 + 20;
  r5 = r2 + 40;
  r6 = r2 + 60;
  r7 = r2 + 80;
  r8 = r2 + 84;
  r9 = r1 + 16 | 0;
  r10 = HEAP32[r9 >> 2];
  if (r10 >>> 0 > 1023) {
    HEAP32[r9 >> 2] = r10 - 1024 | 0;
    r10 = (r1 + 4 | 0) >> 2;
    r9 = HEAP32[r10];
    r11 = HEAP32[r9 >> 2];
    r12 = r9 + 4 | 0;
    HEAP32[r10] = r12;
    r13 = (r1 + 8 | 0) >> 2;
    r14 = HEAP32[r13];
    r15 = r1 + 12 | 0;
    r16 = (r15 | 0) >> 2;
    do {
      if ((r14 | 0) == (HEAP32[r16] | 0)) {
        r17 = (r1 | 0) >> 2;
        r18 = HEAP32[r17];
        if (r12 >>> 0 > r18 >>> 0) {
          r19 = r12;
          r20 = (r19 - r18 + 4 >> 2 | 0) / -2 & -1;
          r21 = r20 + 1 | 0;
          r22 = r14 - r19 | 0;
          _memmove((r21 << 2) + r9 | 0, r12, r22, 4, 0);
          r19 = ((r22 >> 2) + r21 << 2) + r9 | 0;
          HEAP32[r13] = r19;
          HEAP32[r10] = (r20 << 2) + HEAP32[r10] | 0;
          r23 = r19;
          break;
        } else {
          r19 = r14 - r18 >> 1;
          r18 = (r19 | 0) == 0 ? 1 : r19;
          __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEEC1EjjS6_(r6, r18, r18 >>> 2, r15);
          __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r6, HEAP32[r10], HEAP32[r13]);
          r18 = r6 | 0;
          r19 = HEAP32[r17];
          HEAP32[r17] = HEAP32[r18 >> 2];
          HEAP32[r18 >> 2] = r19;
          r19 = r6 + 4 | 0;
          r18 = HEAP32[r10];
          HEAP32[r10] = HEAP32[r19 >> 2];
          HEAP32[r19 >> 2] = r18;
          r18 = r6 + 8 | 0;
          r19 = HEAP32[r13];
          HEAP32[r13] = HEAP32[r18 >> 2];
          HEAP32[r18 >> 2] = r19;
          r19 = r6 + 12 | 0;
          r18 = HEAP32[r16];
          HEAP32[r16] = HEAP32[r19 >> 2];
          HEAP32[r19 >> 2] = r18;
          __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEED1Ev(r6);
          r23 = HEAP32[r13];
          break;
        }
      } else {
        r23 = r14;
      }
    } while (0);
    if ((r23 | 0) == 0) {
      r24 = 0;
    } else {
      HEAP32[r23 >> 2] = r11;
      r24 = HEAP32[r13];
    }
    HEAP32[r13] = r24 + 4 | 0;
    STACKTOP = r2;
    return;
  }
  r24 = r1 | 0;
  r13 = (r1 + 8 | 0) >> 2;
  r11 = HEAP32[r13];
  r23 = (r1 + 4 | 0) >> 2;
  r14 = r11 - HEAP32[r23] >> 2;
  r6 = r1 + 12 | 0;
  r16 = (r6 | 0) >> 2;
  r10 = HEAP32[r16];
  r15 = (r1 | 0) >> 2;
  r1 = r10 - HEAP32[r15] | 0;
  if (r14 >>> 0 >= r1 >> 2 >>> 0) {
    r9 = r1 >> 1;
    __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEEC1EjjS6_(r8, (r9 | 0) == 0 ? 1 : r9, r14, r6);
    r14 = __Znwj(4096);
    r9 = (r8 + 8 | 0) >> 2;
    r1 = HEAP32[r9];
    r12 = (r8 + 12 | 0) >> 2;
    do {
      if ((r1 | 0) == (HEAP32[r12] | 0)) {
        r18 = (r8 + 4 | 0) >> 2;
        r19 = HEAP32[r18];
        r17 = r8 | 0;
        r20 = HEAP32[r17 >> 2];
        if (r19 >>> 0 > r20 >>> 0) {
          r21 = r19;
          r22 = (r21 - r20 + 4 >> 2 | 0) / -2 & -1;
          r25 = (r22 << 2) + r19 | 0;
          r26 = r1 - r21 | 0;
          _memmove(r25, r19, r26, 4, 0);
          r21 = ((r26 >> 2) + r22 << 2) + r19 | 0;
          HEAP32[r9] = r21;
          HEAP32[r18] = r25;
          r27 = r21;
          break;
        }
        r21 = r1 - r20 >> 1;
        r25 = (r21 | 0) == 0 ? 1 : r21;
        __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEEC1EjjS6_(r3, r25, r25 >>> 2, HEAP32[r8 + 16 >> 2]);
        __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r3, r19, r1);
        r25 = r3 | 0;
        HEAP32[r17 >> 2] = HEAP32[r25 >> 2];
        HEAP32[r25 >> 2] = r20;
        r20 = r3 + 4 | 0;
        HEAP32[r18] = HEAP32[r20 >> 2];
        HEAP32[r20 >> 2] = r19;
        r19 = r3 + 8 | 0;
        r20 = HEAP32[r19 >> 2];
        HEAP32[r9] = r20;
        HEAP32[r19 >> 2] = r1;
        r19 = r3 + 12 | 0;
        HEAP32[r12] = HEAP32[r19 >> 2];
        HEAP32[r19 >> 2] = r1;
        __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEED1Ev(r3);
        r27 = r20;
      } else {
        r27 = r1;
      }
    } while (0);
    if ((r27 | 0) == 0) {
      r28 = 0;
    } else {
      HEAP32[r27 >> 2] = r14;
      r28 = r27;
    }
    HEAP32[r9] = r28 + 4 | 0;
    r28 = HEAP32[r13];
    while (1) {
      if ((r28 | 0) == (HEAP32[r23] | 0)) {
        break;
      }
      r27 = r28 - 4 | 0;
      __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEE10push_frontERKS3_(r8, r27);
      r28 = r27;
    }
    r27 = r8 | 0;
    r14 = HEAP32[r15];
    HEAP32[r15] = HEAP32[r27 >> 2];
    HEAP32[r27 >> 2] = r14;
    r14 = r8 + 4 | 0;
    HEAP32[r23] = HEAP32[r14 >> 2];
    HEAP32[r14 >> 2] = r28;
    r28 = HEAP32[r13];
    HEAP32[r13] = HEAP32[r9];
    HEAP32[r9] = r28;
    r28 = HEAP32[r16];
    HEAP32[r16] = HEAP32[r12];
    HEAP32[r12] = r28;
    __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEED1Ev(r8);
    STACKTOP = r2;
    return;
  }
  r8 = __Znwj(4096);
  if ((r10 | 0) == (r11 | 0)) {
    HEAP32[r7 >> 2] = r8;
    __ZNSt3__114__split_bufferIPP5ShapeNS_9allocatorIS3_EEE10push_frontERKS3_(r24, r7);
    r7 = HEAP32[r23];
    r24 = HEAP32[r7 >> 2];
    r11 = r7 + 4 | 0;
    HEAP32[r23] = r11;
    r10 = HEAP32[r13];
    do {
      if ((r10 | 0) == (HEAP32[r16] | 0)) {
        r28 = HEAP32[r15];
        if (r11 >>> 0 > r28 >>> 0) {
          r12 = r11;
          r9 = (r12 - r28 + 4 >> 2 | 0) / -2 & -1;
          r14 = r9 + 1 | 0;
          r27 = r10 - r12 | 0;
          _memmove((r14 << 2) + r7 | 0, r11, r27, 4, 0);
          r12 = ((r27 >> 2) + r14 << 2) + r7 | 0;
          HEAP32[r13] = r12;
          HEAP32[r23] = (r9 << 2) + HEAP32[r23] | 0;
          r29 = r12;
          break;
        } else {
          r12 = r10 - r28 >> 1;
          r28 = (r12 | 0) == 0 ? 1 : r12;
          __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEEC1EjjS6_(r4, r28, r28 >>> 2, r6);
          __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r4, HEAP32[r23], HEAP32[r13]);
          r28 = r4 | 0;
          r12 = HEAP32[r15];
          HEAP32[r15] = HEAP32[r28 >> 2];
          HEAP32[r28 >> 2] = r12;
          r12 = r4 + 4 | 0;
          r28 = HEAP32[r23];
          HEAP32[r23] = HEAP32[r12 >> 2];
          HEAP32[r12 >> 2] = r28;
          r28 = r4 + 8 | 0;
          r12 = HEAP32[r13];
          HEAP32[r13] = HEAP32[r28 >> 2];
          HEAP32[r28 >> 2] = r12;
          r12 = r4 + 12 | 0;
          r28 = HEAP32[r16];
          HEAP32[r16] = HEAP32[r12 >> 2];
          HEAP32[r12 >> 2] = r28;
          __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEED1Ev(r4);
          r29 = HEAP32[r13];
          break;
        }
      } else {
        r29 = r10;
      }
    } while (0);
    if ((r29 | 0) == 0) {
      r30 = 0;
    } else {
      HEAP32[r29 >> 2] = r24;
      r30 = HEAP32[r13];
    }
    HEAP32[r13] = r30 + 4 | 0;
    STACKTOP = r2;
    return;
  } else {
    r30 = HEAP32[r13];
    do {
      if ((r30 | 0) == (HEAP32[r16] | 0)) {
        r24 = HEAP32[r23];
        r29 = HEAP32[r15];
        if (r24 >>> 0 > r29 >>> 0) {
          r10 = r24;
          r4 = (r10 - r29 + 4 >> 2 | 0) / -2 & -1;
          r7 = r30 - r10 | 0;
          _memmove((r4 << 2) + r24 | 0, r24, r7, 4, 0);
          r10 = ((r7 >> 2) + r4 << 2) + r24 | 0;
          HEAP32[r13] = r10;
          HEAP32[r23] = (r4 << 2) + HEAP32[r23] | 0;
          r31 = r10;
          break;
        } else {
          r10 = r30 - r29 >> 1;
          r29 = (r10 | 0) == 0 ? 1 : r10;
          __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEEC1EjjS6_(r5, r29, r29 >>> 2, r6);
          __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_(r5, HEAP32[r23], HEAP32[r13]);
          r29 = r5 | 0;
          r10 = HEAP32[r15];
          HEAP32[r15] = HEAP32[r29 >> 2];
          HEAP32[r29 >> 2] = r10;
          r10 = r5 + 4 | 0;
          r29 = HEAP32[r23];
          HEAP32[r23] = HEAP32[r10 >> 2];
          HEAP32[r10 >> 2] = r29;
          r29 = r5 + 8 | 0;
          r10 = HEAP32[r13];
          HEAP32[r13] = HEAP32[r29 >> 2];
          HEAP32[r29 >> 2] = r10;
          r10 = r5 + 12 | 0;
          r29 = HEAP32[r16];
          HEAP32[r16] = HEAP32[r10 >> 2];
          HEAP32[r10 >> 2] = r29;
          __ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEED1Ev(r5);
          r31 = HEAP32[r13];
          break;
        }
      } else {
        r31 = r30;
      }
    } while (0);
    if ((r31 | 0) == 0) {
      r32 = 0;
    } else {
      HEAP32[r31 >> 2] = r8;
      r32 = HEAP32[r13];
    }
    HEAP32[r13] = r32 + 4 | 0;
    STACKTOP = r2;
    return;
  }
}
__ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE19__add_back_capacityEv["X"] = 1;
function __ZZN8Relooper9CalculateEP5BlockEN8Analyzer8MakeLoopE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_SA_(r1, r2, r3, r4) {
  var r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31;
  r5 = STACKTOP;
  STACKTOP = STACKTOP + 80 | 0;
  r6 = r5;
  r7 = r5 + 8;
  r8 = r5 + 12;
  r9 = r5 + 16;
  r10 = r5 + 20;
  r11 = r5 + 28;
  r12 = r5 + 36;
  r13 = r5 + 40;
  r14 = r5 + 44;
  r15 = r5 + 48;
  r16 = r5 + 60;
  r17 = r5 + 72, r18 = r17 >> 2;
  r19 = r5 + 76;
  r20 = r15 | 0;
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS4_(r20);
  r21 = r16 | 0;
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS7_(r21);
  r22 = r3 | 0;
  r23 = HEAP32[r22 >> 2];
  r24 = r3 + 4 | 0;
  r25 = r24;
  r26 = r16 + 4 | 0;
  L991 : do {
    if ((r23 | 0) != (r25 | 0)) {
      r27 = r24;
      r28 = r23;
      while (1) {
        __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueENS_21__tree_const_iteratorIS2_PKNS_11__tree_nodeIS2_PvEEiEERKS2_(r14, r21, r26, r28 + 16 | 0);
        r29 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r28 | 0);
        if ((r29 | 0) == (r27 | 0)) {
          break L991;
        } else {
          r28 = r29;
        }
      }
    }
  } while (0);
  r26 = r16 + 8 | 0;
  L997 : do {
    if ((HEAP32[r26 >> 2] | 0) != 0) {
      r14 = r16 | 0;
      r23 = r12 | 0;
      r28 = r15 + 4 | 0;
      r27 = r2 | 0;
      while (1) {
        r29 = HEAP32[r14 >> 2];
        HEAP32[r18] = HEAP32[r29 + 16 >> 2];
        __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE5eraseENS_21__tree_const_iteratorIS2_PKNS_11__tree_nodeIS2_PvEEiEE(r13, r21, r29);
        __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r12, r20, r17);
        L1001 : do {
          if ((HEAP32[r23 >> 2] | 0) == (r28 | 0)) {
            __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r11, r20, r17);
            __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE14__erase_uniqueIS2_EEjRKT_(r27, r17);
            r29 = HEAP32[r18];
            r30 = HEAP32[r29 + 12 >> 2];
            if ((r30 | 0) == (r29 + 16 | 0)) {
              break;
            } else {
              r31 = r30;
            }
            while (1) {
              __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r10, r21, r31 + 16 | 0);
              r30 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r31 | 0);
              if ((r30 | 0) == (HEAP32[r18] + 16 | 0)) {
                break L1001;
              } else {
                r31 = r30;
              }
            }
          }
        } while (0);
        if ((HEAP32[r26 >> 2] | 0) == 0) {
          break L997;
        }
      }
    }
  } while (0);
  if ((HEAP32[r15 + 8 >> 2] | 0) == 0) {
    ___assert_func(5242980, 488, 5243988, 5243164);
  }
  r26 = HEAP32[r15 >> 2];
  r31 = r15 + 4 | 0;
  r18 = r31;
  L1012 : do {
    if ((r26 | 0) != (r18 | 0)) {
      r21 = r9 | 0;
      r10 = r4 | 0;
      r17 = r8 | 0;
      r11 = r7 | 0;
      r12 = r31;
      r13 = r26;
      while (1) {
        r2 = HEAP32[r13 + 16 >> 2];
        r27 = HEAP32[r2 >> 2];
        r28 = r2 + 4 | 0;
        L1016 : do {
          if ((r27 | 0) != (r28 | 0)) {
            r2 = r28;
            r23 = r27;
            while (1) {
              HEAP32[r19 >> 2] = HEAP32[r23 + 16 >> 2];
              __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r9, r20, r19);
              do {
                if ((HEAP32[r21 >> 2] | 0) == (r18 | 0)) {
                  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r8, r10, r19);
                  r14 = HEAP32[r17 >> 2];
                  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r7, r10, r19);
                  if ((r14 | 0) != (HEAP32[r11 >> 2] | 0)) {
                    break;
                  }
                  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r6, r10, r19);
                }
              } while (0);
              r14 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r23 | 0);
              if ((r14 | 0) == (r2 | 0)) {
                break L1016;
              } else {
                r23 = r14;
              }
            }
          }
        } while (0);
        r27 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r13 | 0);
        if ((r27 | 0) == (r12 | 0)) {
          break L1012;
        } else {
          r13 = r27;
        }
      }
    }
  } while (0);
  r19 = __Znwj(24);
  __ZN9LoopShapeC1Ev(r19);
  r6 = r19;
  __ZZN8Relooper9CalculateEP5BlockEN8Analyzer6NoticeE_0P5Shape(HEAP32[r1 >> 2], r6);
  r7 = HEAP32[r22 >> 2];
  L1028 : do {
    if ((r7 | 0) != (r25 | 0)) {
      r22 = r24;
      r8 = r7;
      while (1) {
        __ZZN8Relooper9CalculateEP5BlockEN8Analyzer9SolipsizeE_0S1_N6Branch8FlowTypeEP5ShapeRNSt3__13setIS1_NS7_4lessIS1_EENS7_9allocatorIS1_EEEE(HEAP32[r8 + 16 >> 2], 2, r6, r15);
        r18 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r8 | 0);
        if ((r18 | 0) == (r22 | 0)) {
          break L1028;
        } else {
          r8 = r18;
        }
      }
    }
  } while (0);
  r7 = HEAP32[r4 >> 2];
  r24 = r4 + 4 | 0;
  L1034 : do {
    if ((r7 | 0) != (r24 | 0)) {
      r4 = r24;
      r25 = r7;
      while (1) {
        __ZZN8Relooper9CalculateEP5BlockEN8Analyzer9SolipsizeE_0S1_N6Branch8FlowTypeEP5ShapeRNSt3__13setIS1_NS7_4lessIS1_EENS7_9allocatorIS1_EEEE(HEAP32[r25 + 16 >> 2], 1, r6, r15);
        r8 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r25 | 0);
        if ((r8 | 0) == (r4 | 0)) {
          break L1034;
        } else {
          r25 = r8;
        }
      }
    }
  } while (0);
  HEAP32[r19 + 20 >> 2] = __ZZN8Relooper9CalculateEP5BlockEN8Analyzer7ProcessE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_P5Shape(r1, r15, r3);
  __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r16);
  __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r15);
  STACKTOP = r5;
  return r6;
}
__ZZN8Relooper9CalculateEP5BlockEN8Analyzer8MakeLoopE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_SA_["X"] = 1;
function __ZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEE(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 84 | 0;
  r4 = r3;
  r5 = r3 + 8;
  r6 = r3 + 12;
  r7 = r3 + 20;
  r8 = r3 + 36;
  r9 = r3 + 48;
  r10 = r3 + 52;
  r11 = r3 + 56, r12 = r11 >> 2;
  r13 = r3 + 60;
  r14 = r3 + 64;
  r15 = r3 + 76;
  r16 = r3 + 80;
  __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassC1ESH_(r7, r2);
  r17 = r8;
  HEAP32[r8 >> 2] = r17;
  r18 = r8 + 4 | 0;
  HEAP32[r18 >> 2] = r17;
  r17 = (r8 + 8 | 0) >> 2;
  HEAP32[r17] = 0;
  r19 = (r1 | 0) >> 2;
  r20 = HEAP32[r19];
  r21 = r1 + 4 | 0;
  r1 = r21;
  L1042 : do {
    if ((r20 | 0) != (r1 | 0)) {
      r22 = r7 + 4 | 0;
      r23 = r21;
      r24 = r20;
      while (1) {
        r25 = HEAP32[r24 + 16 >> 2];
        HEAP32[r9 >> 2] = r25;
        HEAP32[__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEEixERS7_(r22, r9) >> 2] = r25;
        __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r6, __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEEixERSA_(r2, r9) | 0, r9);
        __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEE9push_backERKS2_(r8, r9);
        r25 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r24 | 0);
        if ((r25 | 0) == (r23 | 0)) {
          break;
        } else {
          r24 = r25;
        }
      }
      if ((HEAP32[r17] | 0) == 0) {
        break;
      }
      r24 = r22 | 0;
      r23 = r5 | 0;
      r25 = r7 + 8 | 0;
      while (1) {
        HEAP32[r10 >> 2] = HEAP32[HEAP32[r18 >> 2] + 8 >> 2];
        __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEE9pop_frontEv(r8);
        r26 = HEAP32[__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEEixERS7_(r22, r10) >> 2];
        HEAP32[r12] = r26;
        L1055 : do {
          if ((r26 | 0) != 0) {
            r27 = HEAP32[r10 >> 2];
            r28 = HEAP32[r27 >> 2];
            r29 = r27 + 4 | 0;
            if ((r28 | 0) == (r29 | 0)) {
              break;
            }
            r27 = r29;
            r29 = r28;
            while (1) {
              HEAP32[r13 >> 2] = HEAP32[r29 + 16 >> 2];
              __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_(r5, r24, r13);
              r28 = HEAP32[r23 >> 2];
              do {
                if ((r28 | 0) == (r25 | 0)) {
                  r30 = HEAP32[r12];
                  HEAP32[__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEEixERS7_(r22, r13) >> 2] = r30;
                  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r4, __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEEixERSA_(r2, r11) | 0, r13);
                  __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEE9push_backERKS2_(r8, r13);
                } else {
                  r30 = HEAP32[r28 + 20 >> 2];
                  if ((r30 | 0) == 0) {
                    break;
                  }
                  if ((r30 | 0) == (HEAP32[r12] | 0)) {
                    break;
                  }
                  __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClass22InvalidateWithChildrenES1_(r7, HEAP32[r13 >> 2]);
                }
              } while (0);
              r28 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r29 | 0);
              if ((r28 | 0) == (r27 | 0)) {
                break L1055;
              } else {
                r29 = r28;
              }
            }
          }
        } while (0);
        if ((HEAP32[r17] | 0) == 0) {
          break L1042;
        }
      }
    }
  } while (0);
  r17 = HEAP32[r19];
  if ((r17 | 0) == (r1 | 0)) {
    __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEED1Ev(r8);
    __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassD1Ev(r7);
    STACKTOP = r3;
    return;
  }
  r13 = r14 | 0;
  r12 = r14;
  r11 = r14 + 4 | 0;
  r4 = r14 + 8 | 0;
  r5 = r7 + 4 | 0;
  r10 = r21;
  r21 = r17;
  while (1) {
    r17 = __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEEixERSA_(r2, r21 + 16 | 0);
    HEAP32[r13 >> 2] = r12;
    HEAP32[r11 >> 2] = r12;
    HEAP32[r4 >> 2] = 0;
    r18 = HEAP32[r17 >> 2];
    r9 = r17 + 4 | 0;
    L1077 : do {
      if ((r18 | 0) != (r9 | 0)) {
        r17 = r9;
        r6 = r18;
        while (1) {
          r20 = HEAP32[r6 + 16 >> 2];
          HEAP32[r15 >> 2] = r20;
          r22 = HEAP32[r20 + 12 >> 2];
          L1081 : do {
            if ((r22 | 0) != (r20 + 16 | 0)) {
              r25 = r22;
              while (1) {
                HEAP32[r16 >> 2] = HEAP32[r25 + 16 >> 2];
                if ((HEAP32[__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEEixERS7_(r5, r16) >> 2] | 0) != (HEAP32[__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEEixERS7_(r5, r15) >> 2] | 0)) {
                  __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEE9push_backERKS2_(r14, r15);
                }
                r23 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r25 | 0);
                if ((r23 | 0) == (HEAP32[r15 >> 2] + 16 | 0)) {
                  break L1081;
                } else {
                  r25 = r23;
                }
              }
            }
          } while (0);
          r22 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r6 | 0);
          if ((r22 | 0) == (r17 | 0)) {
            break L1077;
          } else {
            r6 = r22;
          }
        }
      }
    } while (0);
    while (1) {
      if ((HEAP32[r4 >> 2] | 0) == 0) {
        break;
      }
      r18 = HEAP32[HEAP32[r11 >> 2] + 8 >> 2];
      __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEE9pop_frontEv(r14);
      __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClass22InvalidateWithChildrenES1_(r7, r18);
    }
    __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEED1Ev(r14);
    r18 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r21 | 0);
    if ((r18 | 0) == (r10 | 0)) {
      break;
    } else {
      r21 = r18;
    }
  }
  r21 = HEAP32[r19];
  if ((r21 | 0) == (r1 | 0)) {
    __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEED1Ev(r8);
    __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassD1Ev(r7);
    STACKTOP = r3;
    return;
  }
  r1 = r2 | 0;
  r19 = r21;
  while (1) {
    r21 = r19 + 16 | 0;
    if ((HEAP32[__ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEEixERSA_(r2, r21) + 8 >> 2] | 0) == 0) {
      __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE14__erase_uniqueIS3_EEjRKT_(r1, r21);
    }
    r21 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r19 | 0);
    if ((r21 | 0) == (r10 | 0)) {
      break;
    } else {
      r19 = r21;
    }
  }
  __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEED1Ev(r8);
  __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassD1Ev(r7);
  STACKTOP = r3;
  return;
}
__ZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEE["X"] = 1;
function __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEEixERSA_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 16 | 0;
  r4 = r3;
  r5 = r3 + 4;
  r6 = __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEE16__find_equal_keyERPNS_16__tree_node_baseIPvEERSA_(r1, r4, r2);
  r7 = HEAP32[r6 >> 2];
  if ((r7 | 0) != 0) {
    r8 = r7;
    r9 = r8 + 20 | 0;
    STACKTOP = r3;
    return r9;
  }
  __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEE16__construct_nodeERSA_(r5, r1, r2);
  r2 = r5 | 0;
  r5 = HEAP32[r2 >> 2];
  HEAP32[r2 >> 2] = 0;
  __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSI_SI_(r1 | 0, HEAP32[r4 >> 2], r6, r5 | 0);
  r8 = r5;
  r9 = r8 + 20 | 0;
  STACKTOP = r3;
  return r9;
}
function __ZZN8Relooper9CalculateEP5BlockEN8Analyzer12MakeMultipleE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEP5ShapeSA_(r1, r2, r3, r4, r5, r6) {
  var r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45;
  r7 = STACKTOP;
  STACKTOP = STACKTOP + 60 | 0;
  r8 = r7;
  r9 = r7 + 8;
  r10 = r7 + 12;
  r11 = r7 + 20;
  r12 = r7 + 24;
  r13 = r7 + 32;
  r14 = r7 + 44, r15 = r14 >> 2;
  r16 = r7 + 48, r17 = r16 >> 2;
  r18 = r7 + 52, r19 = r18 >> 2;
  r20 = r7 + 56;
  r21 = __ZN5Shape8IsSimpleEPS_(r5);
  r5 = __Znwj(36);
  __ZN13MultipleShapeC1Ev(r5);
  r22 = r5;
  __ZZN8Relooper9CalculateEP5BlockEN8Analyzer6NoticeE_0P5Shape(HEAP32[r1 >> 2], r22);
  r23 = r13 | 0;
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS4_(r23);
  r24 = r4 | 0;
  r25 = HEAP32[r4 >> 2];
  r26 = r4 + 4 | 0;
  r4 = r26;
  L1111 : do {
    if ((r25 | 0) != (r4 | 0)) {
      r27 = r5 + 20 | 0;
      r28 = r2 | 0;
      r29 = r11 | 0;
      r30 = r6 | 0;
      r31 = r26;
      if ((r21 | 0) == 0) {
        r32 = r25;
        while (1) {
          HEAP32[r15] = HEAP32[r32 + 16 >> 2];
          r33 = r32 + 20 | 0;
          __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE5clearEv(r23);
          __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r12, r23, r14);
          r34 = r33 | 0;
          r35 = HEAP32[r33 >> 2];
          r36 = r32 + 24 | 0;
          r37 = r36;
          L1136 : do {
            if ((r35 | 0) != (r37 | 0)) {
              r38 = r36;
              r39 = r35;
              while (1) {
                HEAP32[r17] = HEAP32[r39 + 16 >> 2];
                __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE14__erase_uniqueIS2_EEjRKT_(r28, r16);
                r40 = HEAP32[r17];
                r41 = HEAP32[r40 >> 2];
                r42 = r40 + 4 | 0;
                L1140 : do {
                  if ((r41 | 0) != (r42 | 0)) {
                    r40 = r42;
                    r43 = r41;
                    while (1) {
                      HEAP32[r19] = HEAP32[r43 + 16 >> 2];
                      r44 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r43 | 0);
                      __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r11, r34, r18);
                      if ((HEAP32[r29 >> 2] | 0) == (r37 | 0)) {
                        __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r10, r30, r18);
                        __ZZN8Relooper9CalculateEP5BlockEN8Analyzer9SolipsizeE_0S1_N6Branch8FlowTypeEP5ShapeRNSt3__13setIS1_NS7_4lessIS1_EENS7_9allocatorIS1_EEEE(HEAP32[r19], 1, r22, r33);
                      }
                      if ((r44 | 0) == (r40 | 0)) {
                        break L1140;
                      } else {
                        r43 = r44;
                      }
                    }
                  }
                } while (0);
                r41 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r39 | 0);
                if ((r41 | 0) == (r38 | 0)) {
                  break L1136;
                } else {
                  r39 = r41;
                }
              }
            }
          } while (0);
          r37 = __ZZN8Relooper9CalculateEP5BlockEN8Analyzer7ProcessE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_P5Shape(r1, r33, r13);
          HEAP32[__ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(r27, r14) >> 2] = r37;
          HEAP8[HEAP32[r15] + 64 | 0] = 1;
          r37 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r32 | 0);
          if ((r37 | 0) == (r31 | 0)) {
            break L1111;
          } else {
            r32 = r37;
          }
        }
      } else {
        r32 = r25;
        while (1) {
          HEAP32[r15] = HEAP32[r32 + 16 >> 2];
          r37 = r32 + 20 | 0;
          __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE5clearEv(r23);
          __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r12, r23, r14);
          r34 = r37 | 0;
          r35 = HEAP32[r37 >> 2];
          r36 = r32 + 24 | 0;
          r39 = r36;
          L1117 : do {
            if ((r35 | 0) != (r39 | 0)) {
              r38 = r36;
              r41 = r35;
              while (1) {
                HEAP32[r17] = HEAP32[r41 + 16 >> 2];
                __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE14__erase_uniqueIS2_EEjRKT_(r28, r16);
                r42 = HEAP32[r17];
                r43 = HEAP32[r42 >> 2];
                r40 = r42 + 4 | 0;
                L1121 : do {
                  if ((r43 | 0) != (r40 | 0)) {
                    r42 = r40;
                    r44 = r43;
                    while (1) {
                      HEAP32[r19] = HEAP32[r44 + 16 >> 2];
                      r45 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r44 | 0);
                      __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r11, r34, r18);
                      if ((HEAP32[r29 >> 2] | 0) == (r39 | 0)) {
                        __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r10, r30, r18);
                        __ZZN8Relooper9CalculateEP5BlockEN8Analyzer9SolipsizeE_0S1_N6Branch8FlowTypeEP5ShapeRNSt3__13setIS1_NS7_4lessIS1_EENS7_9allocatorIS1_EEEE(HEAP32[r19], 1, r22, r37);
                      }
                      if ((r45 | 0) == (r42 | 0)) {
                        break L1121;
                      } else {
                        r44 = r45;
                      }
                    }
                  }
                } while (0);
                r43 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r41 | 0);
                if ((r43 | 0) == (r38 | 0)) {
                  break L1117;
                } else {
                  r41 = r43;
                }
              }
            }
          } while (0);
          r39 = __ZZN8Relooper9CalculateEP5BlockEN8Analyzer7ProcessE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_P5Shape(r1, r37, r13);
          HEAP32[__ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(r27, r14) >> 2] = r39;
          r39 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r32 | 0);
          if ((r39 | 0) == (r31 | 0)) {
            break L1111;
          } else {
            r32 = r39;
          }
        }
      }
    }
  } while (0);
  r14 = HEAP32[r3 >> 2];
  r1 = r3 + 4 | 0;
  if ((r14 | 0) == (r1 | 0)) {
    __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r13);
    STACKTOP = r7;
    return r22;
  }
  r3 = r9 | 0;
  r19 = r6 | 0;
  r6 = r1;
  r1 = r14;
  while (1) {
    HEAP32[r20 >> 2] = HEAP32[r1 + 16 >> 2];
    __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE4findIS3_EENS_15__tree_iteratorISA_PNS_11__tree_nodeISA_PvEEiEERKT_(r9, r24, r20);
    if ((HEAP32[r3 >> 2] | 0) == (r4 | 0)) {
      __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r8, r19, r20);
    }
    r14 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r1 | 0);
    if ((r14 | 0) == (r6 | 0)) {
      break;
    } else {
      r1 = r14;
    }
  }
  __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r13);
  STACKTOP = r7;
  return r22;
}
__ZZN8Relooper9CalculateEP5BlockEN8Analyzer12MakeMultipleE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEP5ShapeSA_["X"] = 1;
function __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEED1Ev(r1) {
  __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEED2Ev(r1);
  return;
}
function __ZN12LabeledShapeD1Ev(r1) {
  return;
}
function __ZN5ShapeD1Ev(r1) {
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE13__lower_boundIS3_EENS_15__tree_iteratorISA_PNS_11__tree_nodeISA_PvEEiEERKT_SK_SK_(r1, r2, r3, r4) {
  var r5, r6, r7, r8, r9, r10, r11;
  L1166 : do {
    if ((r3 | 0) == 0) {
      r5 = r4;
    } else {
      r6 = HEAP32[r2 >> 2];
      r7 = r3;
      r8 = r4;
      while (1) {
        r9 = r7, r10 = r9 >> 2;
        while (1) {
          if (HEAP32[r10 + 4] >>> 0 >= r6 >>> 0) {
            break;
          }
          r11 = HEAP32[r10 + 1];
          if ((r11 | 0) == 0) {
            r5 = r8;
            break L1166;
          } else {
            r9 = r11, r10 = r9 >> 2;
          }
        }
        r11 = HEAP32[r10];
        if ((r11 | 0) == 0) {
          r5 = r9;
          break L1166;
        } else {
          r7 = r11;
          r8 = r9;
        }
      }
    }
  } while (0);
  HEAP32[r1 >> 2] = r5;
  return;
}
function __ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEE16__find_equal_keyERPNS_16__tree_node_baseIPvEERS9_(r1, r2, r3) {
  var r4, r5, r6, r7, r8, r9;
  r4 = 0;
  r5 = r1 + 4 | 0;
  r1 = r5 | 0;
  r6 = HEAP32[r1 >> 2];
  if ((r6 | 0) == 0) {
    HEAP32[r2 >> 2] = r5;
    r7 = r1;
    return r7;
  }
  r1 = HEAP32[r3 >> 2];
  r3 = r6;
  while (1) {
    r6 = HEAP32[r3 + 16 >> 2];
    if (r1 >>> 0 < r6 >>> 0) {
      r8 = r3 | 0;
      r5 = HEAP32[r8 >> 2];
      if ((r5 | 0) == 0) {
        r4 = 980;
        break;
      } else {
        r3 = r5;
        continue;
      }
    }
    if (r6 >>> 0 >= r1 >>> 0) {
      r4 = 984;
      break;
    }
    r9 = r3 + 4 | 0;
    r6 = HEAP32[r9 >> 2];
    if ((r6 | 0) == 0) {
      r4 = 983;
      break;
    } else {
      r3 = r6;
    }
  }
  if (r4 == 984) {
    HEAP32[r2 >> 2] = r3;
    r7 = r2;
    return r7;
  } else if (r4 == 983) {
    HEAP32[r2 >> 2] = r3;
    r7 = r9;
    return r7;
  } else if (r4 == 980) {
    HEAP32[r2 >> 2] = r3;
    r7 = r8;
    return r7;
  }
}
function __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC2ERKSA_(r1) {
  var r2;
  r2 = r1 + 4 | 0;
  HEAP32[r2 >> 2] = 0;
  HEAP32[r1 + 8 >> 2] = 0;
  HEAP32[r1 >> 2] = r2;
  return;
}
function __ZN5ShapeC2ENS_9ShapeTypeE(r1, r2) {
  var r3;
  HEAP32[r1 >> 2] = 5244376;
  r3 = HEAP32[1311192];
  HEAP32[1311192] = r3 + 1 | 0;
  HEAP32[r1 + 4 >> 2] = r3;
  HEAP32[r1 + 8 >> 2] = 0;
  HEAP32[r1 + 12 >> 2] = r2;
  return;
}
function __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEED2Ev(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEED1Ev(HEAP32[r1 + 4 >> 2]);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEED1Ev(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEED2Ev(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEED2Ev(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE7destroyEPNS_11__tree_nodeISA_PvEE(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE7destroyEPNS_11__tree_nodeISA_PvEE(r1) {
  if ((r1 | 0) == 0) {
    return;
  } else {
    __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE7destroyEPNS_11__tree_nodeISA_PvEE(HEAP32[r1 >> 2]);
    __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE7destroyEPNS_11__tree_nodeISA_PvEE(HEAP32[r1 + 4 >> 2]);
    __ZNSt3__14pairIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEEED1Ev(r1 + 16 | 0);
    __ZdlPv(r1);
    return;
  }
}
function __ZNSt3__14pairIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEEED1Ev(r1) {
  __ZNSt3__14pairIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEEED2Ev(r1);
  return;
}
function __ZNSt3__14pairIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEEED2Ev(r1) {
  __ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev(r1 + 4 | 0);
  return;
}
function __ZN13MultipleShapeC1Ev(r1) {
  __ZN13MultipleShapeC2Ev(r1);
  return;
}
function __ZZN8Relooper9CalculateEP5BlockEN8Analyzer6NoticeE_0P5Shape(r1, r2) {
  var r3, r4;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 4 | 0;
  r4 = r3;
  HEAP32[r4 >> 2] = r2;
  __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE9push_backERKS2_(r1 + 24 | 0, r4);
  STACKTOP = r3;
  return;
}
function __ZZN8Relooper9CalculateEP5BlockEN8Analyzer9SolipsizeE_0S1_N6Branch8FlowTypeEP5ShapeRNSt3__13setIS1_NS7_4lessIS1_EENS7_9allocatorIS1_EEEE(r1, r2, r3, r4) {
  var r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19;
  r5 = STACKTOP;
  STACKTOP = STACKTOP + 12 | 0;
  r6 = r5;
  r7 = r5 + 4, r8 = r7 >> 2;
  r9 = r5 + 8, r10 = r9 >> 2;
  HEAP32[r8] = r1;
  r11 = HEAP32[r1 + 12 >> 2];
  if ((r11 | 0) == (r1 + 16 | 0)) {
    STACKTOP = r5;
    return;
  }
  r12 = r4 | 0;
  r13 = r6 | 0;
  r14 = r4 + 4 | 0;
  r4 = r11;
  r11 = r1;
  while (1) {
    HEAP32[r10] = HEAP32[r4 + 16 >> 2];
    __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r6, r12, r9);
    if ((HEAP32[r13 >> 2] | 0) == (r14 | 0)) {
      r15 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r4 | 0);
      r16 = r11;
    } else {
      r1 = HEAP32[r4 + 20 >> 2];
      r17 = HEAP32[__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(HEAP32[r10] | 0, r7) >> 2];
      HEAP32[r17 >> 2] = r3;
      HEAP32[r17 + 4 >> 2] = r2;
      r18 = __ZN5Shape10IsMultipleEPS_(r3);
      if ((r18 | 0) != 0) {
        r19 = r18 + 32 | 0;
        HEAP32[r19 >> 2] = HEAP32[r19 >> 2] + 1 | 0;
      }
      r19 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r4 | 0);
      r18 = HEAP32[r8];
      __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__erase_uniqueIS3_EEjRKT_(r18 + 12 | 0, r9);
      HEAP32[__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(r18 + 36 | 0, r9) >> 2] = r1;
      r1 = HEAP32[r10];
      __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__erase_uniqueIS3_EEjRKT_(r1 | 0, r7);
      HEAP32[__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(r1 + 24 | 0, r7) >> 2] = r17;
      r15 = r19;
      r16 = HEAP32[r8];
    }
    if ((r15 | 0) == (r16 + 16 | 0)) {
      break;
    } else {
      r4 = r15;
      r11 = r16;
    }
  }
  STACKTOP = r5;
  return;
}
__ZZN8Relooper9CalculateEP5BlockEN8Analyzer9SolipsizeE_0S1_N6Branch8FlowTypeEP5ShapeRNSt3__13setIS1_NS7_4lessIS1_EENS7_9allocatorIS1_EEEE["X"] = 1;
function __ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 16 | 0;
  r4 = r3;
  r5 = r3 + 4;
  r6 = __ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEE16__find_equal_keyERPNS_16__tree_node_baseIPvEERS9_(r1, r4, r2);
  r7 = HEAP32[r6 >> 2];
  if ((r7 | 0) != 0) {
    r8 = r7;
    r9 = r8 + 20 | 0;
    STACKTOP = r3;
    return r9;
  }
  __ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEE16__construct_nodeERS9_(r5, r1, r2);
  r2 = r5 | 0;
  r5 = HEAP32[r2 >> 2];
  HEAP32[r2 >> 2] = 0;
  __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSH_SH_(r1 | 0, HEAP32[r4 >> 2], r6, r5 | 0);
  r8 = r5;
  r9 = r8 + 20 | 0;
  STACKTOP = r3;
  return r9;
}
function __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE4findIS3_EENS_15__tree_iteratorISA_PNS_11__tree_nodeISA_PvEEiEERKT_(r1, r2, r3) {
  var r4, r5, r6;
  r4 = STACKTOP;
  STACKTOP = STACKTOP + 4 | 0;
  r5 = r4;
  r6 = r2 + 4 | 0;
  r2 = r6;
  __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE13__lower_boundIS3_EENS_15__tree_iteratorISA_PNS_11__tree_nodeISA_PvEEiEERKT_SK_SK_(r5, r3, HEAP32[r6 >> 2], r2);
  r6 = HEAP32[r5 >> 2];
  do {
    if ((r6 | 0) != (r2 | 0)) {
      if (HEAP32[r3 >> 2] >>> 0 < HEAP32[r6 + 16 >> 2] >>> 0) {
        break;
      }
      HEAP32[r1 >> 2] = r6;
      STACKTOP = r4;
      return;
    }
  } while (0);
  HEAP32[r1 >> 2] = r2;
  STACKTOP = r4;
  return;
}
function __ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEE16__construct_nodeERS9_(r1, r2, r3) {
  var r4, r5;
  r4 = __Znwj(24);
  r5 = r4 + 16 | 0;
  if ((r5 | 0) != 0) {
    HEAP32[r5 >> 2] = HEAP32[r3 >> 2];
  }
  r3 = r4 + 20 | 0;
  if ((r3 | 0) != 0) {
    HEAP32[r3 >> 2] = 0;
  }
  HEAP32[r1 >> 2] = r4;
  HEAP32[r1 + 4 >> 2] = r2 + 4 | 0;
  HEAP8[r1 + 8 | 0] = 1;
  HEAP8[r1 + 9 | 0] = 1;
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSH_SH_(r1, r2, r3, r4) {
  var r5, r6;
  HEAP32[r4 >> 2] = 0;
  HEAP32[r4 + 4 >> 2] = 0;
  HEAP32[r4 + 8 >> 2] = r2;
  HEAP32[r3 >> 2] = r4;
  r2 = r1 | 0;
  r5 = HEAP32[HEAP32[r2 >> 2] >> 2];
  if ((r5 | 0) == 0) {
    r6 = r4;
  } else {
    HEAP32[r2 >> 2] = r5;
    r6 = HEAP32[r3 >> 2];
  }
  __ZNSt3__127__tree_balance_after_insertIPNS_16__tree_node_baseIPvEEEEvT_S5_(HEAP32[r1 + 4 >> 2], r6);
  r6 = r1 + 8 | 0;
  HEAP32[r6 >> 2] = HEAP32[r6 >> 2] + 1 | 0;
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__erase_uniqueIS3_EEjRKT_(r1, r2) {
  var r3, r4;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 8 | 0;
  r4 = r3;
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_(r4, r1, r2);
  r2 = HEAP32[r4 >> 2];
  if ((r2 | 0) == (r1 + 4 | 0)) {
    STACKTOP = r3;
    return;
  }
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE5eraseENS_21__tree_const_iteratorIS6_PKNS_11__tree_nodeIS6_PvEEiEE(r3 + 4, r1, r2);
  STACKTOP = r3;
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE5eraseENS_21__tree_const_iteratorIS6_PKNS_11__tree_nodeIS6_PvEEiEE(r1, r2, r3) {
  var r4, r5;
  r4 = r3 | 0;
  r5 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r4);
  HEAP32[r1 >> 2] = r5;
  r1 = r2 | 0;
  if ((HEAP32[r1 >> 2] | 0) == (r3 | 0)) {
    HEAP32[r1 >> 2] = r5;
  }
  r5 = r2 + 8 | 0;
  HEAP32[r5 >> 2] = HEAP32[r5 >> 2] - 1 | 0;
  __ZNSt3__113__tree_removeIPNS_16__tree_node_baseIPvEEEEvT_S5_(HEAP32[r2 + 4 >> 2], r4);
  __ZdlPv(r3);
  return;
}
function __ZNSt3__113__tree_removeIPNS_16__tree_node_baseIPvEEEEvT_S5_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43;
  r3 = 0;
  r4 = r2 | 0;
  r5 = HEAP32[r4 >> 2];
  do {
    if ((r5 | 0) == 0) {
      r6 = r2;
      r7 = r4;
      r3 = 1045;
    } else {
      if ((HEAP32[r2 + 4 >> 2] | 0) == 0) {
        r8 = r5;
        r9 = r2;
        r10 = r4;
        r3 = 1047;
        break;
      }
      r11 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r2);
      r12 = r11 | 0;
      r13 = HEAP32[r12 >> 2];
      if ((r13 | 0) == 0) {
        r6 = r11;
        r7 = r12;
        r3 = 1045;
        break;
      } else {
        r8 = r13;
        r9 = r11;
        r10 = r12;
        r3 = 1047;
        break;
      }
    }
  } while (0);
  do {
    if (r3 == 1045) {
      r5 = HEAP32[r6 + 4 >> 2];
      if ((r5 | 0) != 0) {
        r8 = r5;
        r9 = r6;
        r10 = r7;
        r3 = 1047;
        break;
      }
      r14 = 0;
      r15 = 0;
      r16 = r6 + 8 | 0, r17 = r16 >> 2;
      r18 = r6;
      r19 = r7;
      break;
    }
  } while (0);
  if (r3 == 1047) {
    r7 = r9 + 8 | 0;
    HEAP32[r8 + 8 >> 2] = HEAP32[r7 >> 2];
    r14 = r8;
    r15 = 1;
    r16 = r7, r17 = r16 >> 2;
    r18 = r9;
    r19 = r10;
  }
  r10 = HEAP32[r17];
  r9 = r10 | 0;
  do {
    if ((r18 | 0) == (HEAP32[r9 >> 2] | 0)) {
      HEAP32[r9 >> 2] = r14;
      if ((r18 | 0) == (r1 | 0)) {
        r20 = r14;
        r21 = 0;
        break;
      }
      r20 = r1;
      r21 = HEAP32[HEAP32[r17] + 4 >> 2];
    } else {
      HEAP32[r10 + 4 >> 2] = r14;
      r20 = r1;
      r21 = HEAP32[HEAP32[r17] >> 2];
    }
  } while (0);
  r1 = r18 + 12 | 0;
  r10 = (HEAP8[r1] & 1) << 24 >> 24 == 0;
  if ((r18 | 0) == (r2 | 0)) {
    r22 = r20;
  } else {
    r9 = r2 + 8 | 0;
    r16 = HEAP32[r9 >> 2];
    HEAP32[r17] = r16;
    if ((HEAP32[HEAP32[r9 >> 2] >> 2] | 0) == (r2 | 0)) {
      HEAP32[r16 >> 2] = r18;
    } else {
      HEAP32[r16 + 4 >> 2] = r18;
    }
    r16 = HEAP32[r4 >> 2];
    HEAP32[r19 >> 2] = r16;
    HEAP32[r16 + 8 >> 2] = r18;
    r16 = HEAP32[r2 + 4 >> 2];
    HEAP32[r18 + 4 >> 2] = r16;
    if ((r16 | 0) != 0) {
      HEAP32[r16 + 8 >> 2] = r18;
    }
    HEAP8[r1] = HEAP8[r2 + 12 | 0] & 1;
    r22 = (r20 | 0) == (r2 | 0) ? r18 : r20;
  }
  if (r10 | (r22 | 0) == 0) {
    return;
  }
  if (r15) {
    HEAP8[r14 + 12 | 0] = 1;
    return;
  } else {
    r23 = r22;
    r24 = r21;
  }
  while (1) {
    r21 = (r24 + 8 | 0) >> 2;
    r22 = HEAP32[r21];
    r14 = r24 + 12 | 0;
    r15 = (HEAP8[r14] & 1) << 24 >> 24 != 0;
    if ((r24 | 0) == (HEAP32[r22 >> 2] | 0)) {
      if (r15) {
        r25 = r23;
        r26 = r24, r27 = r26 >> 2;
      } else {
        HEAP8[r14] = 1;
        HEAP8[r22 + 12 | 0] = 0;
        __ZNSt3__119__tree_right_rotateIPNS_16__tree_node_baseIPvEEEEvT_(HEAP32[r21]);
        r10 = HEAP32[r24 + 4 >> 2];
        r25 = (r23 | 0) == (r10 | 0) ? r24 : r23;
        r26 = HEAP32[r10 >> 2], r27 = r26 >> 2;
      }
      r28 = HEAP32[r27];
      r29 = (r28 | 0) == 0;
      if (!r29) {
        r10 = HEAP8[r28 + 12 | 0];
        if ((r10 & 1) << 24 >> 24 == 0) {
          r30 = r10;
          r3 = 1092;
          break;
        }
      }
      r31 = HEAP32[r27 + 1];
      if ((r31 | 0) != 0) {
        if ((HEAP8[r31 + 12 | 0] & 1) << 24 >> 24 == 0) {
          r3 = 1090;
          break;
        }
      }
      HEAP8[r26 + 12 | 0] = 0;
      r10 = HEAP32[r27 + 2];
      r32 = r10 + 12 | 0;
      if ((HEAP8[r32] & 1) << 24 >> 24 == 0 | (r10 | 0) == (r25 | 0)) {
        r3 = 1087;
        break;
      }
      r20 = HEAP32[r10 + 8 >> 2];
      r18 = HEAP32[r20 >> 2];
      if ((r10 | 0) != (r18 | 0)) {
        r23 = r25;
        r24 = r18;
        continue;
      }
      r23 = r25;
      r24 = HEAP32[r20 + 4 >> 2];
      continue;
    }
    if (r15) {
      r33 = r23;
      r34 = r24, r35 = r34 >> 2;
    } else {
      HEAP8[r14] = 1;
      HEAP8[r22 + 12 | 0] = 0;
      __ZNSt3__118__tree_left_rotateIPNS_16__tree_node_baseIPvEEEEvT_(HEAP32[r21]);
      r21 = HEAP32[r24 >> 2];
      r33 = (r23 | 0) == (r21 | 0) ? r24 : r23;
      r34 = HEAP32[r21 + 4 >> 2], r35 = r34 >> 2;
    }
    r36 = HEAP32[r35];
    if ((r36 | 0) != 0) {
      r37 = r36 + 12 | 0;
      if ((HEAP8[r37] & 1) << 24 >> 24 == 0) {
        r3 = 1074;
        break;
      }
    }
    r21 = HEAP32[r35 + 1];
    if ((r21 | 0) != 0) {
      r22 = HEAP8[r21 + 12 | 0];
      if ((r22 & 1) << 24 >> 24 == 0) {
        r38 = r22;
        r3 = 1076;
        break;
      }
    }
    HEAP8[r34 + 12 | 0] = 0;
    r22 = HEAP32[r35 + 2];
    if ((r22 | 0) == (r33 | 0)) {
      r39 = r33;
      r3 = 1071;
      break;
    }
    if ((HEAP8[r22 + 12 | 0] & 1) << 24 >> 24 == 0) {
      r39 = r22;
      r3 = 1071;
      break;
    }
    r21 = HEAP32[r22 + 8 >> 2];
    r14 = HEAP32[r21 >> 2];
    if ((r22 | 0) != (r14 | 0)) {
      r23 = r33;
      r24 = r14;
      continue;
    }
    r23 = r33;
    r24 = HEAP32[r21 + 4 >> 2];
  }
  do {
    if (r3 == 1071) {
      HEAP8[r39 + 12 | 0] = 1;
      return;
    } else if (r3 == 1087) {
      HEAP8[r32] = 1;
      return;
    } else if (r3 == 1090) {
      if (r29) {
        r40 = r31;
        r3 = 1094;
        break;
      }
      r30 = HEAP8[r28 + 12 | 0];
      r3 = 1092;
      break;
    } else if (r3 == 1074) {
      r24 = HEAP32[r35 + 1];
      if ((r24 | 0) == 0) {
        r41 = r37;
        r3 = 1078;
        break;
      }
      r38 = HEAP8[r24 + 12 | 0];
      r3 = 1076;
      break;
    }
  } while (0);
  do {
    if (r3 == 1092) {
      if ((r30 & 1) << 24 >> 24 == 0) {
        r42 = r26;
        r3 = 1095;
        break;
      }
      r40 = HEAP32[r27 + 1];
      r3 = 1094;
      break;
    } else if (r3 == 1076) {
      if ((r38 & 1) << 24 >> 24 == 0) {
        r43 = r34;
        r3 = 1079;
        break;
      }
      r41 = r36 + 12 | 0;
      r3 = 1078;
      break;
    }
  } while (0);
  do {
    if (r3 == 1078) {
      HEAP8[r41] = 1;
      HEAP8[r34 + 12 | 0] = 0;
      __ZNSt3__119__tree_right_rotateIPNS_16__tree_node_baseIPvEEEEvT_(r34);
      r43 = HEAP32[r35 + 2];
      r3 = 1079;
      break;
    } else if (r3 == 1094) {
      HEAP8[r40 + 12 | 0] = 1;
      HEAP8[r26 + 12 | 0] = 0;
      __ZNSt3__118__tree_left_rotateIPNS_16__tree_node_baseIPvEEEEvT_(r26);
      r42 = HEAP32[r27 + 2];
      r3 = 1095;
      break;
    }
  } while (0);
  if (r3 == 1079) {
    r27 = r43 + 8 | 0;
    r26 = HEAP32[r27 >> 2] + 12 | 0;
    HEAP8[r43 + 12 | 0] = HEAP8[r26] & 1;
    HEAP8[r26] = 1;
    HEAP8[HEAP32[r43 + 4 >> 2] + 12 | 0] = 1;
    __ZNSt3__118__tree_left_rotateIPNS_16__tree_node_baseIPvEEEEvT_(HEAP32[r27 >> 2]);
    return;
  } else if (r3 == 1095) {
    r3 = r42 + 8 | 0;
    r27 = HEAP32[r3 >> 2] + 12 | 0;
    HEAP8[r42 + 12 | 0] = HEAP8[r27] & 1;
    HEAP8[r27] = 1;
    HEAP8[HEAP32[r42 >> 2] + 12 | 0] = 1;
    __ZNSt3__119__tree_right_rotateIPNS_16__tree_node_baseIPvEEEEvT_(HEAP32[r3 >> 2]);
    return;
  }
}
__ZNSt3__113__tree_removeIPNS_16__tree_node_baseIPvEEEEvT_S5_["X"] = 1;
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE14__erase_uniqueIS2_EEjRKT_(r1, r2) {
  var r3, r4;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 8 | 0;
  r4 = r3;
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r4, r1, r2);
  r2 = HEAP32[r4 >> 2];
  if ((r2 | 0) == (r1 + 4 | 0)) {
    STACKTOP = r3;
    return;
  }
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE5eraseENS_21__tree_const_iteratorIS2_PKNS_11__tree_nodeIS2_PvEEiEE(r3 + 4, r1, r2);
  STACKTOP = r3;
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE5eraseENS_21__tree_const_iteratorIS2_PKNS_11__tree_nodeIS2_PvEEiEE(r1, r2, r3) {
  var r4, r5;
  r4 = r3 | 0;
  r5 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r4);
  HEAP32[r1 >> 2] = r5;
  r1 = r2 | 0;
  if ((HEAP32[r1 >> 2] | 0) == (r3 | 0)) {
    HEAP32[r1 >> 2] = r5;
  }
  r5 = r2 + 8 | 0;
  HEAP32[r5 >> 2] = HEAP32[r5 >> 2] - 1 | 0;
  __ZNSt3__113__tree_removeIPNS_16__tree_node_baseIPvEEEEvT_S5_(HEAP32[r2 + 4 >> 2], r4);
  __ZdlPv(r3);
  return;
}
function __ZN13MultipleShapeC2Ev(r1) {
  __ZN12LabeledShapeC2EN5Shape9ShapeTypeE(r1 | 0, 1);
  HEAP32[r1 >> 2] = 5244400;
  __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC1ERKSA_(r1 + 20 | 0);
  HEAP32[r1 + 32 >> 2] = 0;
  return;
}
function __ZN12LabeledShapeC2EN5Shape9ShapeTypeE(r1, r2) {
  __ZN5ShapeC2ENS_9ShapeTypeE(r1 | 0, r2);
  HEAP32[r1 >> 2] = 5244424;
  HEAP8[r1 + 16 | 0] = 0;
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC1ERKSA_(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC2ERKSA_(r1);
  return;
}
function __ZN12LabeledShapeD0Ev(r1) {
  __ZdlPv(r1);
  return;
}
function __ZN5ShapeD0Ev(r1) {
  __ZdlPv(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE14__erase_uniqueIS3_EEjRKT_(r1, r2) {
  var r3, r4;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 8 | 0;
  r4 = r3;
  __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE4findIS3_EENS_15__tree_iteratorISA_PNS_11__tree_nodeISA_PvEEiEERKT_(r4, r1, r2);
  r2 = HEAP32[r4 >> 2];
  if ((r2 | 0) == (r1 + 4 | 0)) {
    STACKTOP = r3;
    return;
  }
  __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE5eraseENS_21__tree_const_iteratorISA_PKNS_11__tree_nodeISA_PvEEiEE(r3 + 4, r1, r2);
  STACKTOP = r3;
  return;
}
function __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r1) {
  var r2, r3, r4;
  r2 = HEAP32[r1 + 4 >> 2];
  if ((r2 | 0) == 0) {
    r3 = r1;
    while (1) {
      r1 = HEAP32[r3 + 8 >> 2];
      if ((r3 | 0) == (HEAP32[r1 >> 2] | 0)) {
        r4 = r1;
        break;
      } else {
        r3 = r1;
      }
    }
    return r4;
  } else {
    r3 = r2;
    while (1) {
      r2 = HEAP32[r3 >> 2];
      if ((r2 | 0) == 0) {
        r4 = r3;
        break;
      } else {
        r3 = r2;
      }
    }
    return r4;
  }
}
function __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEE16__find_equal_keyERPNS_16__tree_node_baseIPvEERSA_(r1, r2, r3) {
  var r4, r5, r6, r7, r8, r9;
  r4 = 0;
  r5 = r1 + 4 | 0;
  r1 = r5 | 0;
  r6 = HEAP32[r1 >> 2];
  if ((r6 | 0) == 0) {
    HEAP32[r2 >> 2] = r5;
    r7 = r1;
    return r7;
  }
  r1 = HEAP32[r3 >> 2];
  r3 = r6;
  while (1) {
    r6 = HEAP32[r3 + 16 >> 2];
    if (r1 >>> 0 < r6 >>> 0) {
      r8 = r3 | 0;
      r5 = HEAP32[r8 >> 2];
      if ((r5 | 0) == 0) {
        r4 = 1131;
        break;
      } else {
        r3 = r5;
        continue;
      }
    }
    if (r6 >>> 0 >= r1 >>> 0) {
      r4 = 1135;
      break;
    }
    r9 = r3 + 4 | 0;
    r6 = HEAP32[r9 >> 2];
    if ((r6 | 0) == 0) {
      r4 = 1134;
      break;
    } else {
      r3 = r6;
    }
  }
  if (r4 == 1135) {
    HEAP32[r2 >> 2] = r3;
    r7 = r2;
    return r7;
  } else if (r4 == 1134) {
    HEAP32[r2 >> 2] = r3;
    r7 = r9;
    return r7;
  } else if (r4 == 1131) {
    HEAP32[r2 >> 2] = r3;
    r7 = r8;
    return r7;
  }
}
function __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE13__lower_boundIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_SH_SH_(r1, r2, r3, r4) {
  var r5, r6, r7, r8, r9, r10, r11;
  L1379 : do {
    if ((r3 | 0) == 0) {
      r5 = r4;
    } else {
      r6 = HEAP32[r2 >> 2];
      r7 = r3;
      r8 = r4;
      while (1) {
        r9 = r7, r10 = r9 >> 2;
        while (1) {
          if (HEAP32[r10 + 4] >>> 0 >= r6 >>> 0) {
            break;
          }
          r11 = HEAP32[r10 + 1];
          if ((r11 | 0) == 0) {
            r5 = r8;
            break L1379;
          } else {
            r9 = r11, r10 = r9 >> 2;
          }
        }
        r11 = HEAP32[r10];
        if ((r11 | 0) == 0) {
          r5 = r9;
          break L1379;
        } else {
          r7 = r11;
          r8 = r9;
        }
      }
    }
  } while (0);
  HEAP32[r1 >> 2] = r5;
  return;
}
function __ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEE16__find_equal_keyERPNS_16__tree_node_baseIPvEERS7_(r1, r2, r3) {
  var r4, r5, r6, r7, r8, r9;
  r4 = 0;
  r5 = r1 + 4 | 0;
  r1 = r5 | 0;
  r6 = HEAP32[r1 >> 2];
  if ((r6 | 0) == 0) {
    HEAP32[r2 >> 2] = r5;
    r7 = r1;
    return r7;
  }
  r1 = HEAP32[r3 >> 2];
  r3 = r6;
  while (1) {
    r6 = HEAP32[r3 + 16 >> 2];
    if (r1 >>> 0 < r6 >>> 0) {
      r8 = r3 | 0;
      r5 = HEAP32[r8 >> 2];
      if ((r5 | 0) == 0) {
        r4 = 1153;
        break;
      } else {
        r3 = r5;
        continue;
      }
    }
    if (r6 >>> 0 >= r1 >>> 0) {
      r4 = 1157;
      break;
    }
    r9 = r3 + 4 | 0;
    r6 = HEAP32[r9 >> 2];
    if ((r6 | 0) == 0) {
      r4 = 1156;
      break;
    } else {
      r3 = r6;
    }
  }
  if (r4 == 1156) {
    HEAP32[r2 >> 2] = r3;
    r7 = r9;
    return r7;
  } else if (r4 == 1157) {
    HEAP32[r2 >> 2] = r3;
    r7 = r2;
    return r7;
  } else if (r4 == 1153) {
    HEAP32[r2 >> 2] = r3;
    r7 = r8;
    return r7;
  }
}
function __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEEC2ERKS8_(r1) {
  var r2;
  r2 = r1 + 4 | 0;
  HEAP32[r2 >> 2] = 0;
  HEAP32[r1 + 8 >> 2] = 0;
  HEAP32[r1 >> 2] = r2;
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEEC2ERKSC_(r1) {
  var r2;
  r2 = r1 + 4 | 0;
  HEAP32[r2 >> 2] = 0;
  HEAP32[r1 + 8 >> 2] = 0;
  HEAP32[r1 >> 2] = r2;
  return;
}
function __ZNSt3__111__tree_prevIPKNS_16__tree_node_baseIPvEEEET_S6_(r1) {
  var r2, r3, r4;
  r2 = HEAP32[r1 >> 2];
  if ((r2 | 0) == 0) {
    r3 = r1;
    while (1) {
      r1 = HEAP32[r3 + 8 >> 2];
      if ((r3 | 0) == (HEAP32[r1 >> 2] | 0)) {
        r3 = r1;
      } else {
        r4 = r1;
        break;
      }
    }
    return r4;
  } else {
    r3 = r2;
    while (1) {
      r2 = HEAP32[r3 + 4 >> 2];
      if ((r2 | 0) == 0) {
        r4 = r3;
        break;
      } else {
        r3 = r2;
      }
    }
    return r4;
  }
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC2ERKS7_(r1) {
  var r2;
  r2 = r1 + 4 | 0;
  HEAP32[r2 >> 2] = 0;
  HEAP32[r1 + 8 >> 2] = 0;
  HEAP32[r1 >> 2] = r2;
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE5eraseENS_21__tree_const_iteratorISA_PKNS_11__tree_nodeISA_PvEEiEE(r1, r2, r3) {
  var r4, r5;
  r4 = r3 | 0;
  r5 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r4);
  HEAP32[r1 >> 2] = r5;
  r1 = r2 | 0;
  if ((HEAP32[r1 >> 2] | 0) == (r3 | 0)) {
    HEAP32[r1 >> 2] = r5;
  }
  r5 = r2 + 8 | 0;
  HEAP32[r5 >> 2] = HEAP32[r5 >> 2] - 1 | 0;
  __ZNSt3__14pairIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEEED1Ev(r3 + 16 | 0);
  __ZNSt3__113__tree_removeIPNS_16__tree_node_baseIPvEEEEvT_S5_(HEAP32[r2 + 4 >> 2], r4);
  __ZdlPv(r3);
  return;
}
function __ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEE16__construct_nodeERSA_(r1, r2, r3) {
  var r4, r5;
  r4 = __Znwj(32);
  r5 = r4 + 16 | 0;
  if ((r5 | 0) != 0) {
    HEAP32[r5 >> 2] = HEAP32[r3 >> 2];
  }
  r3 = r4 + 20 | 0;
  if ((r3 | 0) != 0) {
    __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS4_(r3);
  }
  HEAP32[r1 >> 2] = r4;
  HEAP32[r1 + 4 >> 2] = r2 + 4 | 0;
  HEAP8[r1 + 8 | 0] = 1;
  HEAP8[r1 + 9 | 0] = 1;
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSI_SI_(r1, r2, r3, r4) {
  var r5, r6;
  HEAP32[r4 >> 2] = 0;
  HEAP32[r4 + 4 >> 2] = 0;
  HEAP32[r4 + 8 >> 2] = r2;
  HEAP32[r3 >> 2] = r4;
  r2 = r1 | 0;
  r5 = HEAP32[HEAP32[r2 >> 2] >> 2];
  if ((r5 | 0) == 0) {
    r6 = r4;
  } else {
    HEAP32[r2 >> 2] = r5;
    r6 = HEAP32[r3 >> 2];
  }
  __ZNSt3__127__tree_balance_after_insertIPNS_16__tree_node_baseIPvEEEEvT_S5_(HEAP32[r1 + 4 >> 2], r6);
  r6 = r1 + 8 | 0;
  HEAP32[r6 >> 2] = HEAP32[r6 >> 2] + 1 | 0;
  return;
}
function __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassC1ESH_(r1, r2) {
  __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassC2ESH_(r1, r2);
  return;
}
function __ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEEixERS7_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 16 | 0;
  r4 = r3;
  r5 = r3 + 4;
  r6 = __ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEE16__find_equal_keyERPNS_16__tree_node_baseIPvEERS7_(r1, r4, r2);
  r7 = HEAP32[r6 >> 2];
  if ((r7 | 0) != 0) {
    r8 = r7;
    r9 = r8 + 20 | 0;
    STACKTOP = r3;
    return r9;
  }
  __ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEE16__construct_nodeERS7_(r5, r1, r2);
  r2 = r5 | 0;
  r5 = HEAP32[r2 >> 2];
  HEAP32[r2 >> 2] = 0;
  __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSF_SF_(r1 | 0, HEAP32[r4 >> 2], r6, r5 | 0);
  r8 = r5;
  r9 = r8 + 20 | 0;
  STACKTOP = r3;
  return r9;
}
function __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEE9push_backERKS2_(r1, r2) {
  var r3, r4, r5;
  r3 = __Znwj(12);
  r4 = r3;
  r5 = r3 + 8 | 0;
  if ((r5 | 0) != 0) {
    HEAP32[r5 >> 2] = HEAP32[r2 >> 2];
  }
  r2 = (r1 | 0) >> 2;
  HEAP32[HEAP32[r2] + 4 >> 2] = r4;
  HEAP32[r3 >> 2] = HEAP32[r2];
  HEAP32[r2] = r4;
  HEAP32[r3 + 4 >> 2] = r1;
  r3 = r1 + 8 | 0;
  HEAP32[r3 >> 2] = HEAP32[r3 >> 2] + 1 | 0;
  return;
}
function __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEE9pop_frontEv(r1) {
  var r2, r3, r4;
  r2 = HEAP32[r1 + 4 >> 2];
  r3 = r2 + 4 | 0;
  r4 = r2 | 0;
  HEAP32[HEAP32[r4 >> 2] + 4 >> 2] = HEAP32[r3 >> 2];
  HEAP32[HEAP32[r3 >> 2] >> 2] = HEAP32[r4 >> 2];
  r4 = r1 + 8 | 0;
  HEAP32[r4 >> 2] = HEAP32[r4 >> 2] - 1 | 0;
  __ZdlPv(r2);
  return;
}
function __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClass22InvalidateWithChildrenES1_(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 36 | 0;
  r4 = r3;
  r5 = r3 + 4;
  r6 = r3 + 8;
  r7 = r3 + 12;
  r8 = r3 + 24;
  r9 = r3 + 28;
  r10 = r3 + 32;
  HEAP32[r6 >> 2] = r2;
  r2 = r7;
  HEAP32[r7 >> 2] = r2;
  r11 = r7 + 4 | 0;
  HEAP32[r11 >> 2] = r2;
  r2 = (r7 + 8 | 0) >> 2;
  HEAP32[r2] = 0;
  __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEE9push_backERKS2_(r7, r6);
  if ((HEAP32[r2] | 0) == 0) {
    __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEED1Ev(r7);
    STACKTOP = r3;
    return;
  }
  r6 = r1 + 4 | 0;
  r12 = r1 | 0;
  r13 = r5 | 0;
  r14 = r6 | 0;
  r15 = r4 | 0;
  r16 = r1 + 8 | 0;
  while (1) {
    HEAP32[r8 >> 2] = HEAP32[HEAP32[r11 >> 2] + 8 >> 2];
    __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEE9pop_frontEv(r7);
    HEAP32[r9 >> 2] = HEAP32[__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEEixERS7_(r6, r8) >> 2];
    __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE4findIS3_EENS_15__tree_iteratorISA_PNS_11__tree_nodeISA_PvEEiEERKT_(r5, HEAP32[r12 >> 2] | 0, r9);
    r1 = HEAP32[r12 >> 2];
    if ((HEAP32[r13 >> 2] | 0) != (r1 + 4 | 0)) {
      __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE14__erase_uniqueIS2_EEjRKT_(__ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEEixERSA_(r1, r9) | 0, r8);
    }
    L1456 : do {
      if ((HEAP32[__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEEixERS7_(r6, r8) >> 2] | 0) != 0) {
        HEAP32[__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEEixERS7_(r6, r8) >> 2] = 0;
        r1 = HEAP32[r8 >> 2];
        r17 = HEAP32[r1 >> 2];
        r18 = r1 + 4 | 0;
        if ((r17 | 0) == (r18 | 0)) {
          break;
        }
        r1 = r18;
        r18 = r17;
        while (1) {
          HEAP32[r10 >> 2] = HEAP32[r18 + 16 >> 2];
          __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_(r4, r14, r10);
          r17 = HEAP32[r15 >> 2];
          do {
            if ((r17 | 0) != (r16 | 0)) {
              if ((HEAP32[r17 + 20 >> 2] | 0) == 0) {
                break;
              }
              __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEE9push_backERKS2_(r7, r10);
            }
          } while (0);
          r17 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r18 | 0);
          if ((r17 | 0) == (r1 | 0)) {
            break L1456;
          } else {
            r18 = r17;
          }
        }
      }
    } while (0);
    if ((HEAP32[r2] | 0) == 0) {
      break;
    }
  }
  __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEED1Ev(r7);
  STACKTOP = r3;
  return;
}
__ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClass22InvalidateWithChildrenES1_["X"] = 1;
function __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEED1Ev(r1) {
  __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEED2Ev(r1);
  return;
}
function __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassD1Ev(r1) {
  __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassD2Ev(r1);
  return;
}
function __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassD2Ev(r1) {
  __ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEED1Ev(r1 + 4 | 0);
  return;
}
function __ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEED1Ev(r1) {
  __ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEED2Ev(r1);
  return;
}
function __ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEED2Ev(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEED1Ev(HEAP32[r1 + 4 >> 2]);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEED1Ev(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEED2Ev(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEED2Ev(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE(r1) {
  if ((r1 | 0) == 0) {
    return;
  } else {
    __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE(HEAP32[r1 >> 2]);
    __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE(HEAP32[r1 + 4 >> 2]);
    __ZdlPv(r1);
    return;
  }
}
function __ZNSt3__14listIP5BlockNS_9allocatorIS2_EEED2Ev(r1) {
  __ZNSt3__110__list_impIP5BlockNS_9allocatorIS2_EEED2Ev(r1 | 0);
  return;
}
function __ZNSt3__110__list_impIP5BlockNS_9allocatorIS2_EEED2Ev(r1) {
  __ZNSt3__110__list_impIP5BlockNS_9allocatorIS2_EEE5clearEv(r1);
  return;
}
function __ZNSt3__110__list_impIP5BlockNS_9allocatorIS2_EEE5clearEv(r1) {
  var r2, r3, r4, r5, r6;
  r2 = r1 + 8 | 0;
  if ((HEAP32[r2 >> 2] | 0) == 0) {
    return;
  }
  r3 = HEAP32[r1 + 4 >> 2];
  r4 = r1;
  r5 = HEAP32[r1 >> 2] + 4 | 0;
  r1 = r3 | 0;
  HEAP32[HEAP32[r1 >> 2] + 4 >> 2] = HEAP32[r5 >> 2];
  HEAP32[HEAP32[r5 >> 2] >> 2] = HEAP32[r1 >> 2];
  HEAP32[r2 >> 2] = 0;
  if ((r3 | 0) == (r4 | 0)) {
    return;
  } else {
    r6 = r3;
  }
  while (1) {
    r3 = HEAP32[r6 + 4 >> 2];
    __ZdlPv(r6);
    if ((r3 | 0) == (r4 | 0)) {
      break;
    } else {
      r6 = r3;
    }
  }
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_(r1, r2, r3) {
  var r4, r5, r6;
  r4 = STACKTOP;
  STACKTOP = STACKTOP + 4 | 0;
  r5 = r4;
  r6 = r2 + 4 | 0;
  r2 = r6;
  __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE13__lower_boundIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_SH_SH_(r5, r3, HEAP32[r6 >> 2], r2);
  r6 = HEAP32[r5 >> 2];
  do {
    if ((r6 | 0) != (r2 | 0)) {
      if (HEAP32[r3 >> 2] >>> 0 < HEAP32[r6 + 16 >> 2] >>> 0) {
        break;
      }
      HEAP32[r1 >> 2] = r6;
      STACKTOP = r4;
      return;
    }
  } while (0);
  HEAP32[r1 >> 2] = r2;
  STACKTOP = r4;
  return;
}
function __ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEE16__construct_nodeERS7_(r1, r2, r3) {
  var r4, r5;
  r4 = __Znwj(24);
  r5 = r4 + 16 | 0;
  if ((r5 | 0) != 0) {
    HEAP32[r5 >> 2] = HEAP32[r3 >> 2];
  }
  r3 = r4 + 20 | 0;
  if ((r3 | 0) != 0) {
    HEAP32[r3 >> 2] = 0;
  }
  HEAP32[r1 >> 2] = r4;
  HEAP32[r1 + 4 >> 2] = r2 + 4 | 0;
  HEAP8[r1 + 8 | 0] = 1;
  HEAP8[r1 + 9 | 0] = 1;
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSF_SF_(r1, r2, r3, r4) {
  var r5, r6;
  HEAP32[r4 >> 2] = 0;
  HEAP32[r4 + 4 >> 2] = 0;
  HEAP32[r4 + 8 >> 2] = r2;
  HEAP32[r3 >> 2] = r4;
  r2 = r1 | 0;
  r5 = HEAP32[HEAP32[r2 >> 2] >> 2];
  if ((r5 | 0) == 0) {
    r6 = r4;
  } else {
    HEAP32[r2 >> 2] = r5;
    r6 = HEAP32[r3 >> 2];
  }
  __ZNSt3__127__tree_balance_after_insertIPNS_16__tree_node_baseIPvEEEEvT_S5_(HEAP32[r1 + 4 >> 2], r6);
  r6 = r1 + 8 | 0;
  HEAP32[r6 >> 2] = HEAP32[r6 >> 2] + 1 | 0;
  return;
}
function __ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassC2ESH_(r1, r2) {
  HEAP32[r1 >> 2] = r2;
  __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEEC1ERKS8_(r1 + 4 | 0);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEEC1ERKS8_(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEEC2ERKS8_(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEEC1ERKSC_(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEEC2ERKSC_(r1);
  return;
}
function __ZN9LoopShapeC1Ev(r1) {
  __ZN9LoopShapeC2Ev(r1);
  return;
}
function __ZN9LoopShapeC2Ev(r1) {
  __ZN12LabeledShapeC2EN5Shape9ShapeTypeE(r1 | 0, 2);
  HEAP32[r1 >> 2] = 5244352;
  HEAP32[r1 + 20 >> 2] = 0;
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS7_(r1) {
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC2ERKS7_(r1);
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueENS_21__tree_const_iteratorIS2_PKNS_11__tree_nodeIS2_PvEEiEERKS2_(r1, r2, r3, r4) {
  var r5, r6, r7, r8, r9, r10;
  r5 = STACKTOP;
  STACKTOP = STACKTOP + 16 | 0;
  r6 = r5;
  r7 = r5 + 4;
  r8 = __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS2_PKNS_11__tree_nodeIS2_SA_EEiEESD_RKT_(r2, r3, r6, r4);
  r3 = HEAP32[r8 >> 2];
  if ((r3 | 0) != 0) {
    r9 = r3;
    r10 = r1 | 0;
    HEAP32[r10 >> 2] = r9;
    STACKTOP = r5;
    return;
  }
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE16__construct_nodeERKS2_(r7, r2, r4);
  r4 = r7 | 0;
  r7 = HEAP32[r4 >> 2];
  HEAP32[r4 >> 2] = 0;
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSB_SB_(r2, HEAP32[r6 >> 2], r8, r7 | 0);
  r9 = r7;
  r10 = r1 | 0;
  HEAP32[r10 >> 2] = r9;
  STACKTOP = r5;
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS2_PKNS_11__tree_nodeIS2_SA_EEiEESD_RKT_(r1, r2, r3, r4) {
  var r5, r6, r7, r8, r9, r10, r11;
  r5 = r3 >> 2;
  r6 = r1 + 4 | 0;
  do {
    if ((r6 | 0) != (r2 | 0)) {
      r7 = HEAP32[r4 >> 2];
      r8 = HEAP32[r2 + 16 >> 2];
      if (r7 >>> 0 < r8 >>> 0) {
        break;
      }
      r9 = r2 | 0;
      if (r8 >>> 0 >= r7 >>> 0) {
        HEAP32[r5] = r9;
        r10 = r3;
        return r10;
      }
      r8 = __ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_(r9);
      do {
        if ((r8 | 0) != (r6 | 0)) {
          if (r7 >>> 0 < HEAP32[r8 + 16 >> 2] >>> 0) {
            break;
          }
          r10 = __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEESD_RKT_(r1, r3, r4);
          return r10;
        }
      } while (0);
      r7 = r2 + 4 | 0;
      if ((HEAP32[r7 >> 2] | 0) == 0) {
        HEAP32[r5] = r9;
        r10 = r7;
        return r10;
      } else {
        HEAP32[r5] = r8;
        r10 = r8 | 0;
        return r10;
      }
    }
  } while (0);
  do {
    if ((HEAP32[r1 >> 2] | 0) == (r2 | 0)) {
      r11 = r2;
    } else {
      r6 = __ZNSt3__111__tree_prevIPKNS_16__tree_node_baseIPvEEEET_S6_(r2 | 0);
      if (HEAP32[r6 + 16 >> 2] >>> 0 < HEAP32[r4 >> 2] >>> 0) {
        r11 = r6;
        break;
      }
      r10 = __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEESD_RKT_(r1, r3, r4);
      return r10;
    }
  } while (0);
  r4 = r2 | 0;
  if ((HEAP32[r4 >> 2] | 0) == 0) {
    HEAP32[r5] = r2 | 0;
    r10 = r4;
    return r10;
  } else {
    HEAP32[r5] = r11 | 0;
    r10 = r11 + 4 | 0;
    return r10;
  }
}
__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS2_PKNS_11__tree_nodeIS2_SA_EEiEESD_RKT_["X"] = 1;
function __ZN11SimpleShapeC1Ev(r1) {
  __ZN11SimpleShapeC2Ev(r1);
  return;
}
function __ZN11SimpleShapeD1Ev(r1) {
  return;
}
function __ZNK10__cxxabiv116__shim_type_info5noop1Ev(r1) {
  return;
}
function __ZNK10__cxxabiv116__shim_type_info5noop2Ev(r1) {
  return;
}
function __ZN10__cxxabiv18is_equalEPKSt9type_infoS2_b(r1, r2) {
  return (r1 | 0) == (r2 | 0);
}
function __ZN16RelooperRecursorC2EP8Relooper(r1, r2) {
  HEAP32[r1 >> 2] = r2;
  return;
}
function __ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEE5beginEv(r1, r2, r3, r4) {
  var r5, r6;
  r5 = (r4 >>> 10 << 2) + r2 | 0;
  if ((r3 | 0) == (r2 | 0)) {
    r6 = 0;
  } else {
    r6 = ((r4 & 1023) << 2) + HEAP32[r5 >> 2] | 0;
  }
  HEAP32[r1 >> 2] = r5;
  HEAP32[r1 + 4 >> 2] = r6;
  return;
}
function __ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEE5beginEv(r1, r2, r3, r4) {
  var r5, r6;
  r5 = (r4 >>> 10 << 2) + r2 | 0;
  if ((r3 | 0) == (r2 | 0)) {
    r6 = 0;
  } else {
    r6 = ((r4 & 1023) << 2) + HEAP32[r5 >> 2] | 0;
  }
  HEAP32[r1 >> 2] = r5;
  HEAP32[r1 + 4 >> 2] = r6;
  return;
}
function __ZN10ministringC2Ev(r1) {
  HEAP32[r1 >> 2] = 0;
  HEAP32[r1 + 4 >> 2] = 0;
  HEAP32[r1 + 8 >> 2] = 0;
  return;
}
function __ZNK10__cxxabiv117__class_type_info24process_found_base_classEPNS_19__dynamic_cast_infoEPvi(r1, r2, r3) {
  var r4, r5;
  r4 = r1 + 16 | 0;
  r5 = HEAP32[r4 >> 2];
  if ((r5 | 0) == 0) {
    HEAP32[r4 >> 2] = r2;
    HEAP32[r1 + 24 >> 2] = r3;
    HEAP32[r1 + 36 >> 2] = 1;
    return;
  }
  if ((r5 | 0) != (r2 | 0)) {
    r2 = r1 + 36 | 0;
    HEAP32[r2 >> 2] = HEAP32[r2 >> 2] + 1 | 0;
    HEAP32[r1 + 24 >> 2] = 2;
    HEAP8[r1 + 54 | 0] = 1;
    return;
  }
  r2 = r1 + 24 | 0;
  if ((HEAP32[r2 >> 2] | 0) != 2) {
    return;
  }
  HEAP32[r2 >> 2] = r3;
  return;
}
function __ZNK10__cxxabiv117__class_type_info29process_static_type_above_dstEPNS_19__dynamic_cast_infoEPKvS4_i(r1, r2, r3, r4) {
  var r5, r6, r7;
  r5 = r1 >> 2;
  HEAP8[r1 + 53 | 0] = 1;
  if ((HEAP32[r5 + 1] | 0) != (r3 | 0)) {
    return;
  }
  HEAP8[r1 + 52 | 0] = 1;
  r3 = r1 + 16 | 0;
  r6 = HEAP32[r3 >> 2];
  if ((r6 | 0) == 0) {
    HEAP32[r3 >> 2] = r2;
    HEAP32[r5 + 6] = r4;
    HEAP32[r5 + 9] = 1;
    if (!((HEAP32[r5 + 12] | 0) == 1 & (r4 | 0) == 1)) {
      return;
    }
    HEAP8[r1 + 54 | 0] = 1;
    return;
  }
  if ((r6 | 0) != (r2 | 0)) {
    r2 = r1 + 36 | 0;
    HEAP32[r2 >> 2] = HEAP32[r2 >> 2] + 1 | 0;
    HEAP8[r1 + 54 | 0] = 1;
    return;
  }
  r2 = r1 + 24 | 0;
  r6 = HEAP32[r2 >> 2];
  if ((r6 | 0) == 2) {
    HEAP32[r2 >> 2] = r4;
    r7 = r4;
  } else {
    r7 = r6;
  }
  if (!((HEAP32[r5 + 12] | 0) == 1 & (r7 | 0) == 1)) {
    return;
  }
  HEAP8[r1 + 54 | 0] = 1;
  return;
}
__ZNK10__cxxabiv117__class_type_info29process_static_type_above_dstEPNS_19__dynamic_cast_infoEPKvS4_i["X"] = 1;
function __ZNK10__cxxabiv117__class_type_info29process_static_type_below_dstEPNS_19__dynamic_cast_infoEPKvi(r1, r2, r3) {
  if ((HEAP32[r1 + 4 >> 2] | 0) != (r2 | 0)) {
    return;
  }
  r2 = r1 + 28 | 0;
  if ((HEAP32[r2 >> 2] | 0) == 1) {
    return;
  }
  HEAP32[r2 >> 2] = r3;
  return;
}
function __ZZN8Relooper9CalculateEP5BlockEN8Analyzer12GetBlocksOutE_0S1_RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEEPS9_(r1, r2, r3) {
  var r4, r5, r6, r7, r8, r9, r10, r11, r12;
  r4 = STACKTOP;
  STACKTOP = STACKTOP + 12 | 0;
  r5 = r4;
  r6 = r4 + 4;
  r7 = HEAP32[r1 >> 2];
  r8 = r1 + 4 | 0;
  if ((r7 | 0) == (r8 | 0)) {
    STACKTOP = r4;
    return;
  }
  r1 = r2 | 0;
  r2 = r3 | 0;
  r9 = r5 | 0;
  r10 = r3 + 4 | 0;
  r11 = r8;
  if ((r3 | 0) == 0) {
    r3 = r7;
    while (1) {
      __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r6, r1, r3 + 16 | 0);
      r8 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r3 | 0);
      if ((r8 | 0) == (r11 | 0)) {
        break;
      } else {
        r3 = r8;
      }
    }
    STACKTOP = r4;
    return;
  } else {
    r12 = r7;
  }
  while (1) {
    r7 = r12 + 16 | 0;
    __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_(r5, r2, r7);
    if ((HEAP32[r9 >> 2] | 0) != (r10 | 0)) {
      __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_(r6, r1, r7);
    }
    r7 = __ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_(r12 | 0);
    if ((r7 | 0) == (r11 | 0)) {
      break;
    } else {
      r12 = r7;
    }
  }
  STACKTOP = r4;
  return;
}
function __ZN11SimpleShapeC2Ev(r1) {
  __ZN5ShapeC2ENS_9ShapeTypeE(r1 | 0, 0);
  HEAP32[r1 >> 2] = 5244448;
  HEAP32[r1 + 16 >> 2] = 0;
  return;
}
function __ZN11SimpleShapeD0Ev(r1) {
  __ZdlPv(r1);
  return;
}
function __ZN11SimpleShape6RenderEb(r1, r2) {
  var r3;
  __ZN5Block6RenderEb(HEAP32[r1 + 16 >> 2], r2);
  r3 = HEAP32[r1 + 8 >> 2];
  if ((r3 | 0) == 0) {
    return;
  }
  FUNCTION_TABLE[HEAP32[HEAP32[r3 >> 2] + 8 >> 2]](r3, r2);
  return;
}
function __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE5clearEv(r1) {
  var r2, r3;
  r2 = r1 + 4 | 0;
  r3 = r2 | 0;
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE7destroyEPNS_11__tree_nodeIS2_PvEE(HEAP32[r3 >> 2]);
  HEAP32[r1 + 8 >> 2] = 0;
  HEAP32[r1 >> 2] = r2;
  HEAP32[r3 >> 2] = 0;
  return;
}
function __ZZN8Relooper9CalculateEP5BlockEN8AnalyzerC2E_0PS_(r1, r2) {
  __ZN16RelooperRecursorC2EP8Relooper(r1 | 0, r2);
  return;
}
function __ZZN8Relooper9CalculateEP5BlockEN12PreOptimizerC2EPS_(r1, r2) {
  __ZN16RelooperRecursorC2EP8Relooper(r1 | 0, r2);
  __ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS4_(r1 + 4 | 0);
  return;
}
function __ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEED2Ev(r1) {
  __ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEED2Ev(r1 | 0);
  return;
}
function __ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEED2Ev(r1) {
  var r2, r3, r4, r5;
  __ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEE5clearEv(r1);
  r2 = r1 | 0;
  r3 = HEAP32[r1 + 4 >> 2];
  r4 = HEAP32[r1 + 8 >> 2];
  if ((r3 | 0) == (r4 | 0)) {
    __ZNSt3__114__split_bufferIPP5ShapeNS_9allocatorIS3_EEED1Ev(r2);
    return;
  } else {
    r5 = r3;
  }
  while (1) {
    __ZdlPv(HEAP32[r5 >> 2]);
    r3 = r5 + 4 | 0;
    if ((r3 | 0) == (r4 | 0)) {
      break;
    } else {
      r5 = r3;
    }
  }
  __ZNSt3__114__split_bufferIPP5ShapeNS_9allocatorIS3_EEED1Ev(r2);
  return;
}
function __ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEE5clearEv(r1) {
  var r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18;
  r2 = STACKTOP;
  STACKTOP = STACKTOP + 16 | 0;
  r3 = r2;
  r4 = r2 + 8;
  r5 = (r1 + 4 | 0) >> 2;
  r6 = (r1 + 8 | 0) >> 2;
  r7 = (r1 + 16 | 0) >> 2;
  __ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEE5beginEv(r3, HEAP32[r5], HEAP32[r6], HEAP32[r7]);
  __ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEE3endEv(r4, r1);
  r8 = r3 + 4 | 0;
  r9 = HEAP32[r8 >> 2];
  r10 = HEAP32[r4 + 4 >> 2];
  if ((r9 | 0) != (r10 | 0)) {
    r4 = r3 | 0;
    r3 = HEAP32[r4 >> 2];
    r11 = r9;
    r9 = r3;
    r12 = HEAP32[r3 >> 2];
    while (1) {
      r3 = r11 + 4 | 0;
      if ((r3 - r12 | 0) == 4096) {
        r13 = r9 + 4 | 0;
        HEAP32[r4 >> 2] = r13;
        r14 = HEAP32[r13 >> 2];
        r15 = r14;
        r16 = r13;
        r17 = r14;
      } else {
        r15 = r3;
        r16 = r9;
        r17 = r12;
      }
      if ((r15 | 0) == (r10 | 0)) {
        break;
      } else {
        r11 = r15;
        r9 = r16;
        r12 = r17;
      }
    }
    HEAP32[r8 >> 2] = r10;
  }
  HEAP32[r1 + 20 >> 2] = 0;
  r1 = HEAP32[r5];
  r10 = HEAP32[r6] - r1 >> 2;
  L1647 : do {
    if (r10 >>> 0 > 2) {
      r8 = r1;
      while (1) {
        __ZdlPv(HEAP32[r8 >> 2]);
        r17 = HEAP32[r5] + 4 | 0;
        HEAP32[r5] = r17;
        r12 = HEAP32[r6] - r17 >> 2;
        if (r12 >>> 0 > 2) {
          r8 = r17;
        } else {
          r18 = r12;
          break L1647;
        }
      }
    } else {
      r18 = r10;
    }
  } while (0);
  if ((r18 | 0) == 2) {
    HEAP32[r7] = 1024;
    STACKTOP = r2;
    return;
  } else if ((r18 | 0) == 1) {
    HEAP32[r7] = 512;
    STACKTOP = r2;
    return;
  } else {
    STACKTOP = r2;
    return;
  }
}
__ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEE5clearEv["X"] = 1;
function __ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEED2Ev(r1) {
  __ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEED2Ev(r1 | 0);
  return;
}
function __ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEED2Ev(r1) {
  var r2, r3, r4, r5;
  __ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEE5clearEv(r1);
  r2 = r1 | 0;
  r3 = HEAP32[r1 + 4 >> 2];
  r4 = HEAP32[r1 + 8 >> 2];
  if ((r3 | 0) == (r4 | 0)) {
    __ZNSt3__114__split_bufferIPP5BlockNS_9allocatorIS3_EEED1Ev(r2);
    return;
  } else {
    r5 = r3;
  }
  while (1) {
    __ZdlPv(HEAP32[r5 >> 2]);
    r3 = r5 + 4 | 0;
    if ((r3 | 0) == (r4 | 0)) {
      break;
    } else {
      r5 = r3;
    }
  }
  __ZNSt3__114__split_bufferIPP5BlockNS_9allocatorIS3_EEED1Ev(r2);
  return;
}
function __ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEE5clearEv(r1) {
  var r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18;
  r2 = STACKTOP;
  STACKTOP = STACKTOP + 16 | 0;
  r3 = r2;
  r4 = r2 + 8;
  r5 = (r1 + 4 | 0) >> 2;
  r6 = (r1 + 8 | 0) >> 2;
  r7 = (r1 + 16 | 0) >> 2;
  __ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEE5beginEv(r3, HEAP32[r5], HEAP32[r6], HEAP32[r7]);
  __ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEE3endEv(r4, r1);
  r8 = r3 + 4 | 0;
  r9 = HEAP32[r8 >> 2];
  r10 = HEAP32[r4 + 4 >> 2];
  if ((r9 | 0) != (r10 | 0)) {
    r4 = r3 | 0;
    r3 = HEAP32[r4 >> 2];
    r11 = r9;
    r9 = r3;
    r12 = HEAP32[r3 >> 2];
    while (1) {
      r3 = r11 + 4 | 0;
      if ((r3 - r12 | 0) == 4096) {
        r13 = r9 + 4 | 0;
        HEAP32[r4 >> 2] = r13;
        r14 = HEAP32[r13 >> 2];
        r15 = r14;
        r16 = r13;
        r17 = r14;
      } else {
        r15 = r3;
        r16 = r9;
        r17 = r12;
      }
      if ((r15 | 0) == (r10 | 0)) {
        break;
      } else {
        r11 = r15;
        r9 = r16;
        r12 = r17;
      }
    }
    HEAP32[r8 >> 2] = r10;
  }
  HEAP32[r1 + 20 >> 2] = 0;
  r1 = HEAP32[r5];
  r10 = HEAP32[r6] - r1 >> 2;
  L1674 : do {
    if (r10 >>> 0 > 2) {
      r8 = r1;
      while (1) {
        __ZdlPv(HEAP32[r8 >> 2]);
        r17 = HEAP32[r5] + 4 | 0;
        HEAP32[r5] = r17;
        r12 = HEAP32[r6] - r17 >> 2;
        if (r12 >>> 0 > 2) {
          r8 = r17;
        } else {
          r18 = r12;
          break L1674;
        }
      }
    } else {
      r18 = r10;
    }
  } while (0);
  if ((r18 | 0) == 1) {
    HEAP32[r7] = 512;
    STACKTOP = r2;
    return;
  } else if ((r18 | 0) == 2) {
    HEAP32[r7] = 1024;
    STACKTOP = r2;
    return;
  } else {
    STACKTOP = r2;
    return;
  }
}
__ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEE5clearEv["X"] = 1;
function __ZN10ministringD2Ev(r1) {
  if ((r1 | 0) == 0) {
    return;
  }
  _free(r1);
  return;
}
function __ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED2Ev(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEED1Ev(HEAP32[r1 + 4 >> 2]);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEED1Ev(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEED2Ev(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEED2Ev(r1) {
  __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE(r1);
  return;
}
function __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE(r1) {
  if ((r1 | 0) == 0) {
    return;
  } else {
    __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE(HEAP32[r1 >> 2]);
    __ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE(HEAP32[r1 + 4 >> 2]);
    __ZdlPv(r1);
    return;
  }
}
function __GLOBAL__I_a() {
  ___cxx_global_var_init();
  return;
}
function __ZN10__cxxabiv116__shim_type_infoD2Ev(r1) {
  return;
}
function __ZN10__cxxabiv117__class_type_infoD0Ev(r1) {
  __ZN10__cxxabiv117__class_type_infoD1Ev(r1);
  __ZdlPv(r1);
  return;
}
function __ZN10__cxxabiv117__class_type_infoD1Ev(r1) {
  __ZN10__cxxabiv117__class_type_infoD2Ev(r1);
  return;
}
function __ZN10__cxxabiv117__class_type_infoD2Ev(r1) {
  __ZN10__cxxabiv116__shim_type_infoD2Ev(r1 | 0);
  return;
}
function __ZN10__cxxabiv120__si_class_type_infoD0Ev(r1) {
  __ZN10__cxxabiv120__si_class_type_infoD1Ev(r1);
  __ZdlPv(r1);
  return;
}
function __ZN10__cxxabiv120__si_class_type_infoD1Ev(r1) {
  __ZN10__cxxabiv120__si_class_type_infoD2Ev(r1);
  return;
}
function __ZN10__cxxabiv120__si_class_type_infoD2Ev(r1) {
  __ZN10__cxxabiv117__class_type_infoD2Ev(r1 | 0);
  return;
}
function __ZNK10__cxxabiv117__class_type_info9can_catchEPKNS_16__shim_type_infoERPv(r1, r2, r3) {
  var r4, r5, r6, r7, r8, r9, r10, r11, r12;
  r4 = STACKTOP;
  STACKTOP = STACKTOP + 56 | 0;
  r5 = r4, r6 = r5 >> 2;
  do {
    if (__ZN10__cxxabiv18is_equalEPKSt9type_infoS2_b(r1 | 0, r2 | 0)) {
      r7 = 1;
    } else {
      if ((r2 | 0) == 0) {
        r7 = 0;
        break;
      }
      r8 = ___dynamic_cast(r2, 5244684);
      r9 = r8;
      if ((r8 | 0) == 0) {
        r7 = 0;
        break;
      }
      r10 = r5;
      for (r11 = r10 >> 2, r12 = r11 + 14; r11 < r12; r11++) {
        HEAP32[r11] = 0;
      }
      HEAP32[r6] = r9;
      HEAP32[r6 + 2] = r1;
      HEAP32[r6 + 3] = -1;
      HEAP32[r6 + 12] = 1;
      FUNCTION_TABLE[HEAP32[HEAP32[r8 >> 2] + 28 >> 2]](r9, r5, HEAP32[r3 >> 2], 1);
      if ((HEAP32[r6 + 6] | 0) != 1) {
        r7 = 0;
        break;
      }
      HEAP32[r3 >> 2] = HEAP32[r6 + 4];
      r7 = 1;
    }
  } while (0);
  STACKTOP = r4;
  return r7;
}
function __ZNK10__cxxabiv117__class_type_info27has_unambiguous_public_baseEPNS_19__dynamic_cast_infoEPvi(r1, r2, r3, r4) {
  if (!__ZN10__cxxabiv18is_equalEPKSt9type_infoS2_b(r1 | 0, HEAP32[r2 + 8 >> 2] | 0)) {
    return;
  }
  __ZNK10__cxxabiv117__class_type_info24process_found_base_classEPNS_19__dynamic_cast_infoEPvi(r2, r3, r4);
  return;
}
function __ZNK10__cxxabiv120__si_class_type_info27has_unambiguous_public_baseEPNS_19__dynamic_cast_infoEPvi(r1, r2, r3, r4) {
  var r5;
  if (__ZN10__cxxabiv18is_equalEPKSt9type_infoS2_b(r1 | 0, HEAP32[r2 + 8 >> 2] | 0)) {
    __ZNK10__cxxabiv117__class_type_info24process_found_base_classEPNS_19__dynamic_cast_infoEPvi(r2, r3, r4);
    return;
  } else {
    r5 = HEAP32[r1 + 8 >> 2];
    FUNCTION_TABLE[HEAP32[HEAP32[r5 >> 2] + 28 >> 2]](r5, r2, r3, r4);
    return;
  }
}
function ___dynamic_cast(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17;
  r3 = STACKTOP;
  STACKTOP = STACKTOP + 56 | 0;
  r4 = r3, r5 = r4 >> 2;
  r6 = HEAP32[r1 >> 2];
  r7 = r1 + HEAP32[r6 - 8 >> 2] | 0;
  r8 = HEAP32[r6 - 4 >> 2];
  r6 = r8;
  HEAP32[r5] = r2;
  HEAP32[r5 + 1] = r1;
  HEAP32[r5 + 2] = 5244696;
  HEAP32[r5 + 3] = -1;
  r1 = r4 + 16 | 0;
  r9 = r4 + 20 | 0;
  r10 = r4 + 24 | 0;
  r11 = r4 + 28 | 0;
  r12 = r4 + 32 | 0;
  r13 = r4 + 40 | 0;
  r14 = __ZN10__cxxabiv18is_equalEPKSt9type_infoS2_b(r8, r2 | 0);
  r2 = r1;
  for (r15 = r2 >> 2, r16 = r15 + 9; r15 < r16; r15++) {
    HEAP32[r15] = 0;
  }
  HEAP16[r2 + 36 >> 1] = 0;
  HEAP8[r2 + 38] = 0;
  if (r14) {
    HEAP32[r5 + 12] = 1;
    FUNCTION_TABLE[HEAP32[HEAP32[r8 >> 2] + 20 >> 2]](r6, r4, r7, r7, 1, 0);
    STACKTOP = r3;
    return (HEAP32[r10 >> 2] | 0) == 1 ? r7 : 0;
  }
  FUNCTION_TABLE[HEAP32[HEAP32[r8 >> 2] + 24 >> 2]](r6, r4, r7, 1, 0);
  r7 = HEAP32[r5 + 9];
  if ((r7 | 0) == 1) {
    do {
      if ((HEAP32[r10 >> 2] | 0) != 1) {
        if ((HEAP32[r13 >> 2] | 0) != 0) {
          r17 = 0;
          STACKTOP = r3;
          return r17;
        }
        if ((HEAP32[r11 >> 2] | 0) != 1) {
          r17 = 0;
          STACKTOP = r3;
          return r17;
        }
        if ((HEAP32[r12 >> 2] | 0) == 1) {
          break;
        } else {
          r17 = 0;
        }
        STACKTOP = r3;
        return r17;
      }
    } while (0);
    r17 = HEAP32[r1 >> 2];
    STACKTOP = r3;
    return r17;
  } else if ((r7 | 0) == 0) {
    if ((HEAP32[r13 >> 2] | 0) != 1) {
      r17 = 0;
      STACKTOP = r3;
      return r17;
    }
    if ((HEAP32[r11 >> 2] | 0) != 1) {
      r17 = 0;
      STACKTOP = r3;
      return r17;
    }
    r17 = (HEAP32[r12 >> 2] | 0) == 1 ? HEAP32[r9 >> 2] : 0;
    STACKTOP = r3;
    return r17;
  } else {
    r17 = 0;
    STACKTOP = r3;
    return r17;
  }
}
___dynamic_cast["X"] = 1;
function __ZNK10__cxxabiv120__si_class_type_info16search_below_dstEPNS_19__dynamic_cast_infoEPKvib(r1, r2, r3, r4, r5) {
  var r6, r7, r8, r9, r10, r11, r12, r13;
  r6 = r2 >> 2;
  r7 = 0;
  r8 = r1 | 0;
  if (__ZN10__cxxabiv18is_equalEPKSt9type_infoS2_b(r8, HEAP32[r6 + 2] | 0)) {
    __ZNK10__cxxabiv117__class_type_info29process_static_type_below_dstEPNS_19__dynamic_cast_infoEPKvi(r2, r3, r4);
    return;
  }
  if (!__ZN10__cxxabiv18is_equalEPKSt9type_infoS2_b(r8, HEAP32[r6] | 0)) {
    r8 = HEAP32[r1 + 8 >> 2];
    FUNCTION_TABLE[HEAP32[HEAP32[r8 >> 2] + 24 >> 2]](r8, r2, r3, r4, r5);
    return;
  }
  do {
    if ((HEAP32[r6 + 4] | 0) != (r3 | 0)) {
      r8 = r2 + 20 | 0;
      if ((HEAP32[r8 >> 2] | 0) == (r3 | 0)) {
        break;
      }
      HEAP32[r6 + 8] = r4;
      r9 = (r2 + 44 | 0) >> 2;
      if ((HEAP32[r9] | 0) == 4) {
        return;
      }
      r10 = r2 + 52 | 0;
      HEAP8[r10] = 0;
      r11 = r2 + 53 | 0;
      HEAP8[r11] = 0;
      r12 = HEAP32[r1 + 8 >> 2];
      FUNCTION_TABLE[HEAP32[HEAP32[r12 >> 2] + 20 >> 2]](r12, r2, r3, r3, 1, r5);
      do {
        if ((HEAP8[r11] & 1) << 24 >> 24 == 0) {
          r13 = 0;
          r7 = 1467;
        } else {
          if ((HEAP8[r10] & 1) << 24 >> 24 == 0) {
            r13 = 1;
            r7 = 1467;
            break;
          } else {
            break;
          }
        }
      } while (0);
      L1767 : do {
        if (r7 == 1467) {
          HEAP32[r8 >> 2] = r3;
          r10 = r2 + 40 | 0;
          HEAP32[r10 >> 2] = HEAP32[r10 >> 2] + 1 | 0;
          do {
            if ((HEAP32[r6 + 9] | 0) == 1) {
              if ((HEAP32[r6 + 6] | 0) != 2) {
                r7 = 1470;
                break;
              }
              HEAP8[r2 + 54 | 0] = 1;
              if (r13) {
                break L1767;
              } else {
                break;
              }
            } else {
              r7 = 1470;
            }
          } while (0);
          if (r7 == 1470) {
            if (r13) {
              break;
            }
          }
          HEAP32[r9] = 4;
          return;
        }
      } while (0);
      HEAP32[r9] = 3;
      return;
    }
  } while (0);
  if ((r4 | 0) != 1) {
    return;
  }
  HEAP32[r6 + 8] = 1;
  return;
}
__ZNK10__cxxabiv120__si_class_type_info16search_below_dstEPNS_19__dynamic_cast_infoEPKvib["X"] = 1;
function __ZNK10__cxxabiv117__class_type_info16search_below_dstEPNS_19__dynamic_cast_infoEPKvib(r1, r2, r3, r4, r5) {
  var r6;
  r5 = r2 >> 2;
  r6 = r1 | 0;
  if (__ZN10__cxxabiv18is_equalEPKSt9type_infoS2_b(r6, HEAP32[r5 + 2] | 0)) {
    __ZNK10__cxxabiv117__class_type_info29process_static_type_below_dstEPNS_19__dynamic_cast_infoEPKvi(r2, r3, r4);
    return;
  }
  if (!__ZN10__cxxabiv18is_equalEPKSt9type_infoS2_b(r6, HEAP32[r5] | 0)) {
    return;
  }
  do {
    if ((HEAP32[r5 + 4] | 0) != (r3 | 0)) {
      r6 = r2 + 20 | 0;
      if ((HEAP32[r6 >> 2] | 0) == (r3 | 0)) {
        break;
      }
      HEAP32[r5 + 8] = r4;
      HEAP32[r6 >> 2] = r3;
      r6 = r2 + 40 | 0;
      HEAP32[r6 >> 2] = HEAP32[r6 >> 2] + 1 | 0;
      do {
        if ((HEAP32[r5 + 9] | 0) == 1) {
          if ((HEAP32[r5 + 6] | 0) != 2) {
            break;
          }
          HEAP8[r2 + 54 | 0] = 1;
        }
      } while (0);
      HEAP32[r5 + 11] = 4;
      return;
    }
  } while (0);
  if ((r4 | 0) != 1) {
    return;
  }
  HEAP32[r5 + 8] = 1;
  return;
}
function __ZNK10__cxxabiv120__si_class_type_info16search_above_dstEPNS_19__dynamic_cast_infoEPKvS4_ib(r1, r2, r3, r4, r5, r6) {
  var r7;
  if (__ZN10__cxxabiv18is_equalEPKSt9type_infoS2_b(r1 | 0, HEAP32[r2 + 8 >> 2] | 0)) {
    __ZNK10__cxxabiv117__class_type_info29process_static_type_above_dstEPNS_19__dynamic_cast_infoEPKvS4_i(r2, r3, r4, r5);
    return;
  } else {
    r7 = HEAP32[r1 + 8 >> 2];
    FUNCTION_TABLE[HEAP32[HEAP32[r7 >> 2] + 20 >> 2]](r7, r2, r3, r4, r5, r6);
    return;
  }
}
function __ZNK10__cxxabiv117__class_type_info16search_above_dstEPNS_19__dynamic_cast_infoEPKvS4_ib(r1, r2, r3, r4, r5, r6) {
  if (!__ZN10__cxxabiv18is_equalEPKSt9type_infoS2_b(r1 | 0, HEAP32[r2 + 8 >> 2] | 0)) {
    return;
  }
  __ZNK10__cxxabiv117__class_type_info29process_static_type_above_dstEPNS_19__dynamic_cast_infoEPKvS4_i(r2, r3, r4, r5);
  return;
}
function _malloc(r1) {
  var r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19;
  do {
    if (r1 >>> 0 < 245) {
      if (r1 >>> 0 < 11) {
        r2 = 16;
      } else {
        r2 = r1 + 11 & -8;
      }
      r3 = r2 >>> 3;
      r4 = HEAP32[1310877];
      r5 = r4 >>> (r3 >>> 0);
      if ((r5 & 3 | 0) != 0) {
        r6 = (r5 & 1 ^ 1) + r3 | 0;
        r7 = r6 << 1;
        r8 = (r7 << 2) + 5243548 | 0;
        r9 = (r7 + 2 << 2) + 5243548 | 0;
        r7 = HEAP32[r9 >> 2];
        r10 = r7 + 8 | 0;
        r11 = HEAP32[r10 >> 2];
        do {
          if ((r8 | 0) == (r11 | 0)) {
            HEAP32[1310877] = r4 & (1 << r6 ^ -1);
          } else {
            if (r11 >>> 0 < HEAP32[1310881] >>> 0) {
              _abort();
            } else {
              HEAP32[r9 >> 2] = r11;
              HEAP32[r11 + 12 >> 2] = r8;
              break;
            }
          }
        } while (0);
        r8 = r6 << 3;
        HEAP32[r7 + 4 >> 2] = r8 | 3;
        r11 = r7 + (r8 | 4) | 0;
        HEAP32[r11 >> 2] = HEAP32[r11 >> 2] | 1;
        r12 = r10;
        return r12;
      }
      if (r2 >>> 0 <= HEAP32[1310879] >>> 0) {
        r13 = r2;
        break;
      }
      if ((r5 | 0) == 0) {
        if ((HEAP32[1310878] | 0) == 0) {
          r13 = r2;
          break;
        }
        r11 = _tmalloc_small(r2);
        if ((r11 | 0) == 0) {
          r13 = r2;
          break;
        } else {
          r12 = r11;
        }
        return r12;
      }
      r11 = 2 << r3;
      r8 = r5 << r3 & (r11 | -r11);
      r11 = (r8 & -r8) - 1 | 0;
      r8 = r11 >>> 12 & 16;
      r9 = r11 >>> (r8 >>> 0);
      r11 = r9 >>> 5 & 8;
      r14 = r9 >>> (r11 >>> 0);
      r9 = r14 >>> 2 & 4;
      r15 = r14 >>> (r9 >>> 0);
      r14 = r15 >>> 1 & 2;
      r16 = r15 >>> (r14 >>> 0);
      r15 = r16 >>> 1 & 1;
      r17 = (r11 | r8 | r9 | r14 | r15) + (r16 >>> (r15 >>> 0)) | 0;
      r15 = r17 << 1;
      r16 = (r15 << 2) + 5243548 | 0;
      r14 = (r15 + 2 << 2) + 5243548 | 0;
      r15 = HEAP32[r14 >> 2];
      r9 = r15 + 8 | 0;
      r8 = HEAP32[r9 >> 2];
      do {
        if ((r16 | 0) == (r8 | 0)) {
          HEAP32[1310877] = r4 & (1 << r17 ^ -1);
        } else {
          if (r8 >>> 0 < HEAP32[1310881] >>> 0) {
            _abort();
          } else {
            HEAP32[r14 >> 2] = r8;
            HEAP32[r8 + 12 >> 2] = r16;
            break;
          }
        }
      } while (0);
      r16 = r17 << 3;
      r8 = r16 - r2 | 0;
      HEAP32[r15 + 4 >> 2] = r2 | 3;
      r14 = r15;
      r4 = r14 + r2 | 0;
      HEAP32[r14 + (r2 | 4) >> 2] = r8 | 1;
      HEAP32[r14 + r16 >> 2] = r8;
      r16 = HEAP32[1310879];
      if ((r16 | 0) != 0) {
        r14 = HEAP32[1310882];
        r3 = r16 >>> 3;
        r16 = r3 << 1;
        r5 = (r16 << 2) + 5243548 | 0;
        r10 = HEAP32[1310877];
        r7 = 1 << r3;
        do {
          if ((r10 & r7 | 0) == 0) {
            HEAP32[1310877] = r10 | r7;
            r18 = r5;
            r19 = (r16 + 2 << 2) + 5243548 | 0;
          } else {
            r3 = (r16 + 2 << 2) + 5243548 | 0;
            r6 = HEAP32[r3 >> 2];
            if (r6 >>> 0 >= HEAP32[1310881] >>> 0) {
              r18 = r6;
              r19 = r3;
              break;
            }
            _abort();
          }
        } while (0);
        HEAP32[r19 >> 2] = r14;
        HEAP32[r18 + 12 >> 2] = r14;
        HEAP32[r14 + 8 >> 2] = r18;
        HEAP32[r14 + 12 >> 2] = r5;
      }
      HEAP32[1310879] = r8;
      HEAP32[1310882] = r4;
      r12 = r9;
      return r12;
    } else {
      if (r1 >>> 0 > 4294967231) {
        r13 = -1;
        break;
      }
      r16 = r1 + 11 & -8;
      if ((HEAP32[1310878] | 0) == 0) {
        r13 = r16;
        break;
      }
      r7 = _tmalloc_large(r16);
      if ((r7 | 0) == 0) {
        r13 = r16;
        break;
      } else {
        r12 = r7;
      }
      return r12;
    }
  } while (0);
  r1 = HEAP32[1310879];
  if (r13 >>> 0 > r1 >>> 0) {
    r18 = HEAP32[1310880];
    if (r13 >>> 0 < r18 >>> 0) {
      r19 = r18 - r13 | 0;
      HEAP32[1310880] = r19;
      r18 = HEAP32[1310883];
      r2 = r18;
      HEAP32[1310883] = r2 + r13 | 0;
      HEAP32[r13 + (r2 + 4) >> 2] = r19 | 1;
      HEAP32[r18 + 4 >> 2] = r13 | 3;
      r12 = r18 + 8 | 0;
      return r12;
    } else {
      r12 = _sys_alloc(r13);
      return r12;
    }
  } else {
    r18 = r1 - r13 | 0;
    r19 = HEAP32[1310882];
    if (r18 >>> 0 > 15) {
      r2 = r19;
      HEAP32[1310882] = r2 + r13 | 0;
      HEAP32[1310879] = r18;
      HEAP32[r13 + (r2 + 4) >> 2] = r18 | 1;
      HEAP32[r2 + r1 >> 2] = r18;
      HEAP32[r19 + 4 >> 2] = r13 | 3;
    } else {
      HEAP32[1310879] = 0;
      HEAP32[1310882] = 0;
      HEAP32[r19 + 4 >> 2] = r1 | 3;
      r13 = r1 + (r19 + 4) | 0;
      HEAP32[r13 >> 2] = HEAP32[r13 >> 2] | 1;
    }
    r12 = r19 + 8 | 0;
    return r12;
  }
}
_malloc["X"] = 1;
function _tmalloc_small(r1) {
  var r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21;
  r2 = HEAP32[1310878];
  r3 = (r2 & -r2) - 1 | 0;
  r2 = r3 >>> 12 & 16;
  r4 = r3 >>> (r2 >>> 0);
  r3 = r4 >>> 5 & 8;
  r5 = r4 >>> (r3 >>> 0);
  r4 = r5 >>> 2 & 4;
  r6 = r5 >>> (r4 >>> 0);
  r5 = r6 >>> 1 & 2;
  r7 = r6 >>> (r5 >>> 0);
  r6 = r7 >>> 1 & 1;
  r8 = HEAP32[((r3 | r2 | r4 | r5 | r6) + (r7 >>> (r6 >>> 0)) << 2) + 5243812 >> 2];
  r6 = r8;
  r7 = r8, r5 = r7 >> 2;
  r4 = (HEAP32[r8 + 4 >> 2] & -8) - r1 | 0;
  while (1) {
    r8 = HEAP32[r6 + 16 >> 2];
    if ((r8 | 0) == 0) {
      r2 = HEAP32[r6 + 20 >> 2];
      if ((r2 | 0) == 0) {
        break;
      } else {
        r9 = r2;
      }
    } else {
      r9 = r8;
    }
    r8 = (HEAP32[r9 + 4 >> 2] & -8) - r1 | 0;
    r2 = r8 >>> 0 < r4 >>> 0;
    r6 = r9;
    r7 = r2 ? r9 : r7, r5 = r7 >> 2;
    r4 = r2 ? r8 : r4;
  }
  r9 = r7;
  r6 = HEAP32[1310881];
  if (r9 >>> 0 < r6 >>> 0) {
    _abort();
  }
  r8 = r9 + r1 | 0;
  r2 = r8;
  if (r9 >>> 0 >= r8 >>> 0) {
    _abort();
  }
  r8 = HEAP32[r5 + 6];
  r3 = HEAP32[r5 + 3];
  L1885 : do {
    if ((r3 | 0) == (r7 | 0)) {
      r10 = r7 + 20 | 0;
      r11 = HEAP32[r10 >> 2];
      do {
        if ((r11 | 0) == 0) {
          r12 = r7 + 16 | 0;
          r13 = HEAP32[r12 >> 2];
          if ((r13 | 0) == 0) {
            r14 = 0, r15 = r14 >> 2;
            break L1885;
          } else {
            r16 = r13;
            r17 = r12;
            break;
          }
        } else {
          r16 = r11;
          r17 = r10;
        }
      } while (0);
      while (1) {
        r10 = r16 + 20 | 0;
        r11 = HEAP32[r10 >> 2];
        if ((r11 | 0) != 0) {
          r16 = r11;
          r17 = r10;
          continue;
        }
        r10 = r16 + 16 | 0;
        r11 = HEAP32[r10 >> 2];
        if ((r11 | 0) == 0) {
          break;
        } else {
          r16 = r11;
          r17 = r10;
        }
      }
      if (r17 >>> 0 < r6 >>> 0) {
        _abort();
      } else {
        HEAP32[r17 >> 2] = 0;
        r14 = r16, r15 = r14 >> 2;
        break;
      }
    } else {
      r10 = HEAP32[r5 + 2];
      if (r10 >>> 0 < r6 >>> 0) {
        _abort();
      } else {
        HEAP32[r10 + 12 >> 2] = r3;
        HEAP32[r3 + 8 >> 2] = r10;
        r14 = r3, r15 = r14 >> 2;
        break;
      }
    }
  } while (0);
  L1901 : do {
    if ((r8 | 0) != 0) {
      r3 = r7 + 28 | 0;
      r6 = (HEAP32[r3 >> 2] << 2) + 5243812 | 0;
      do {
        if ((r7 | 0) == (HEAP32[r6 >> 2] | 0)) {
          HEAP32[r6 >> 2] = r14;
          if ((r14 | 0) != 0) {
            break;
          }
          HEAP32[1310878] = HEAP32[1310878] & (1 << HEAP32[r3 >> 2] ^ -1);
          break L1901;
        } else {
          if (r8 >>> 0 < HEAP32[1310881] >>> 0) {
            _abort();
          }
          r16 = r8 + 16 | 0;
          if ((HEAP32[r16 >> 2] | 0) == (r7 | 0)) {
            HEAP32[r16 >> 2] = r14;
          } else {
            HEAP32[r8 + 20 >> 2] = r14;
          }
          if ((r14 | 0) == 0) {
            break L1901;
          }
        }
      } while (0);
      if (r14 >>> 0 < HEAP32[1310881] >>> 0) {
        _abort();
      }
      HEAP32[r15 + 6] = r8;
      r3 = HEAP32[r5 + 4];
      do {
        if ((r3 | 0) != 0) {
          if (r3 >>> 0 < HEAP32[1310881] >>> 0) {
            _abort();
          } else {
            HEAP32[r15 + 4] = r3;
            HEAP32[r3 + 24 >> 2] = r14;
            break;
          }
        }
      } while (0);
      r3 = HEAP32[r5 + 5];
      if ((r3 | 0) == 0) {
        break;
      }
      if (r3 >>> 0 < HEAP32[1310881] >>> 0) {
        _abort();
      } else {
        HEAP32[r15 + 5] = r3;
        HEAP32[r3 + 24 >> 2] = r14;
        break;
      }
    }
  } while (0);
  if (r4 >>> 0 < 16) {
    r14 = r4 + r1 | 0;
    HEAP32[r5 + 1] = r14 | 3;
    r15 = r14 + (r9 + 4) | 0;
    HEAP32[r15 >> 2] = HEAP32[r15 >> 2] | 1;
    r18 = r7 + 8 | 0;
    r19 = r18;
    return r19;
  }
  HEAP32[r5 + 1] = r1 | 3;
  HEAP32[r1 + (r9 + 4) >> 2] = r4 | 1;
  HEAP32[r9 + r4 + r1 >> 2] = r4;
  r1 = HEAP32[1310879];
  if ((r1 | 0) != 0) {
    r9 = HEAP32[1310882];
    r5 = r1 >>> 3;
    r1 = r5 << 1;
    r15 = (r1 << 2) + 5243548 | 0;
    r14 = HEAP32[1310877];
    r8 = 1 << r5;
    do {
      if ((r14 & r8 | 0) == 0) {
        HEAP32[1310877] = r14 | r8;
        r20 = r15;
        r21 = (r1 + 2 << 2) + 5243548 | 0;
      } else {
        r5 = (r1 + 2 << 2) + 5243548 | 0;
        r3 = HEAP32[r5 >> 2];
        if (r3 >>> 0 >= HEAP32[1310881] >>> 0) {
          r20 = r3;
          r21 = r5;
          break;
        }
        _abort();
      }
    } while (0);
    HEAP32[r21 >> 2] = r9;
    HEAP32[r20 + 12 >> 2] = r9;
    HEAP32[r9 + 8 >> 2] = r20;
    HEAP32[r9 + 12 >> 2] = r15;
  }
  HEAP32[1310879] = r4;
  HEAP32[1310882] = r2;
  r18 = r7 + 8 | 0;
  r19 = r18;
  return r19;
}
_tmalloc_small["X"] = 1;
function _sys_alloc(r1) {
  var r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22;
  r2 = 0;
  if ((HEAP32[1310720] | 0) == 0) {
    _init_mparams();
  }
  L1946 : do {
    if ((HEAP32[1310987] & 4 | 0) == 0) {
      r3 = HEAP32[1310883];
      do {
        if ((r3 | 0) == 0) {
          r2 = 1612;
        } else {
          r4 = _segment_holding(r3);
          if ((r4 | 0) == 0) {
            r2 = 1612;
            break;
          }
          r5 = HEAP32[1310722];
          r6 = r1 + 47 - HEAP32[1310880] + r5 & -r5;
          if (r6 >>> 0 >= 2147483647) {
            r7 = 0;
            break;
          }
          r5 = _sbrk(r6);
          r8 = (r5 | 0) == (HEAP32[r4 >> 2] + HEAP32[r4 + 4 >> 2] | 0);
          r9 = r8 ? r5 : -1;
          r10 = r8 ? r6 : 0;
          r11 = r5;
          r12 = r6;
          r2 = 1619;
          break;
        }
      } while (0);
      do {
        if (r2 == 1612) {
          r3 = _sbrk(0);
          if ((r3 | 0) == -1) {
            r7 = 0;
            break;
          }
          r6 = HEAP32[1310722];
          r5 = r6 + (r1 + 47) & -r6;
          r6 = r3;
          r8 = HEAP32[1310721];
          r4 = r8 - 1 | 0;
          if ((r4 & r6 | 0) == 0) {
            r13 = r5;
          } else {
            r13 = r5 - r6 + (r4 + r6 & -r8) | 0;
          }
          if (r13 >>> 0 >= 2147483647) {
            r7 = 0;
            break;
          }
          r8 = _sbrk(r13);
          r6 = (r8 | 0) == (r3 | 0);
          r9 = r6 ? r3 : -1;
          r10 = r6 ? r13 : 0;
          r11 = r8;
          r12 = r13;
          r2 = 1619;
          break;
        }
      } while (0);
      L1959 : do {
        if (r2 == 1619) {
          r8 = -r12 | 0;
          if ((r9 | 0) != -1) {
            r14 = r10;
            r15 = r9;
            r2 = 1632;
            break L1946;
          }
          do {
            if ((r11 | 0) != -1 & r12 >>> 0 < 2147483647) {
              if (r12 >>> 0 >= (r1 + 48 | 0) >>> 0) {
                r16 = r12;
                break;
              }
              r6 = HEAP32[1310722];
              r3 = r1 + 47 - r12 + r6 & -r6;
              if (r3 >>> 0 >= 2147483647) {
                r16 = r12;
                break;
              }
              if ((_sbrk(r3) | 0) == -1) {
                _sbrk(r8);
                r7 = r10;
                break L1959;
              } else {
                r16 = r3 + r12 | 0;
                break;
              }
            } else {
              r16 = r12;
            }
          } while (0);
          if ((r11 | 0) != -1) {
            r14 = r16;
            r15 = r11;
            r2 = 1632;
            break L1946;
          }
          HEAP32[1310987] = HEAP32[1310987] | 4;
          r17 = r10;
          r2 = 1629;
          break L1946;
        }
      } while (0);
      HEAP32[1310987] = HEAP32[1310987] | 4;
      r17 = r7;
      r2 = 1629;
      break;
    } else {
      r17 = 0;
      r2 = 1629;
    }
  } while (0);
  do {
    if (r2 == 1629) {
      r7 = HEAP32[1310722];
      r10 = r7 + (r1 + 47) & -r7;
      if (r10 >>> 0 >= 2147483647) {
        break;
      }
      r7 = _sbrk(r10);
      r10 = _sbrk(0);
      if (!((r10 | 0) != -1 & (r7 | 0) != -1 & r7 >>> 0 < r10 >>> 0)) {
        break;
      }
      r11 = r10 - r7 | 0;
      r10 = r11 >>> 0 > (r1 + 40 | 0) >>> 0;
      r16 = r10 ? r7 : -1;
      if ((r16 | 0) == -1) {
        break;
      } else {
        r14 = r10 ? r11 : r17;
        r15 = r16;
        r2 = 1632;
        break;
      }
    }
  } while (0);
  do {
    if (r2 == 1632) {
      r17 = HEAP32[1310985] + r14 | 0;
      HEAP32[1310985] = r17;
      if (r17 >>> 0 > HEAP32[1310986] >>> 0) {
        HEAP32[1310986] = r17;
      }
      r17 = HEAP32[1310883];
      L1981 : do {
        if ((r17 | 0) == 0) {
          r16 = HEAP32[1310881];
          if ((r16 | 0) == 0 | r15 >>> 0 < r16 >>> 0) {
            HEAP32[1310881] = r15;
          }
          HEAP32[1310988] = r15;
          HEAP32[1310989] = r14;
          HEAP32[1310991] = 0;
          HEAP32[1310886] = HEAP32[1310720];
          HEAP32[1310885] = -1;
          _init_bins();
          _init_top(r15, r14 - 40 | 0);
        } else {
          r16 = 5243952, r11 = r16 >> 2;
          while (1) {
            r18 = HEAP32[r11];
            r19 = r16 + 4 | 0;
            r20 = HEAP32[r19 >> 2];
            if ((r15 | 0) == (r18 + r20 | 0)) {
              r2 = 1640;
              break;
            }
            r10 = HEAP32[r11 + 2];
            if ((r10 | 0) == 0) {
              break;
            } else {
              r16 = r10, r11 = r16 >> 2;
            }
          }
          do {
            if (r2 == 1640) {
              if ((HEAP32[r11 + 3] & 8 | 0) != 0) {
                break;
              }
              r16 = r17;
              if (!(r16 >>> 0 >= r18 >>> 0 & r16 >>> 0 < r15 >>> 0)) {
                break;
              }
              HEAP32[r19 >> 2] = r20 + r14 | 0;
              _init_top(HEAP32[1310883], HEAP32[1310880] + r14 | 0);
              break L1981;
            }
          } while (0);
          if (r15 >>> 0 < HEAP32[1310881] >>> 0) {
            HEAP32[1310881] = r15;
          }
          r11 = r15 + r14 | 0;
          r16 = 5243952;
          while (1) {
            r21 = r16 | 0;
            if ((HEAP32[r21 >> 2] | 0) == (r11 | 0)) {
              r2 = 1648;
              break;
            }
            r10 = HEAP32[r16 + 8 >> 2];
            if ((r10 | 0) == 0) {
              break;
            } else {
              r16 = r10;
            }
          }
          do {
            if (r2 == 1648) {
              if ((HEAP32[r16 + 12 >> 2] & 8 | 0) != 0) {
                break;
              }
              HEAP32[r21 >> 2] = r15;
              r10 = r16 + 4 | 0;
              HEAP32[r10 >> 2] = HEAP32[r10 >> 2] + r14 | 0;
              r22 = _prepend_alloc(r15, r11, r1);
              return r22;
            }
          } while (0);
          _add_segment(r15, r14);
        }
      } while (0);
      r17 = HEAP32[1310880];
      if (r17 >>> 0 <= r1 >>> 0) {
        break;
      }
      r11 = r17 - r1 | 0;
      HEAP32[1310880] = r11;
      r17 = HEAP32[1310883];
      r16 = r17;
      HEAP32[1310883] = r16 + r1 | 0;
      HEAP32[r1 + (r16 + 4) >> 2] = r11 | 1;
      HEAP32[r17 + 4 >> 2] = r1 | 3;
      r22 = r17 + 8 | 0;
      return r22;
    }
  } while (0);
  HEAP32[___errno_location() >> 2] = 12;
  r22 = 0;
  return r22;
}
_sys_alloc["X"] = 1;
function _tmalloc_large(r1) {
  var r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36;
  r2 = r1 >> 2;
  r3 = 0;
  r4 = -r1 | 0;
  r5 = r1 >>> 8;
  do {
    if ((r5 | 0) == 0) {
      r6 = 0;
    } else {
      if (r1 >>> 0 > 16777215) {
        r6 = 31;
        break;
      }
      r7 = (r5 + 1048320 | 0) >>> 16 & 8;
      r8 = r5 << r7;
      r9 = (r8 + 520192 | 0) >>> 16 & 4;
      r10 = r8 << r9;
      r8 = (r10 + 245760 | 0) >>> 16 & 2;
      r11 = 14 - (r9 | r7 | r8) + (r10 << r8 >>> 15) | 0;
      r6 = r1 >>> ((r11 + 7 | 0) >>> 0) & 1 | r11 << 1;
    }
  } while (0);
  r5 = HEAP32[(r6 << 2) + 5243812 >> 2];
  L2015 : do {
    if ((r5 | 0) == 0) {
      r12 = 0;
      r13 = r4;
      r14 = 0;
    } else {
      if ((r6 | 0) == 31) {
        r15 = 0;
      } else {
        r15 = 25 - (r6 >>> 1) | 0;
      }
      r11 = 0;
      r8 = r4;
      r10 = r5, r7 = r10 >> 2;
      r9 = r1 << r15;
      r16 = 0;
      while (1) {
        r17 = HEAP32[r7 + 1] & -8;
        r18 = r17 - r1 | 0;
        if (r18 >>> 0 < r8 >>> 0) {
          if ((r17 | 0) == (r1 | 0)) {
            r12 = r10;
            r13 = r18;
            r14 = r10;
            break L2015;
          } else {
            r19 = r10;
            r20 = r18;
          }
        } else {
          r19 = r11;
          r20 = r8;
        }
        r18 = HEAP32[r7 + 5];
        r17 = HEAP32[((r9 >>> 31 << 2) + 16 >> 2) + r7];
        r21 = (r18 | 0) == 0 | (r18 | 0) == (r17 | 0) ? r16 : r18;
        if ((r17 | 0) == 0) {
          r12 = r19;
          r13 = r20;
          r14 = r21;
          break L2015;
        } else {
          r11 = r19;
          r8 = r20;
          r10 = r17, r7 = r10 >> 2;
          r9 = r9 << 1;
          r16 = r21;
        }
      }
    }
  } while (0);
  do {
    if ((r14 | 0) == 0 & (r12 | 0) == 0) {
      r20 = 2 << r6;
      r19 = HEAP32[1310878] & (r20 | -r20);
      if ((r19 | 0) == 0) {
        r22 = 0;
        return r22;
      } else {
        r20 = (r19 & -r19) - 1 | 0;
        r19 = r20 >>> 12 & 16;
        r15 = r20 >>> (r19 >>> 0);
        r20 = r15 >>> 5 & 8;
        r5 = r15 >>> (r20 >>> 0);
        r15 = r5 >>> 2 & 4;
        r4 = r5 >>> (r15 >>> 0);
        r5 = r4 >>> 1 & 2;
        r16 = r4 >>> (r5 >>> 0);
        r4 = r16 >>> 1 & 1;
        r23 = HEAP32[((r20 | r19 | r15 | r5 | r4) + (r16 >>> (r4 >>> 0)) << 2) + 5243812 >> 2];
        break;
      }
    } else {
      r23 = r14;
    }
  } while (0);
  L2032 : do {
    if ((r23 | 0) == 0) {
      r24 = r13;
      r25 = r12, r26 = r25 >> 2;
    } else {
      r14 = r23, r6 = r14 >> 2;
      r4 = r13;
      r16 = r12;
      while (1) {
        r5 = (HEAP32[r6 + 1] & -8) - r1 | 0;
        r15 = r5 >>> 0 < r4 >>> 0;
        r19 = r15 ? r5 : r4;
        r5 = r15 ? r14 : r16;
        r15 = HEAP32[r6 + 4];
        if ((r15 | 0) != 0) {
          r14 = r15, r6 = r14 >> 2;
          r4 = r19;
          r16 = r5;
          continue;
        }
        r15 = HEAP32[r6 + 5];
        if ((r15 | 0) == 0) {
          r24 = r19;
          r25 = r5, r26 = r25 >> 2;
          break L2032;
        } else {
          r14 = r15, r6 = r14 >> 2;
          r4 = r19;
          r16 = r5;
        }
      }
    }
  } while (0);
  if ((r25 | 0) == 0) {
    r22 = 0;
    return r22;
  }
  if (r24 >>> 0 >= (HEAP32[1310879] - r1 | 0) >>> 0) {
    r22 = 0;
    return r22;
  }
  r12 = r25, r13 = r12 >> 2;
  r23 = HEAP32[1310881];
  if (r12 >>> 0 < r23 >>> 0) {
    _abort();
  }
  r16 = r12 + r1 | 0;
  r4 = r16;
  if (r12 >>> 0 >= r16 >>> 0) {
    _abort();
  }
  r14 = HEAP32[r26 + 6];
  r6 = HEAP32[r26 + 3];
  L2049 : do {
    if ((r6 | 0) == (r25 | 0)) {
      r5 = r25 + 20 | 0;
      r19 = HEAP32[r5 >> 2];
      do {
        if ((r19 | 0) == 0) {
          r15 = r25 + 16 | 0;
          r20 = HEAP32[r15 >> 2];
          if ((r20 | 0) == 0) {
            r27 = 0, r28 = r27 >> 2;
            break L2049;
          } else {
            r29 = r20;
            r30 = r15;
            break;
          }
        } else {
          r29 = r19;
          r30 = r5;
        }
      } while (0);
      while (1) {
        r5 = r29 + 20 | 0;
        r19 = HEAP32[r5 >> 2];
        if ((r19 | 0) != 0) {
          r29 = r19;
          r30 = r5;
          continue;
        }
        r5 = r29 + 16 | 0;
        r19 = HEAP32[r5 >> 2];
        if ((r19 | 0) == 0) {
          break;
        } else {
          r29 = r19;
          r30 = r5;
        }
      }
      if (r30 >>> 0 < r23 >>> 0) {
        _abort();
      } else {
        HEAP32[r30 >> 2] = 0;
        r27 = r29, r28 = r27 >> 2;
        break;
      }
    } else {
      r5 = HEAP32[r26 + 2];
      if (r5 >>> 0 < r23 >>> 0) {
        _abort();
      } else {
        HEAP32[r5 + 12 >> 2] = r6;
        HEAP32[r6 + 8 >> 2] = r5;
        r27 = r6, r28 = r27 >> 2;
        break;
      }
    }
  } while (0);
  L2065 : do {
    if ((r14 | 0) == 0) {
      r31 = r25;
    } else {
      r6 = r25 + 28 | 0;
      r23 = (HEAP32[r6 >> 2] << 2) + 5243812 | 0;
      do {
        if ((r25 | 0) == (HEAP32[r23 >> 2] | 0)) {
          HEAP32[r23 >> 2] = r27;
          if ((r27 | 0) != 0) {
            break;
          }
          HEAP32[1310878] = HEAP32[1310878] & (1 << HEAP32[r6 >> 2] ^ -1);
          r31 = r25;
          break L2065;
        } else {
          if (r14 >>> 0 < HEAP32[1310881] >>> 0) {
            _abort();
          }
          r29 = r14 + 16 | 0;
          if ((HEAP32[r29 >> 2] | 0) == (r25 | 0)) {
            HEAP32[r29 >> 2] = r27;
          } else {
            HEAP32[r14 + 20 >> 2] = r27;
          }
          if ((r27 | 0) == 0) {
            r31 = r25;
            break L2065;
          }
        }
      } while (0);
      if (r27 >>> 0 < HEAP32[1310881] >>> 0) {
        _abort();
      }
      HEAP32[r28 + 6] = r14;
      r6 = HEAP32[r26 + 4];
      do {
        if ((r6 | 0) != 0) {
          if (r6 >>> 0 < HEAP32[1310881] >>> 0) {
            _abort();
          } else {
            HEAP32[r28 + 4] = r6;
            HEAP32[r6 + 24 >> 2] = r27;
            break;
          }
        }
      } while (0);
      r6 = HEAP32[r26 + 5];
      if ((r6 | 0) == 0) {
        r31 = r25;
        break;
      }
      if (r6 >>> 0 < HEAP32[1310881] >>> 0) {
        _abort();
      } else {
        HEAP32[r28 + 5] = r6;
        HEAP32[r6 + 24 >> 2] = r27;
        r31 = r25;
        break;
      }
    }
  } while (0);
  do {
    if (r24 >>> 0 < 16) {
      r25 = r24 + r1 | 0;
      HEAP32[r31 + 4 >> 2] = r25 | 3;
      r27 = r25 + (r12 + 4) | 0;
      HEAP32[r27 >> 2] = HEAP32[r27 >> 2] | 1;
    } else {
      HEAP32[r31 + 4 >> 2] = r1 | 3;
      HEAP32[r2 + (r13 + 1)] = r24 | 1;
      HEAP32[(r24 >> 2) + r13 + r2] = r24;
      r27 = r24 >>> 3;
      if (r24 >>> 0 < 256) {
        r25 = r27 << 1;
        r28 = (r25 << 2) + 5243548 | 0;
        r26 = HEAP32[1310877];
        r14 = 1 << r27;
        do {
          if ((r26 & r14 | 0) == 0) {
            HEAP32[1310877] = r26 | r14;
            r32 = r28;
            r33 = (r25 + 2 << 2) + 5243548 | 0;
          } else {
            r27 = (r25 + 2 << 2) + 5243548 | 0;
            r6 = HEAP32[r27 >> 2];
            if (r6 >>> 0 >= HEAP32[1310881] >>> 0) {
              r32 = r6;
              r33 = r27;
              break;
            }
            _abort();
          }
        } while (0);
        HEAP32[r33 >> 2] = r4;
        HEAP32[r32 + 12 >> 2] = r4;
        HEAP32[r2 + (r13 + 2)] = r32;
        HEAP32[r2 + (r13 + 3)] = r28;
        break;
      }
      r25 = r16;
      r14 = r24 >>> 8;
      do {
        if ((r14 | 0) == 0) {
          r34 = 0;
        } else {
          if (r24 >>> 0 > 16777215) {
            r34 = 31;
            break;
          }
          r26 = (r14 + 1048320 | 0) >>> 16 & 8;
          r27 = r14 << r26;
          r6 = (r27 + 520192 | 0) >>> 16 & 4;
          r23 = r27 << r6;
          r27 = (r23 + 245760 | 0) >>> 16 & 2;
          r29 = 14 - (r6 | r26 | r27) + (r23 << r27 >>> 15) | 0;
          r34 = r24 >>> ((r29 + 7 | 0) >>> 0) & 1 | r29 << 1;
        }
      } while (0);
      r14 = (r34 << 2) + 5243812 | 0;
      HEAP32[r2 + (r13 + 7)] = r34;
      HEAP32[r2 + (r13 + 5)] = 0;
      HEAP32[r2 + (r13 + 4)] = 0;
      r28 = HEAP32[1310878];
      r29 = 1 << r34;
      if ((r28 & r29 | 0) == 0) {
        HEAP32[1310878] = r28 | r29;
        HEAP32[r14 >> 2] = r25;
        HEAP32[r2 + (r13 + 6)] = r14;
        HEAP32[r2 + (r13 + 3)] = r25;
        HEAP32[r2 + (r13 + 2)] = r25;
        break;
      }
      if ((r34 | 0) == 31) {
        r35 = 0;
      } else {
        r35 = 25 - (r34 >>> 1) | 0;
      }
      r29 = r24 << r35;
      r28 = HEAP32[r14 >> 2];
      while (1) {
        if ((HEAP32[r28 + 4 >> 2] & -8 | 0) == (r24 | 0)) {
          break;
        }
        r36 = (r29 >>> 31 << 2) + r28 + 16 | 0;
        r14 = HEAP32[r36 >> 2];
        if ((r14 | 0) == 0) {
          r3 = 1727;
          break;
        } else {
          r29 = r29 << 1;
          r28 = r14;
        }
      }
      if (r3 == 1727) {
        if (r36 >>> 0 < HEAP32[1310881] >>> 0) {
          _abort();
        } else {
          HEAP32[r36 >> 2] = r25;
          HEAP32[r2 + (r13 + 6)] = r28;
          HEAP32[r2 + (r13 + 3)] = r25;
          HEAP32[r2 + (r13 + 2)] = r25;
          break;
        }
      }
      r29 = r28 + 8 | 0;
      r14 = HEAP32[r29 >> 2];
      r27 = HEAP32[1310881];
      if (r28 >>> 0 < r27 >>> 0) {
        _abort();
      }
      if (r14 >>> 0 < r27 >>> 0) {
        _abort();
      } else {
        HEAP32[r14 + 12 >> 2] = r25;
        HEAP32[r29 >> 2] = r25;
        HEAP32[r2 + (r13 + 2)] = r14;
        HEAP32[r2 + (r13 + 3)] = r28;
        HEAP32[r2 + (r13 + 6)] = 0;
        break;
      }
    }
  } while (0);
  r22 = r31 + 8 | 0;
  return r22;
}
_tmalloc_large["X"] = 1;
function _release_unused_segments() {
  var r1, r2;
  r1 = 5243960;
  while (1) {
    r2 = HEAP32[r1 >> 2];
    if ((r2 | 0) == 0) {
      break;
    } else {
      r1 = r2 + 8 | 0;
    }
  }
  HEAP32[1310885] = -1;
  return;
}
function _sys_trim() {
  var r1, r2, r3, r4, r5, r6, r7;
  if ((HEAP32[1310720] | 0) == 0) {
    _init_mparams();
  }
  r1 = HEAP32[1310883];
  if ((r1 | 0) == 0) {
    return;
  }
  r2 = HEAP32[1310880];
  do {
    if (r2 >>> 0 > 40) {
      r3 = HEAP32[1310722];
      r4 = (Math.floor(((r2 - 41 + r3 | 0) >>> 0) / (r3 >>> 0)) - 1) * r3 & -1;
      r5 = _segment_holding(r1);
      if ((HEAP32[r5 + 12 >> 2] & 8 | 0) != 0) {
        break;
      }
      r6 = _sbrk(0);
      r7 = (r5 + 4 | 0) >> 2;
      if ((r6 | 0) != (HEAP32[r5 >> 2] + HEAP32[r7] | 0)) {
        break;
      }
      r5 = _sbrk(-(r4 >>> 0 > 2147483646 ? -2147483648 - r3 | 0 : r4) | 0);
      r4 = _sbrk(0);
      if (!((r5 | 0) != -1 & r4 >>> 0 < r6 >>> 0)) {
        break;
      }
      r5 = r6 - r4 | 0;
      if ((r6 | 0) == (r4 | 0)) {
        break;
      }
      HEAP32[r7] = HEAP32[r7] - r5 | 0;
      HEAP32[1310985] = HEAP32[1310985] - r5 | 0;
      _init_top(HEAP32[1310883], HEAP32[1310880] - r5 | 0);
      return;
    }
  } while (0);
  if (HEAP32[1310880] >>> 0 <= HEAP32[1310884] >>> 0) {
    return;
  }
  HEAP32[1310884] = -1;
  return;
}
_sys_trim["X"] = 1;
function _free(r1) {
  var r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40;
  r2 = r1 >> 2;
  r3 = 0;
  if ((r1 | 0) == 0) {
    return;
  }
  r4 = r1 - 8 | 0;
  r5 = r4;
  r6 = HEAP32[1310881];
  if (r4 >>> 0 < r6 >>> 0) {
    _abort();
  }
  r7 = HEAP32[r1 - 4 >> 2];
  r8 = r7 & 3;
  if ((r8 | 0) == 1) {
    _abort();
  }
  r9 = r7 & -8, r10 = r9 >> 2;
  r11 = r1 + (r9 - 8) | 0;
  r12 = r11;
  L2164 : do {
    if ((r7 & 1 | 0) == 0) {
      r13 = HEAP32[r4 >> 2];
      if ((r8 | 0) == 0) {
        return;
      }
      r14 = -8 - r13 | 0, r15 = r14 >> 2;
      r16 = r1 + r14 | 0;
      r17 = r16;
      r18 = r13 + r9 | 0;
      if (r16 >>> 0 < r6 >>> 0) {
        _abort();
      }
      if ((r17 | 0) == (HEAP32[1310882] | 0)) {
        r19 = (r1 + (r9 - 4) | 0) >> 2;
        if ((HEAP32[r19] & 3 | 0) != 3) {
          r20 = r17, r21 = r20 >> 2;
          r22 = r18;
          break;
        }
        HEAP32[1310879] = r18;
        HEAP32[r19] = HEAP32[r19] & -2;
        HEAP32[r15 + (r2 + 1)] = r18 | 1;
        HEAP32[r11 >> 2] = r18;
        return;
      }
      r19 = r13 >>> 3;
      if (r13 >>> 0 < 256) {
        r13 = HEAP32[r15 + (r2 + 2)];
        r23 = HEAP32[r15 + (r2 + 3)];
        if ((r13 | 0) == (r23 | 0)) {
          HEAP32[1310877] = HEAP32[1310877] & (1 << r19 ^ -1);
          r20 = r17, r21 = r20 >> 2;
          r22 = r18;
          break;
        }
        r24 = (r19 << 3) + 5243548 | 0;
        if ((r13 | 0) != (r24 | 0) & r13 >>> 0 < r6 >>> 0) {
          _abort();
        }
        if ((r23 | 0) == (r24 | 0) | r23 >>> 0 >= r6 >>> 0) {
          HEAP32[r13 + 12 >> 2] = r23;
          HEAP32[r23 + 8 >> 2] = r13;
          r20 = r17, r21 = r20 >> 2;
          r22 = r18;
          break;
        } else {
          _abort();
        }
      }
      r13 = r16;
      r16 = HEAP32[r15 + (r2 + 6)];
      r23 = HEAP32[r15 + (r2 + 3)];
      L2189 : do {
        if ((r23 | 0) == (r13 | 0)) {
          r24 = r14 + (r1 + 20) | 0;
          r19 = HEAP32[r24 >> 2];
          do {
            if ((r19 | 0) == 0) {
              r25 = r14 + (r1 + 16) | 0;
              r26 = HEAP32[r25 >> 2];
              if ((r26 | 0) == 0) {
                r27 = 0, r28 = r27 >> 2;
                break L2189;
              } else {
                r29 = r26;
                r30 = r25;
                break;
              }
            } else {
              r29 = r19;
              r30 = r24;
            }
          } while (0);
          while (1) {
            r24 = r29 + 20 | 0;
            r19 = HEAP32[r24 >> 2];
            if ((r19 | 0) != 0) {
              r29 = r19;
              r30 = r24;
              continue;
            }
            r24 = r29 + 16 | 0;
            r19 = HEAP32[r24 >> 2];
            if ((r19 | 0) == 0) {
              break;
            } else {
              r29 = r19;
              r30 = r24;
            }
          }
          if (r30 >>> 0 < r6 >>> 0) {
            _abort();
          } else {
            HEAP32[r30 >> 2] = 0;
            r27 = r29, r28 = r27 >> 2;
            break;
          }
        } else {
          r24 = HEAP32[r15 + (r2 + 2)];
          if (r24 >>> 0 < r6 >>> 0) {
            _abort();
          } else {
            HEAP32[r24 + 12 >> 2] = r23;
            HEAP32[r23 + 8 >> 2] = r24;
            r27 = r23, r28 = r27 >> 2;
            break;
          }
        }
      } while (0);
      if ((r16 | 0) == 0) {
        r20 = r17, r21 = r20 >> 2;
        r22 = r18;
        break;
      }
      r23 = r14 + (r1 + 28) | 0;
      r24 = (HEAP32[r23 >> 2] << 2) + 5243812 | 0;
      do {
        if ((r13 | 0) == (HEAP32[r24 >> 2] | 0)) {
          HEAP32[r24 >> 2] = r27;
          if ((r27 | 0) != 0) {
            break;
          }
          HEAP32[1310878] = HEAP32[1310878] & (1 << HEAP32[r23 >> 2] ^ -1);
          r20 = r17, r21 = r20 >> 2;
          r22 = r18;
          break L2164;
        } else {
          if (r16 >>> 0 < HEAP32[1310881] >>> 0) {
            _abort();
          }
          r19 = r16 + 16 | 0;
          if ((HEAP32[r19 >> 2] | 0) == (r13 | 0)) {
            HEAP32[r19 >> 2] = r27;
          } else {
            HEAP32[r16 + 20 >> 2] = r27;
          }
          if ((r27 | 0) == 0) {
            r20 = r17, r21 = r20 >> 2;
            r22 = r18;
            break L2164;
          }
        }
      } while (0);
      if (r27 >>> 0 < HEAP32[1310881] >>> 0) {
        _abort();
      }
      HEAP32[r28 + 6] = r16;
      r13 = HEAP32[r15 + (r2 + 4)];
      do {
        if ((r13 | 0) != 0) {
          if (r13 >>> 0 < HEAP32[1310881] >>> 0) {
            _abort();
          } else {
            HEAP32[r28 + 4] = r13;
            HEAP32[r13 + 24 >> 2] = r27;
            break;
          }
        }
      } while (0);
      r13 = HEAP32[r15 + (r2 + 5)];
      if ((r13 | 0) == 0) {
        r20 = r17, r21 = r20 >> 2;
        r22 = r18;
        break;
      }
      if (r13 >>> 0 < HEAP32[1310881] >>> 0) {
        _abort();
      } else {
        HEAP32[r28 + 5] = r13;
        HEAP32[r13 + 24 >> 2] = r27;
        r20 = r17, r21 = r20 >> 2;
        r22 = r18;
        break;
      }
    } else {
      r20 = r5, r21 = r20 >> 2;
      r22 = r9;
    }
  } while (0);
  r5 = r20, r27 = r5 >> 2;
  if (r5 >>> 0 >= r11 >>> 0) {
    _abort();
  }
  r5 = r1 + (r9 - 4) | 0;
  r28 = HEAP32[r5 >> 2];
  if ((r28 & 1 | 0) == 0) {
    _abort();
  }
  do {
    if ((r28 & 2 | 0) == 0) {
      if ((r12 | 0) == (HEAP32[1310883] | 0)) {
        r6 = HEAP32[1310880] + r22 | 0;
        HEAP32[1310880] = r6;
        HEAP32[1310883] = r20;
        HEAP32[r21 + 1] = r6 | 1;
        if ((r20 | 0) == (HEAP32[1310882] | 0)) {
          HEAP32[1310882] = 0;
          HEAP32[1310879] = 0;
        }
        if (r6 >>> 0 <= HEAP32[1310884] >>> 0) {
          return;
        }
        _sys_trim();
        return;
      }
      if ((r12 | 0) == (HEAP32[1310882] | 0)) {
        r6 = HEAP32[1310879] + r22 | 0;
        HEAP32[1310879] = r6;
        HEAP32[1310882] = r20;
        HEAP32[r21 + 1] = r6 | 1;
        HEAP32[(r6 >> 2) + r27] = r6;
        return;
      }
      r6 = (r28 & -8) + r22 | 0;
      r29 = r28 >>> 3;
      L2255 : do {
        if (r28 >>> 0 < 256) {
          r30 = HEAP32[r2 + r10];
          r8 = HEAP32[((r9 | 4) >> 2) + r2];
          if ((r30 | 0) == (r8 | 0)) {
            HEAP32[1310877] = HEAP32[1310877] & (1 << r29 ^ -1);
            break;
          }
          r4 = (r29 << 3) + 5243548 | 0;
          do {
            if ((r30 | 0) != (r4 | 0)) {
              if (r30 >>> 0 >= HEAP32[1310881] >>> 0) {
                break;
              }
              _abort();
            }
          } while (0);
          do {
            if ((r8 | 0) != (r4 | 0)) {
              if (r8 >>> 0 >= HEAP32[1310881] >>> 0) {
                break;
              }
              _abort();
            }
          } while (0);
          HEAP32[r30 + 12 >> 2] = r8;
          HEAP32[r8 + 8 >> 2] = r30;
        } else {
          r4 = r11;
          r7 = HEAP32[r10 + (r2 + 4)];
          r13 = HEAP32[((r9 | 4) >> 2) + r2];
          L2269 : do {
            if ((r13 | 0) == (r4 | 0)) {
              r16 = r9 + (r1 + 12) | 0;
              r23 = HEAP32[r16 >> 2];
              do {
                if ((r23 | 0) == 0) {
                  r24 = r9 + (r1 + 8) | 0;
                  r14 = HEAP32[r24 >> 2];
                  if ((r14 | 0) == 0) {
                    r31 = 0, r32 = r31 >> 2;
                    break L2269;
                  } else {
                    r33 = r14;
                    r34 = r24;
                    break;
                  }
                } else {
                  r33 = r23;
                  r34 = r16;
                }
              } while (0);
              while (1) {
                r16 = r33 + 20 | 0;
                r23 = HEAP32[r16 >> 2];
                if ((r23 | 0) != 0) {
                  r33 = r23;
                  r34 = r16;
                  continue;
                }
                r16 = r33 + 16 | 0;
                r23 = HEAP32[r16 >> 2];
                if ((r23 | 0) == 0) {
                  break;
                } else {
                  r33 = r23;
                  r34 = r16;
                }
              }
              if (r34 >>> 0 < HEAP32[1310881] >>> 0) {
                _abort();
              } else {
                HEAP32[r34 >> 2] = 0;
                r31 = r33, r32 = r31 >> 2;
                break;
              }
            } else {
              r16 = HEAP32[r2 + r10];
              if (r16 >>> 0 < HEAP32[1310881] >>> 0) {
                _abort();
              } else {
                HEAP32[r16 + 12 >> 2] = r13;
                HEAP32[r13 + 8 >> 2] = r16;
                r31 = r13, r32 = r31 >> 2;
                break;
              }
            }
          } while (0);
          if ((r7 | 0) == 0) {
            break;
          }
          r13 = r9 + (r1 + 20) | 0;
          r30 = (HEAP32[r13 >> 2] << 2) + 5243812 | 0;
          do {
            if ((r4 | 0) == (HEAP32[r30 >> 2] | 0)) {
              HEAP32[r30 >> 2] = r31;
              if ((r31 | 0) != 0) {
                break;
              }
              HEAP32[1310878] = HEAP32[1310878] & (1 << HEAP32[r13 >> 2] ^ -1);
              break L2255;
            } else {
              if (r7 >>> 0 < HEAP32[1310881] >>> 0) {
                _abort();
              }
              r8 = r7 + 16 | 0;
              if ((HEAP32[r8 >> 2] | 0) == (r4 | 0)) {
                HEAP32[r8 >> 2] = r31;
              } else {
                HEAP32[r7 + 20 >> 2] = r31;
              }
              if ((r31 | 0) == 0) {
                break L2255;
              }
            }
          } while (0);
          if (r31 >>> 0 < HEAP32[1310881] >>> 0) {
            _abort();
          }
          HEAP32[r32 + 6] = r7;
          r4 = HEAP32[r10 + (r2 + 2)];
          do {
            if ((r4 | 0) != 0) {
              if (r4 >>> 0 < HEAP32[1310881] >>> 0) {
                _abort();
              } else {
                HEAP32[r32 + 4] = r4;
                HEAP32[r4 + 24 >> 2] = r31;
                break;
              }
            }
          } while (0);
          r4 = HEAP32[r10 + (r2 + 3)];
          if ((r4 | 0) == 0) {
            break;
          }
          if (r4 >>> 0 < HEAP32[1310881] >>> 0) {
            _abort();
          } else {
            HEAP32[r32 + 5] = r4;
            HEAP32[r4 + 24 >> 2] = r31;
            break;
          }
        }
      } while (0);
      HEAP32[r21 + 1] = r6 | 1;
      HEAP32[(r6 >> 2) + r27] = r6;
      if ((r20 | 0) != (HEAP32[1310882] | 0)) {
        r35 = r6;
        break;
      }
      HEAP32[1310879] = r6;
      return;
    } else {
      HEAP32[r5 >> 2] = r28 & -2;
      HEAP32[r21 + 1] = r22 | 1;
      HEAP32[(r22 >> 2) + r27] = r22;
      r35 = r22;
    }
  } while (0);
  r22 = r35 >>> 3;
  if (r35 >>> 0 < 256) {
    r27 = r22 << 1;
    r28 = (r27 << 2) + 5243548 | 0;
    r5 = HEAP32[1310877];
    r31 = 1 << r22;
    do {
      if ((r5 & r31 | 0) == 0) {
        HEAP32[1310877] = r5 | r31;
        r36 = r28;
        r37 = (r27 + 2 << 2) + 5243548 | 0;
      } else {
        r22 = (r27 + 2 << 2) + 5243548 | 0;
        r32 = HEAP32[r22 >> 2];
        if (r32 >>> 0 >= HEAP32[1310881] >>> 0) {
          r36 = r32;
          r37 = r22;
          break;
        }
        _abort();
      }
    } while (0);
    HEAP32[r37 >> 2] = r20;
    HEAP32[r36 + 12 >> 2] = r20;
    HEAP32[r21 + 2] = r36;
    HEAP32[r21 + 3] = r28;
    return;
  }
  r28 = r20;
  r36 = r35 >>> 8;
  do {
    if ((r36 | 0) == 0) {
      r38 = 0;
    } else {
      if (r35 >>> 0 > 16777215) {
        r38 = 31;
        break;
      }
      r37 = (r36 + 1048320 | 0) >>> 16 & 8;
      r27 = r36 << r37;
      r31 = (r27 + 520192 | 0) >>> 16 & 4;
      r5 = r27 << r31;
      r27 = (r5 + 245760 | 0) >>> 16 & 2;
      r22 = 14 - (r31 | r37 | r27) + (r5 << r27 >>> 15) | 0;
      r38 = r35 >>> ((r22 + 7 | 0) >>> 0) & 1 | r22 << 1;
    }
  } while (0);
  r36 = (r38 << 2) + 5243812 | 0;
  HEAP32[r21 + 7] = r38;
  HEAP32[r21 + 5] = 0;
  HEAP32[r21 + 4] = 0;
  r22 = HEAP32[1310878];
  r27 = 1 << r38;
  do {
    if ((r22 & r27 | 0) == 0) {
      HEAP32[1310878] = r22 | r27;
      HEAP32[r36 >> 2] = r28;
      HEAP32[r21 + 6] = r36;
      HEAP32[r21 + 3] = r20;
      HEAP32[r21 + 2] = r20;
    } else {
      if ((r38 | 0) == 31) {
        r39 = 0;
      } else {
        r39 = 25 - (r38 >>> 1) | 0;
      }
      r5 = r35 << r39;
      r37 = HEAP32[r36 >> 2];
      while (1) {
        if ((HEAP32[r37 + 4 >> 2] & -8 | 0) == (r35 | 0)) {
          break;
        }
        r40 = (r5 >>> 31 << 2) + r37 + 16 | 0;
        r31 = HEAP32[r40 >> 2];
        if ((r31 | 0) == 0) {
          r3 = 1880;
          break;
        } else {
          r5 = r5 << 1;
          r37 = r31;
        }
      }
      if (r3 == 1880) {
        if (r40 >>> 0 < HEAP32[1310881] >>> 0) {
          _abort();
        } else {
          HEAP32[r40 >> 2] = r28;
          HEAP32[r21 + 6] = r37;
          HEAP32[r21 + 3] = r20;
          HEAP32[r21 + 2] = r20;
          break;
        }
      }
      r5 = r37 + 8 | 0;
      r6 = HEAP32[r5 >> 2];
      r31 = HEAP32[1310881];
      if (r37 >>> 0 < r31 >>> 0) {
        _abort();
      }
      if (r6 >>> 0 < r31 >>> 0) {
        _abort();
      } else {
        HEAP32[r6 + 12 >> 2] = r28;
        HEAP32[r5 >> 2] = r28;
        HEAP32[r21 + 2] = r6;
        HEAP32[r21 + 3] = r37;
        HEAP32[r21 + 6] = 0;
        break;
      }
    }
  } while (0);
  r21 = HEAP32[1310885] - 1 | 0;
  HEAP32[1310885] = r21;
  if ((r21 | 0) != 0) {
    return;
  }
  _release_unused_segments();
  return;
}
_free["X"] = 1;
function _mmap_resize(r1, r2) {
  var r3, r4;
  r3 = HEAP32[r1 + 4 >> 2] & -8;
  do {
    if (r2 >>> 0 < 256) {
      r4 = 0;
    } else {
      if (r3 >>> 0 >= (r2 + 4 | 0) >>> 0) {
        if ((r3 - r2 | 0) >>> 0 <= HEAP32[1310722] << 1 >>> 0) {
          r4 = r1;
          break;
        }
      }
      r4 = 0;
    }
  } while (0);
  return r4;
}
function _segment_holding(r1) {
  var r2, r3, r4, r5, r6;
  r2 = 0;
  r3 = 5243952, r4 = r3 >> 2;
  while (1) {
    r5 = HEAP32[r4];
    if (r5 >>> 0 <= r1 >>> 0) {
      if ((r5 + HEAP32[r4 + 1] | 0) >>> 0 > r1 >>> 0) {
        r6 = r3;
        r2 = 1922;
        break;
      }
    }
    r5 = HEAP32[r4 + 2];
    if ((r5 | 0) == 0) {
      r6 = 0;
      r2 = 1923;
      break;
    } else {
      r3 = r5, r4 = r3 >> 2;
    }
  }
  if (r2 == 1923) {
    return r6;
  } else if (r2 == 1922) {
    return r6;
  }
}
function _init_top(r1, r2) {
  var r3, r4, r5;
  r3 = r1;
  r4 = r1 + 8 | 0;
  if ((r4 & 7 | 0) == 0) {
    r5 = 0;
  } else {
    r5 = -r4 & 7;
  }
  r4 = r2 - r5 | 0;
  HEAP32[1310883] = r3 + r5 | 0;
  HEAP32[1310880] = r4;
  HEAP32[r5 + (r3 + 4) >> 2] = r4 | 1;
  HEAP32[r2 + (r3 + 4) >> 2] = 40;
  HEAP32[1310884] = HEAP32[1310724];
  return;
}
function _init_bins() {
  var r1, r2, r3;
  r1 = 0;
  while (1) {
    r2 = r1 << 1;
    r3 = (r2 << 2) + 5243548 | 0;
    HEAP32[(r2 + 3 << 2) + 5243548 >> 2] = r3;
    HEAP32[(r2 + 2 << 2) + 5243548 >> 2] = r3;
    r3 = r1 + 1 | 0;
    if ((r3 | 0) == 32) {
      break;
    } else {
      r1 = r3;
    }
  }
  return;
}
function _realloc(r1, r2) {
  var r3;
  if ((r1 | 0) == 0) {
    r3 = _malloc(r2);
  } else {
    r3 = _internal_realloc(r1, r2);
  }
  return r3;
}
Module["_realloc"] = _realloc;
function _internal_realloc(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16;
  r3 = 0;
  if (r2 >>> 0 > 4294967231) {
    HEAP32[___errno_location() >> 2] = 12;
    r4 = 0;
    return r4;
  }
  r5 = r1 - 8 | 0;
  r6 = r5;
  r7 = (r1 - 4 | 0) >> 2;
  r8 = HEAP32[r7];
  r9 = r8 & -8;
  r10 = r9 - 8 | 0;
  r11 = r1 + r10 | 0;
  if (r5 >>> 0 < HEAP32[1310881] >>> 0) {
    _abort();
  }
  r5 = r8 & 3;
  if (!((r5 | 0) != 1 & (r10 | 0) > -8)) {
    _abort();
  }
  r10 = (r1 + (r9 - 4) | 0) >> 2;
  if ((HEAP32[r10] & 1 | 0) == 0) {
    _abort();
  }
  if (r2 >>> 0 < 11) {
    r12 = 16;
  } else {
    r12 = r2 + 11 & -8;
  }
  do {
    if ((r5 | 0) == 0) {
      r13 = _mmap_resize(r6, r12);
      r14 = 0;
      r3 = 1950;
      break;
    } else {
      if (r9 >>> 0 >= r12 >>> 0) {
        r15 = r9 - r12 | 0;
        if (r15 >>> 0 <= 15) {
          r13 = r6;
          r14 = 0;
          r3 = 1950;
          break;
        }
        HEAP32[r7] = r12 | r8 & 1 | 2;
        HEAP32[r1 + (r12 - 4) >> 2] = r15 | 3;
        HEAP32[r10] = HEAP32[r10] | 1;
        r13 = r6;
        r14 = r1 + r12 | 0;
        r3 = 1950;
        break;
      }
      if ((r11 | 0) != (HEAP32[1310883] | 0)) {
        break;
      }
      r15 = HEAP32[1310880] + r9 | 0;
      if (r15 >>> 0 <= r12 >>> 0) {
        break;
      }
      r16 = r15 - r12 | 0;
      HEAP32[r7] = r12 | r8 & 1 | 2;
      HEAP32[r1 + (r12 - 4) >> 2] = r16 | 1;
      HEAP32[1310883] = r1 + (r12 - 8) | 0;
      HEAP32[1310880] = r16;
      r13 = r6;
      r14 = 0;
      r3 = 1950;
      break;
    }
  } while (0);
  do {
    if (r3 == 1950) {
      if ((r13 | 0) == 0) {
        break;
      }
      if ((r14 | 0) != 0) {
        _free(r14);
      }
      r4 = r13 + 8 | 0;
      return r4;
    }
  } while (0);
  r13 = _malloc(r2);
  if ((r13 | 0) == 0) {
    r4 = 0;
    return r4;
  }
  r14 = r9 - ((HEAP32[r7] & 3 | 0) == 0 ? 8 : 4) | 0;
  _memcpy(r13, r1, r14 >>> 0 < r2 >>> 0 ? r14 : r2);
  _free(r1);
  r4 = r13;
  return r4;
}
_internal_realloc["X"] = 1;
function _init_mparams() {
  var r1;
  if ((HEAP32[1310720] | 0) != 0) {
    return;
  }
  r1 = _sysconf(8);
  if ((r1 - 1 & r1 | 0) != 0) {
    _abort();
  }
  HEAP32[1310722] = r1;
  HEAP32[1310721] = r1;
  HEAP32[1310723] = -1;
  HEAP32[1310724] = 2097152;
  HEAP32[1310725] = 0;
  HEAP32[1310987] = 0;
  HEAP32[1310720] = _time(0) & -16 ^ 1431655768;
  return;
}
function _prepend_alloc(r1, r2, r3) {
  var r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40;
  r4 = r2 >> 2;
  r5 = r1 >> 2;
  r6 = 0;
  r7 = r1 + 8 | 0;
  if ((r7 & 7 | 0) == 0) {
    r8 = 0;
  } else {
    r8 = -r7 & 7;
  }
  r7 = r2 + 8 | 0;
  if ((r7 & 7 | 0) == 0) {
    r9 = 0, r10 = r9 >> 2;
  } else {
    r9 = -r7 & 7, r10 = r9 >> 2;
  }
  r7 = r2 + r9 | 0;
  r11 = r7;
  r12 = r8 + r3 | 0, r13 = r12 >> 2;
  r14 = r1 + r12 | 0;
  r12 = r14;
  r15 = r7 - (r1 + r8) - r3 | 0;
  HEAP32[(r8 + 4 >> 2) + r5] = r3 | 3;
  if ((r11 | 0) == (HEAP32[1310883] | 0)) {
    r3 = HEAP32[1310880] + r15 | 0;
    HEAP32[1310880] = r3;
    HEAP32[1310883] = r12;
    HEAP32[r13 + (r5 + 1)] = r3 | 1;
    r16 = r8 | 8;
    r17 = r1 + r16 | 0;
    return r17;
  }
  if ((r11 | 0) == (HEAP32[1310882] | 0)) {
    r3 = HEAP32[1310879] + r15 | 0;
    HEAP32[1310879] = r3;
    HEAP32[1310882] = r12;
    HEAP32[r13 + (r5 + 1)] = r3 | 1;
    HEAP32[(r3 >> 2) + r5 + r13] = r3;
    r16 = r8 | 8;
    r17 = r1 + r16 | 0;
    return r17;
  }
  r3 = HEAP32[r10 + (r4 + 1)];
  if ((r3 & 3 | 0) == 1) {
    r18 = r3 & -8;
    r19 = r3 >>> 3;
    L2446 : do {
      if (r3 >>> 0 < 256) {
        r20 = HEAP32[((r9 | 8) >> 2) + r4];
        r21 = HEAP32[r10 + (r4 + 3)];
        if ((r20 | 0) == (r21 | 0)) {
          HEAP32[1310877] = HEAP32[1310877] & (1 << r19 ^ -1);
          break;
        }
        r22 = (r19 << 3) + 5243548 | 0;
        do {
          if ((r20 | 0) != (r22 | 0)) {
            if (r20 >>> 0 >= HEAP32[1310881] >>> 0) {
              break;
            }
            _abort();
          }
        } while (0);
        do {
          if ((r21 | 0) != (r22 | 0)) {
            if (r21 >>> 0 >= HEAP32[1310881] >>> 0) {
              break;
            }
            _abort();
          }
        } while (0);
        HEAP32[r20 + 12 >> 2] = r21;
        HEAP32[r21 + 8 >> 2] = r20;
      } else {
        r22 = r7;
        r23 = HEAP32[((r9 | 24) >> 2) + r4];
        r24 = HEAP32[r10 + (r4 + 3)];
        L2448 : do {
          if ((r24 | 0) == (r22 | 0)) {
            r25 = r9 | 16;
            r26 = r25 + (r2 + 4) | 0;
            r27 = HEAP32[r26 >> 2];
            do {
              if ((r27 | 0) == 0) {
                r28 = r2 + r25 | 0;
                r29 = HEAP32[r28 >> 2];
                if ((r29 | 0) == 0) {
                  r30 = 0, r31 = r30 >> 2;
                  break L2448;
                } else {
                  r32 = r29;
                  r33 = r28;
                  break;
                }
              } else {
                r32 = r27;
                r33 = r26;
              }
            } while (0);
            while (1) {
              r26 = r32 + 20 | 0;
              r27 = HEAP32[r26 >> 2];
              if ((r27 | 0) != 0) {
                r32 = r27;
                r33 = r26;
                continue;
              }
              r26 = r32 + 16 | 0;
              r27 = HEAP32[r26 >> 2];
              if ((r27 | 0) == 0) {
                break;
              } else {
                r32 = r27;
                r33 = r26;
              }
            }
            if (r33 >>> 0 < HEAP32[1310881] >>> 0) {
              _abort();
            } else {
              HEAP32[r33 >> 2] = 0;
              r30 = r32, r31 = r30 >> 2;
              break;
            }
          } else {
            r26 = HEAP32[((r9 | 8) >> 2) + r4];
            if (r26 >>> 0 < HEAP32[1310881] >>> 0) {
              _abort();
            } else {
              HEAP32[r26 + 12 >> 2] = r24;
              HEAP32[r24 + 8 >> 2] = r26;
              r30 = r24, r31 = r30 >> 2;
              break;
            }
          }
        } while (0);
        if ((r23 | 0) == 0) {
          break;
        }
        r24 = r9 + (r2 + 28) | 0;
        r20 = (HEAP32[r24 >> 2] << 2) + 5243812 | 0;
        do {
          if ((r22 | 0) == (HEAP32[r20 >> 2] | 0)) {
            HEAP32[r20 >> 2] = r30;
            if ((r30 | 0) != 0) {
              break;
            }
            HEAP32[1310878] = HEAP32[1310878] & (1 << HEAP32[r24 >> 2] ^ -1);
            break L2446;
          } else {
            if (r23 >>> 0 < HEAP32[1310881] >>> 0) {
              _abort();
            }
            r21 = r23 + 16 | 0;
            if ((HEAP32[r21 >> 2] | 0) == (r22 | 0)) {
              HEAP32[r21 >> 2] = r30;
            } else {
              HEAP32[r23 + 20 >> 2] = r30;
            }
            if ((r30 | 0) == 0) {
              break L2446;
            }
          }
        } while (0);
        if (r30 >>> 0 < HEAP32[1310881] >>> 0) {
          _abort();
        }
        HEAP32[r31 + 6] = r23;
        r22 = r9 | 16;
        r24 = HEAP32[(r22 >> 2) + r4];
        do {
          if ((r24 | 0) != 0) {
            if (r24 >>> 0 < HEAP32[1310881] >>> 0) {
              _abort();
            } else {
              HEAP32[r31 + 4] = r24;
              HEAP32[r24 + 24 >> 2] = r30;
              break;
            }
          }
        } while (0);
        r24 = HEAP32[(r22 + 4 >> 2) + r4];
        if ((r24 | 0) == 0) {
          break;
        }
        if (r24 >>> 0 < HEAP32[1310881] >>> 0) {
          _abort();
        } else {
          HEAP32[r31 + 5] = r24;
          HEAP32[r24 + 24 >> 2] = r30;
          break;
        }
      }
    } while (0);
    r34 = r2 + (r18 | r9) | 0;
    r35 = r18 + r15 | 0;
  } else {
    r34 = r11;
    r35 = r15;
  }
  r15 = r34 + 4 | 0;
  HEAP32[r15 >> 2] = HEAP32[r15 >> 2] & -2;
  HEAP32[r13 + (r5 + 1)] = r35 | 1;
  HEAP32[(r35 >> 2) + r5 + r13] = r35;
  r15 = r35 >>> 3;
  if (r35 >>> 0 < 256) {
    r34 = r15 << 1;
    r11 = (r34 << 2) + 5243548 | 0;
    r18 = HEAP32[1310877];
    r9 = 1 << r15;
    do {
      if ((r18 & r9 | 0) == 0) {
        HEAP32[1310877] = r18 | r9;
        r36 = r11;
        r37 = (r34 + 2 << 2) + 5243548 | 0;
      } else {
        r15 = (r34 + 2 << 2) + 5243548 | 0;
        r2 = HEAP32[r15 >> 2];
        if (r2 >>> 0 >= HEAP32[1310881] >>> 0) {
          r36 = r2;
          r37 = r15;
          break;
        }
        _abort();
      }
    } while (0);
    HEAP32[r37 >> 2] = r12;
    HEAP32[r36 + 12 >> 2] = r12;
    HEAP32[r13 + (r5 + 2)] = r36;
    HEAP32[r13 + (r5 + 3)] = r11;
    r16 = r8 | 8;
    r17 = r1 + r16 | 0;
    return r17;
  }
  r11 = r14;
  r14 = r35 >>> 8;
  do {
    if ((r14 | 0) == 0) {
      r38 = 0;
    } else {
      if (r35 >>> 0 > 16777215) {
        r38 = 31;
        break;
      }
      r36 = (r14 + 1048320 | 0) >>> 16 & 8;
      r12 = r14 << r36;
      r37 = (r12 + 520192 | 0) >>> 16 & 4;
      r34 = r12 << r37;
      r12 = (r34 + 245760 | 0) >>> 16 & 2;
      r9 = 14 - (r37 | r36 | r12) + (r34 << r12 >>> 15) | 0;
      r38 = r35 >>> ((r9 + 7 | 0) >>> 0) & 1 | r9 << 1;
    }
  } while (0);
  r14 = (r38 << 2) + 5243812 | 0;
  HEAP32[r13 + (r5 + 7)] = r38;
  HEAP32[r13 + (r5 + 5)] = 0;
  HEAP32[r13 + (r5 + 4)] = 0;
  r9 = HEAP32[1310878];
  r12 = 1 << r38;
  if ((r9 & r12 | 0) == 0) {
    HEAP32[1310878] = r9 | r12;
    HEAP32[r14 >> 2] = r11;
    HEAP32[r13 + (r5 + 6)] = r14;
    HEAP32[r13 + (r5 + 3)] = r11;
    HEAP32[r13 + (r5 + 2)] = r11;
    r16 = r8 | 8;
    r17 = r1 + r16 | 0;
    return r17;
  }
  if ((r38 | 0) == 31) {
    r39 = 0;
  } else {
    r39 = 25 - (r38 >>> 1) | 0;
  }
  r38 = r35 << r39;
  r39 = HEAP32[r14 >> 2];
  while (1) {
    if ((HEAP32[r39 + 4 >> 2] & -8 | 0) == (r35 | 0)) {
      break;
    }
    r40 = (r38 >>> 31 << 2) + r39 + 16 | 0;
    r14 = HEAP32[r40 >> 2];
    if ((r14 | 0) == 0) {
      r6 = 2037;
      break;
    } else {
      r38 = r38 << 1;
      r39 = r14;
    }
  }
  if (r6 == 2037) {
    if (r40 >>> 0 < HEAP32[1310881] >>> 0) {
      _abort();
    }
    HEAP32[r40 >> 2] = r11;
    HEAP32[r13 + (r5 + 6)] = r39;
    HEAP32[r13 + (r5 + 3)] = r11;
    HEAP32[r13 + (r5 + 2)] = r11;
    r16 = r8 | 8;
    r17 = r1 + r16 | 0;
    return r17;
  }
  r40 = r39 + 8 | 0;
  r6 = HEAP32[r40 >> 2];
  r38 = HEAP32[1310881];
  if (r39 >>> 0 < r38 >>> 0) {
    _abort();
  }
  if (r6 >>> 0 < r38 >>> 0) {
    _abort();
  }
  HEAP32[r6 + 12 >> 2] = r11;
  HEAP32[r40 >> 2] = r11;
  HEAP32[r13 + (r5 + 2)] = r6;
  HEAP32[r13 + (r5 + 3)] = r39;
  HEAP32[r13 + (r5 + 6)] = 0;
  r16 = r8 | 8;
  r17 = r1 + r16 | 0;
  return r17;
}
_prepend_alloc["X"] = 1;
function __ZNKSt9bad_alloc4whatEv(r1) {
  return 5243056;
}
function __ZSt15get_new_handlerv() {
  return tempValue = HEAP32[1311197], HEAP32[1311197] = tempValue, tempValue;
}
function __ZNSt9bad_allocC2Ev(r1) {
  HEAP32[r1 >> 2] = 5244328;
  return;
}
function __ZNSt9bad_allocC1Ev(r1) {
  __ZNSt9bad_allocC2Ev(r1);
  return;
}
function __ZNSt9bad_allocD1Ev(r1) {
  __ZNSt9bad_allocD2Ev(r1);
  return;
}
function __ZdlPv(r1) {
  if ((r1 | 0) == 0) {
    return;
  }
  _free(r1);
  return;
}
function __ZNSt9bad_allocD0Ev(r1) {
  __ZNSt9bad_allocD1Ev(r1);
  __ZdlPv(r1);
  return;
}
function __ZNSt9bad_allocD2Ev(r1) {
  return;
}
function _add_segment(r1, r2) {
  var r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16;
  r3 = 0;
  r4 = HEAP32[1310883], r5 = r4 >> 2;
  r6 = r4;
  r7 = _segment_holding(r6);
  r8 = HEAP32[r7 >> 2];
  r9 = HEAP32[r7 + 4 >> 2];
  r7 = r8 + r9 | 0;
  r10 = r8 + (r9 - 39) | 0;
  if ((r10 & 7 | 0) == 0) {
    r11 = 0;
  } else {
    r11 = -r10 & 7;
  }
  r10 = r8 + (r9 - 47) + r11 | 0;
  r11 = r10 >>> 0 < (r4 + 16 | 0) >>> 0 ? r6 : r10;
  r10 = r11 + 8 | 0, r9 = r10 >> 2;
  _init_top(r1, r2 - 40 | 0);
  HEAP32[r11 + 4 >> 2] = 27;
  HEAP32[r9] = HEAP32[1310988];
  HEAP32[r9 + 1] = HEAP32[1310989];
  HEAP32[r9 + 2] = HEAP32[1310990];
  HEAP32[r9 + 3] = HEAP32[1310991];
  HEAP32[1310988] = r1;
  HEAP32[1310989] = r2;
  HEAP32[1310991] = 0;
  HEAP32[1310990] = r10;
  r10 = r11 + 28 | 0;
  HEAP32[r10 >> 2] = 7;
  L2557 : do {
    if ((r11 + 32 | 0) >>> 0 < r7 >>> 0) {
      r2 = r10;
      while (1) {
        r1 = r2 + 4 | 0;
        HEAP32[r1 >> 2] = 7;
        if ((r2 + 8 | 0) >>> 0 < r7 >>> 0) {
          r2 = r1;
        } else {
          break L2557;
        }
      }
    }
  } while (0);
  if ((r11 | 0) == (r6 | 0)) {
    return;
  }
  r7 = r11 - r4 | 0;
  r11 = r7 + (r6 + 4) | 0;
  HEAP32[r11 >> 2] = HEAP32[r11 >> 2] & -2;
  HEAP32[r5 + 1] = r7 | 1;
  HEAP32[r6 + r7 >> 2] = r7;
  r6 = r7 >>> 3;
  if (r7 >>> 0 < 256) {
    r11 = r6 << 1;
    r10 = (r11 << 2) + 5243548 | 0;
    r2 = HEAP32[1310877];
    r1 = 1 << r6;
    do {
      if ((r2 & r1 | 0) == 0) {
        HEAP32[1310877] = r2 | r1;
        r12 = r10;
        r13 = (r11 + 2 << 2) + 5243548 | 0;
      } else {
        r6 = (r11 + 2 << 2) + 5243548 | 0;
        r9 = HEAP32[r6 >> 2];
        if (r9 >>> 0 >= HEAP32[1310881] >>> 0) {
          r12 = r9;
          r13 = r6;
          break;
        }
        _abort();
      }
    } while (0);
    HEAP32[r13 >> 2] = r4;
    HEAP32[r12 + 12 >> 2] = r4;
    HEAP32[r5 + 2] = r12;
    HEAP32[r5 + 3] = r10;
    return;
  }
  r10 = r4;
  r12 = r7 >>> 8;
  do {
    if ((r12 | 0) == 0) {
      r14 = 0;
    } else {
      if (r7 >>> 0 > 16777215) {
        r14 = 31;
        break;
      }
      r13 = (r12 + 1048320 | 0) >>> 16 & 8;
      r11 = r12 << r13;
      r1 = (r11 + 520192 | 0) >>> 16 & 4;
      r2 = r11 << r1;
      r11 = (r2 + 245760 | 0) >>> 16 & 2;
      r6 = 14 - (r1 | r13 | r11) + (r2 << r11 >>> 15) | 0;
      r14 = r7 >>> ((r6 + 7 | 0) >>> 0) & 1 | r6 << 1;
    }
  } while (0);
  r12 = (r14 << 2) + 5243812 | 0;
  HEAP32[r5 + 7] = r14;
  HEAP32[r5 + 5] = 0;
  HEAP32[r5 + 4] = 0;
  r6 = HEAP32[1310878];
  r11 = 1 << r14;
  if ((r6 & r11 | 0) == 0) {
    HEAP32[1310878] = r6 | r11;
    HEAP32[r12 >> 2] = r10;
    HEAP32[r5 + 6] = r12;
    HEAP32[r5 + 3] = r4;
    HEAP32[r5 + 2] = r4;
    return;
  }
  if ((r14 | 0) == 31) {
    r15 = 0;
  } else {
    r15 = 25 - (r14 >>> 1) | 0;
  }
  r14 = r7 << r15;
  r15 = HEAP32[r12 >> 2];
  while (1) {
    if ((HEAP32[r15 + 4 >> 2] & -8 | 0) == (r7 | 0)) {
      break;
    }
    r16 = (r14 >>> 31 << 2) + r15 + 16 | 0;
    r12 = HEAP32[r16 >> 2];
    if ((r12 | 0) == 0) {
      r3 = 2088;
      break;
    } else {
      r14 = r14 << 1;
      r15 = r12;
    }
  }
  if (r3 == 2088) {
    if (r16 >>> 0 < HEAP32[1310881] >>> 0) {
      _abort();
    }
    HEAP32[r16 >> 2] = r10;
    HEAP32[r5 + 6] = r15;
    HEAP32[r5 + 3] = r4;
    HEAP32[r5 + 2] = r4;
    return;
  }
  r4 = r15 + 8 | 0;
  r16 = HEAP32[r4 >> 2];
  r3 = HEAP32[1310881];
  if (r15 >>> 0 < r3 >>> 0) {
    _abort();
  }
  if (r16 >>> 0 < r3 >>> 0) {
    _abort();
  }
  HEAP32[r16 + 12 >> 2] = r10;
  HEAP32[r4 >> 2] = r10;
  HEAP32[r5 + 2] = r16;
  HEAP32[r5 + 3] = r15;
  HEAP32[r5 + 6] = 0;
  return;
}
_add_segment["X"] = 1;
function __Znwj(r1) {
  var r2, r3, r4;
  r2 = 0;
  r3 = (r1 | 0) == 0 ? 1 : r1;
  while (1) {
    r4 = _malloc(r3);
    if ((r4 | 0) != 0) {
      r2 = 2112;
      break;
    }
    r1 = __ZSt15get_new_handlerv();
    if ((r1 | 0) == 0) {
      break;
    }
    FUNCTION_TABLE[r1]();
  }
  if (r2 == 2112) {
    return r4;
  }
  r4 = ___cxa_allocate_exception(4);
  __ZNSt9bad_allocC1Ev(r4);
  ___cxa_throw(r4, 5244660, 42);
}





// Warning: printing of i64 values may be slightly rounded! No deep i64 math used, so precise i64 code not included
var i64Math = null;

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

Module.callMain = function callMain(args) {
  var argc = args.length+1;
  function pad() {
    for (var i = 0; i < 4-1; i++) {
      argv.push(0);
    }
  }
  var argv = [allocate(intArrayFromString("/bin/this.program"), 'i8', ALLOC_STATIC) ];
  pad();
  for (var i = 0; i < argc-1; i = i + 1) {
    argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_STATIC));
    pad();
  }
  argv.push(0);
  argv = allocate(argv, 'i32', ALLOC_STATIC);


  var ret;

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


  return ret;
}




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

  if (runDependencies > 0) {
    Module.printErr('run() called, but dependencies remain, so not running');
    return 0;
  }

  if (Module['preRun']) {
    if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];
    var toRun = Module['preRun'];
    Module['preRun'] = [];
    for (var i = toRun.length-1; i >= 0; i--) {
      toRun[i]();
    }
    if (runDependencies > 0) {
      // a preRun added a dependency, run will be called later
      return 0;
    }
  }

  function doRun() {
    var ret = 0;
    calledRun = true;
    if (Module['_main']) {
      preMain();
      ret = Module.callMain(args);
      if (!Module['noExitRuntime']) {
        exitRuntime();
      }
    }
    if (Module['postRun']) {
      if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];
      while (Module['postRun'].length > 0) {
        Module['postRun'].pop()();
      }
    }
    return ret;
  }

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

// {{PRE_RUN_ADDITIONS}}

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

initRuntime();

var shouldRunNow = true;
if (Module['noInitialRun']) {
  shouldRunNow = false;
}

if (shouldRunNow) {
  var ret = run();
}

// {{POST_RUN_ADDITIONS}}






  // {{MODULE_ADDITIONS}}


// EMSCRIPTEN_GENERATED_FUNCTIONS: ["_sys_trim","__ZNSt3__14pairIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEEED2Ev","__ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEE16__find_equal_keyERPNS_16__tree_node_baseIPvEERSA_","__ZN9LoopShapeD1Ev","___cxx_global_var_init","__ZN13MultipleShape6RenderEb","__ZNK10__cxxabiv117__class_type_info16search_above_dstEPNS_19__dynamic_cast_infoEPKvS4_ib","__ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEEC2EjjS6_","__ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEED2Ev","__ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEED2Ev","__ZNSt9bad_allocC2Ev","__ZN13MultipleShapeC1Ev","_rl_make_output_buffer","__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEEixERS7_","__ZN12LabeledShapeD0Ev","__ZN8RelooperD2Ev","__ZN16RelooperRecursorC2EP8Relooper","__ZNK10__cxxabiv117__class_type_info9can_catchEPKNS_16__shim_type_infoERPv","__ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEEC1EjjS6_","__ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEED1Ev","__ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE5eraseENS_21__tree_const_iteratorIS6_PKNS_11__tree_nodeIS6_PvEEiEE","_rl_relooper_add_block","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE13__lower_boundIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_SD_SD_","__ZNKSt9bad_alloc4whatEv","__ZNSt3__111__tree_nextIPNS_16__tree_node_baseIPvEEEET_S5_","__ZN5ShapeD0Ev","_init_mparams","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS2_PKNS_11__tree_nodeIS2_SA_EEiEESD_RKT_","__ZN10ministringD2Ev","__ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE19__add_back_capacityEv","__ZNK10__cxxabiv117__class_type_info24process_found_base_classEPNS_19__dynamic_cast_infoEPvi","_rl_delete_relooper","__ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED2Ev","__ZNK10__cxxabiv120__si_class_type_info16search_above_dstEPNS_19__dynamic_cast_infoEPKvS4_ib","__ZN13MultipleShapeD2Ev","__ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE4findIS3_EENS_15__tree_iteratorISA_PNS_11__tree_nodeISA_PvEEiEERKT_","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC2ERKS4_","__ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEEC2EjjS6_","__ZN5BlockC2EPKc","__ZN8Relooper8AddBlockEP5Block","__ZNSt3__114__split_bufferIPP5BlockNS_9allocatorIS3_EEED1Ev","__ZN5Shape9IsLabeledEPS_","__ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_","__ZN10__cxxabiv116__shim_type_infoD2Ev","__ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC1ERKSA_","_release_unused_segments","__ZNSt3__14listIP5BlockNS_9allocatorIS2_EEED1Ev","__ZN10ministringpLEPKc","__ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEED1Ev","__ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEED1Ev","__ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE9push_backERKS2_","__ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEE5clearEv","__ZN5Block11AddBranchToEPS_PKcS2_","__ZN5BlockD2Ev","__ZN13MultipleShape16RenderLoopPrefixEv","__ZL13PrintIndentedPKcz","__ZNSt9bad_allocD0Ev","__ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassD1Ev","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS4_","__ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEE10push_frontERKS3_","__ZN6Branch6RenderEP5Blockb","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev","__ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED2Ev","_rl_new_relooper","__ZN5Shape10IsMultipleEPS_","__ZNK10__cxxabiv116__shim_type_info5noop2Ev","__ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEEC1ERKSC_","__ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE5eraseENS_21__tree_const_iteratorISA_PKNS_11__tree_nodeISA_PvEEiEE","__ZNSt3__111__tree_prevIPKNS_16__tree_node_baseIPvEEEET_S6_","__ZN13MultipleShapeD0Ev","__ZN10__cxxabiv120__si_class_type_infoD2Ev","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED2Ev","_rl_new_block","__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED2Ev","__ZZN8Relooper9CalculateEP5BlockEN12PreOptimizer13SplitDeadEndsEv","__ZZN8Relooper9CalculateEP5BlockEN8Analyzer6NoticeE_0P5Shape","__ZZN8Relooper9CalculateEP5BlockEN8Analyzer9SolipsizeE_0S1_N6Branch8FlowTypeEP5ShapeRNSt3__13setIS1_NS7_4lessIS1_EENS7_9allocatorIS1_EEEE","__ZN10__cxxabiv117__class_type_infoD2Ev","__ZN8Relooper6RenderEv","__ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClass22InvalidateWithChildrenES1_","_rl_relooper_calculate","_rl_set_output_buffer","__ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC1ERKSA_","_tmalloc_small","__ZN12LabeledShapeC2EN5Shape9ShapeTypeE","__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEE16__find_equal_keyERPNS_16__tree_node_baseIPvEERS7_","__ZN5Shape8IsSimpleEPS_","__ZZN8Relooper9CalculateEP5BlockEN12PreOptimizerC2EPS_","__ZNK10__cxxabiv117__class_type_info27has_unambiguous_public_baseEPNS_19__dynamic_cast_infoEPvi","__ZSt15get_new_handlerv","__ZNK10__cxxabiv120__si_class_type_info16search_below_dstEPNS_19__dynamic_cast_infoEPKvib","_realloc","__ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEED1Ev","_tmalloc_large","__ZZN8Relooper9CalculateEP5BlockEN13PostOptimizerC2E_1PS_","__ZNSt9bad_allocD1Ev","__ZN13MultipleShapeC2Ev","__ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSH_SH_","__ZN8RelooperC1Ev","__ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEED2Ev","_rl_set_asm_js_mode","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE14__erase_uniqueIS2_EEjRKT_","__ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEED2Ev","__ZNSt3__113__tree_removeIPNS_16__tree_node_baseIPvEEEEvT_S5_","__ZZN8Relooper9CalculateEP5BlockEN8Analyzer7ProcessE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_P5Shape","__ZNSt3__114__split_bufferIPP5BlockNS_9allocatorIS3_EEED2Ev","__ZN5BlockD1Ev","__ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEE3endEv","__ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEED2Ev","_init_top","__ZZN8Relooper9CalculateEP5BlockEN13PostOptimizerC1E_1PS_","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE7destroyEPNS_11__tree_nodeIS2_PvEE","__ZN8Relooper12SetAsmJSModeEi","__ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEED1Ev","__ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_","__ZN10__cxxabiv117__class_type_infoD0Ev","__ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEEC1EjjS6_","__ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_","__ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_","__ZNSt3__13mapIPviNS_4lessIS1_EENS_9allocatorINS_4pairIKS1_iEEEEED2Ev","__ZN10__cxxabiv120__si_class_type_infoD1Ev","__ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE7destroyEPNS_11__tree_nodeISA_PvEE","__Znwj","__ZN6BranchC1EPKcS1_","__GLOBAL__I_a","__ZdlPv","__ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE13__lower_boundIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_SH_SH_","__ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEE7destroyEPNS_11__tree_nodeIS3_S2_EE","_free","__ZNK10__cxxabiv117__class_type_info16search_below_dstEPNS_19__dynamic_cast_infoEPKvib","__ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEED2Ev","__ZN5Block6RenderEb","__ZN13MultipleShapeD1Ev","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueERKS2_","__ZZN8Relooper9CalculateEP5BlockEN12PreOptimizerD1Ev","__ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEED1Ev","__ZN9LoopShapeC1Ev","__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEED2Ev","__ZN10__cxxabiv117__class_type_infoD1Ev","__ZL11PutIndentedPKc","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEESD_RKT_","__ZNSt3__114__split_bufferIPP5ShapeNS_9allocatorIS3_EEE10push_frontERKS3_","__ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE","__ZN11SimpleShapeC2Ev","__ZZN8Relooper9CalculateEP5BlockEN8Analyzer10MakeSimpleE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEES1_SA_","_mmap_resize","__ZNSt3__114__split_bufferIPP5ShapeNS_9allocatorIS3_EEED1Ev","__ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE13__lower_boundIS3_EENS_15__tree_iteratorISA_PNS_11__tree_nodeISA_PvEEiEERKT_SK_SK_","__ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE","__ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEED1Ev","__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_","__ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEE19__add_back_capacityEv","__ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEE5clearEv","_prepend_alloc","__ZNSt3__119__tree_right_rotateIPNS_16__tree_node_baseIPvEEEEvT_","__ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEE16__find_equal_keyERPNS_16__tree_node_baseIPvEERS9_","__ZZN8Relooper9CalculateEP5BlockEN12PreOptimizerD2Ev","__ZZN8Relooper9CalculateEP5BlockEN8AnalyzerC1E_0PS_","_init_bins","__ZN10__cxxabiv18is_equalEPKSt9type_infoS2_b","__ZNK10__cxxabiv117__class_type_info29process_static_type_below_dstEPNS_19__dynamic_cast_infoEPKvi","__ZZN8Relooper9CalculateEP5BlockEN8AnalyzerC2E_0PS_","___dynamic_cast","__ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEED1Ev","__ZN13MultipleShape17RenderLoopPostfixEv","__ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer7ProcessE_1P5Shape","__ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassC1ESH_","__ZN9LoopShape6RenderEb","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC2ERKS7_","__ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC2ERKSA_","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE4findIS2_EENS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEERKT_","__ZN6BranchD2Ev","__ZNK10__cxxabiv120__si_class_type_info27has_unambiguous_public_baseEPNS_19__dynamic_cast_infoEPvi","__ZNSt9bad_allocC1Ev","__ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEED2Ev","__ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEED2Ev","__ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSH_SH_","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE5clearEv","__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEE16__construct_nodeERS7_","__ZN11SimpleShapeD0Ev","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE15__insert_uniqueENS_21__tree_const_iteratorIS2_PKNS_11__tree_nodeIS2_PvEEiEERKS2_","__ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEED2Ev","__ZNSt3__127__tree_balance_after_insertIPNS_16__tree_node_baseIPvEEEEvT_S5_","__ZN9LoopShapeC2Ev","__ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE13__lower_boundIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_SJ_SJ_","__ZNSt3__13setIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEED1Ev","__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEE16__find_equal_keyERPNS_16__tree_node_baseIPvEERS9_","__ZN11SimpleShape6RenderEb","__ZNSt3__112__deque_baseIP5ShapeNS_9allocatorIS2_EEE5beginEv","__ZN8RelooperC2Ev","__ZZN8Relooper9CalculateEP5BlockEN12PreOptimizerC1EPS_","__ZN8Relooper15SetOutputBufferEPci","__ZZN8Relooper9CalculateEP5BlockEN8Analyzer12GetBlocksOutE_0S1_RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEEPS9_","__ZN5BlockC1EPKc","__ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer16FindLabeledLoopsE_1P5Shape","_rl_relooper_render","__ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEE18__construct_at_endINS_13move_iteratorIPS3_EEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeESD_SD_","__ZNSt3__114__split_bufferIPP5BlockNS_9allocatorIS3_EEE10push_frontERKS3_","__ZN12LabeledShapeD1Ev","_malloc","__ZNSt3__14pairIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEEED1Ev","__ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_","__ZZN8Relooper9CalculateEP5BlockEN8Analyzer8MakeLoopE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_SA_","__ZN8RelooperD1Ev","__ZNSt3__15stackIP5ShapeNS_5dequeIS2_NS_9allocatorIS2_EEEEED1Ev","__ZNSt3__14listIP5BlockNS_9allocatorIS2_EEE9push_backERKS2_","__ZNSt3__13mapIPviNS_4lessIS1_EENS_9allocatorINS_4pairIKS1_iEEEEED1Ev","__ZN5ShapeD1Ev","__ZN6BranchC2EPKcS1_","__ZNSt3__114__split_bufferIPP5ShapeRNS_9allocatorIS3_EEED2Ev","__ZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEE","__ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEE16__construct_nodeERS9_","__ZN5Shape6IsLoopEPS_","__ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEEixERSA_","__ZN8Relooper9CalculateEP5Block","__ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEE5beginEv","__ZZN8Relooper9CalculateEP5BlockEN13PostOptimizer19RemoveUnneededFlowsE_1P5ShapeS4_","__ZN11SimpleShapeC1Ev","__ZNSt3__111__tree_nextIPKNS_16__tree_node_baseIPvEEEET_S6_","__ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE13__lower_boundIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_SJ_SJ_","__ZN10ministring4sizeEv","__ZNSt3__13mapIP5BlockP5ShapeNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED1Ev","__ZNSt3__112__deque_baseIP5BlockNS_9allocatorIS2_EEE3endEv","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEEC1ERKS7_","__ZNSt3__13mapIP5BlockS2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEED1Ev","__ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassC2ESH_","__ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEE16__construct_nodeERSA_","__ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEEC2ERKSA_","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSB_SB_","__ZNSt3__15dequeIP5BlockNS_9allocatorIS2_EEE9push_backERKS2_","__ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEEC2ERKS7_","_rl_block_add_branch_to","__ZNK10__cxxabiv117__class_type_info29process_static_type_above_dstEPNS_19__dynamic_cast_infoEPKvS4_i","__ZNSt3__16__treeINS_4pairIP5BlockP5ShapeEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEED1Ev","__ZZN8Relooper9CalculateEP5BlockEN8Analyzer12MakeMultipleE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEP5ShapeSA_","__ZNSt3__15dequeIP5ShapeNS_9allocatorIS2_EEE8pop_backEv","__ZNSt3__110__list_impIP5BlockNS_9allocatorIS2_EEED2Ev","_internal_realloc","__ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEEC1ERKS7_","__ZNSt3__14listIP5BlockNS_9allocatorIS2_EEED2Ev","__ZN10ministring5c_strEv","__ZN9LoopShapeD0Ev","__ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE14__erase_uniqueIS3_EEjRKT_","__ZNSt3__118__tree_left_rotateIPNS_16__tree_node_baseIPvEEEEvT_","__ZNSt3__14listIP5BlockNS_9allocatorIS2_EEE9pop_frontEv","__ZN8Indenter8UnindentEv","__ZN8Indenter6IndentEv","_sys_alloc","__ZNSt3__110__list_impIP5BlockNS_9allocatorIS2_EEE5clearEv","__ZN11SimpleShapeD1Ev","__ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEEC1ERKS8_","_segment_holding","__ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEEC2ERKS8_","__ZN10ministringC2Ev","__ZNK10__cxxabiv116__shim_type_info5noop1Ev","__ZNSt3__13mapIP5BlockNS_3setIS2_NS_4lessIS2_EENS_9allocatorIS2_EEEES5_NS6_INS_4pairIKS2_S8_EEEEED2Ev","__ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE","__ZNSt9bad_allocD2Ev","__ZNSt3__16__treeINS_4pairIPviEENS_19__map_value_compareIS2_iNS_4lessIS2_EELb1EEENS_9allocatorIS3_EEED2Ev","__ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__erase_uniqueIS3_EEjRKT_","__ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSI_SI_","_add_segment","__ZNSt3__114__split_bufferIPP5BlockRNS_9allocatorIS3_EEE10push_frontERKS3_","__ZN10ministringC1Ev","__ZNSt3__114__split_bufferIPP5ShapeNS_9allocatorIS3_EEED2Ev","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE16__construct_nodeERKS2_","__ZN6BranchD1Ev","__ZN5ShapeC2ENS_9ShapeTypeE","__ZNSt3__16__treeIP5BlockNS_4lessIS2_EENS_9allocatorIS2_EEE5eraseENS_21__tree_const_iteratorIS2_PKNS_11__tree_nodeIS2_PvEEiEE","__ZNSt3__16__treeINS_4pairIP5BlockP6BranchEENS_19__map_value_compareIS3_S5_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEED1Ev","__ZN10__cxxabiv120__si_class_type_infoD0Ev","__ZZZN8Relooper9CalculateEP5BlockEN8Analyzer21FindIndependentGroupsE_0RNSt3__13setIS1_NS3_4lessIS1_EENS3_9allocatorIS1_EEEESA_RNS3_3mapIS1_S9_S6_NS7_INS3_4pairIKS1_S9_EEEEEEEN11HelperClassD2Ev","__ZNSt3__15stackIP5ShapeNS_5dequeIS2_NS_9allocatorIS2_EEEEED2Ev","__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEED1Ev","__ZNSt3__13mapIP5BlockP6BranchNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEE16__construct_nodeERS9_","_rl_delete_block","__ZNSt3__16__treeINS_4pairIP5BlockS3_EENS_19__map_value_compareIS3_S3_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE16__insert_node_atEPNS_16__tree_node_baseIPvEERSF_SF_","__ZNSt3__16__treeINS_4pairIP5BlockNS_3setIS3_NS_4lessIS3_EENS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S9_S6_Lb1EEENS7_ISA_EEEC2ERKSC_","__ZZN8Relooper9CalculateEP5BlockEN12PreOptimizer8FindLiveES1_","__ZN10ministringD1Ev"]



  var RBUFFER_SIZE = 20*1024*1024;
  var rbuffer = _malloc(RBUFFER_SIZE);
  _rl_set_output_buffer(rbuffer, RBUFFER_SIZE);

  var TBUFFER_SIZE = 10*1024*1024;
  var tbuffer = _malloc(TBUFFER_SIZE);

  var RelooperGlue = {};
  RelooperGlue['init'] = function() {
    this.r = _rl_new_relooper();
  },
  RelooperGlue['addBlock'] = function(text) {
    assert(this.r);
    assert(text.length+1 < TBUFFER_SIZE);
    writeStringToMemory(text, tbuffer);
    var b = _rl_new_block(tbuffer);
    _rl_relooper_add_block(this.r, b);
    return b;
  };
  RelooperGlue['addBranch'] = function(from, to, condition, code) {
    assert(this.r);
    if (condition) {
      assert(condition.length+1 < TBUFFER_SIZE/2);
      writeStringToMemory(condition, tbuffer);
      condition = tbuffer;
    } else {
      condition = 0; // allow undefined, null, etc. as inputs
    }
    if (code) {
      assert(code.length+1 < TBUFFER_SIZE/2);
      writeStringToMemory(code, tbuffer + TBUFFER_SIZE/2);
      code = tbuffer + TBUFFER_SIZE/2;
    } else {
      code = 0; // allow undefined, null, etc. as inputs
    }
    _rl_block_add_branch_to(from, to, condition, code);
  };
  RelooperGlue['render'] = function(entry) {
    assert(this.r);
    assert(entry);
    _rl_relooper_calculate(this.r, entry);
    _rl_relooper_render(this.r);
    var ret = Pointer_stringify(rbuffer);
    _rl_delete_relooper(this.r);
    this.r = 0;
    return ret;
  };
  RelooperGlue['setDebug'] = function(debug) {
    _rl_set_debugging(+!!debug);
  };
  RelooperGlue['setAsmJSMode'] = function(on) {
    _rl_set_asm_js_mode(on);
  };

  Module['Relooper'] = RelooperGlue;




  return Module.Relooper;
})();