text: var Module
  if (!Module) Module = (typeof Module !== 'undefined' ? Module : null) || {}
  var moduleOverrides = {}
  for (var key in Module) {
    if (Module.hasOwnProperty(key)) {
      moduleOverrides[key] = Module[key]
    }
  }
  var ENVIRONMENT_IS_WEB = false
  var ENVIRONMENT_IS_WORKER = false
  var ENVIRONMENT_IS_NODE = false
  var ENVIRONMENT_IS_SHELL = false
  if (Module['ENVIRONMENT']) {
    if (Module['ENVIRONMENT'] === 'WEB') {
      ENVIRONMENT_IS_WEB = true
    } else if (Module['ENVIRONMENT'] === 'WORKER') {
      ENVIRONMENT_IS_WORKER = true
    } else if (Module['ENVIRONMENT'] === 'NODE') {
      ENVIRONMENT_IS_NODE = true
    } else if (Module['ENVIRONMENT'] === 'SHELL') {
      ENVIRONMENT_IS_SHELL = true
    } else {
      throw new Error("The provided Module['ENVIRONMENT'] value is not valid. It must be one of: WEB|WORKER|NODE|SHELL.")
    }
  } else {
    ENVIRONMENT_IS_WEB = typeof window === 'object'
    ENVIRONMENT_IS_WORKER = typeof importScripts === 'function'
    ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function' && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER
    ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER
  }
  if (ENVIRONMENT_IS_NODE) {
    if (!Module['print']) Module['print'] = console.log
    if (!Module['printErr']) Module['printErr'] = console.warn
    var nodeFS
    var nodePath
    Module['read'] = function shell_read(filename, binary) {
      if (!nodeFS) nodeFS = require('fs')
      if (!nodePath) nodePath = require('path')
      filename = nodePath['normalize'](filename)
      var ret = nodeFS['readFileSync'](filename)
      return binary ? ret : ret.toString()
    }
    Module['readBinary'] = function readBinary(filename) {
      var ret = Module['read'](filename, true)
      if (!ret.buffer) {
        ret = new Uint8Array(ret)
      }
      assert(ret.buffer)
      return ret
    }
    Module['load'] = function load(f) {
      globalEval(read(f))
    }
    if (!Module['thisProgram']) {
      if (process['argv'].length > 1) {
        Module['thisProgram'] = process['argv'][1].replace(/\\/g, '/')
      } else {
        Module['thisProgram'] = 'unknown-program'
      }
    }
    Module['arguments'] = process['argv'].slice(2)
    if (typeof module !== 'undefined') {
      module['exports'] = Module
    }
    process['on']('uncaughtException', function(ex) {
      if (!(ex instanceof ExitStatus)) {
        throw ex
      }
    })
    Module['inspect'] = function() {
      return '[Emscripten Module object]'
    }
  } else if (ENVIRONMENT_IS_SHELL) {
    if (!Module['print']) Module['print'] = print
    if (typeof printErr !== 'undefined') Module['printErr'] = printErr
    if (typeof read !== 'undefined') {
      Module['read'] = read
    } else {
      Module['read'] = function shell_read() {
        throw 'no read() available'
      }
    }
    Module['readBinary'] = function readBinary(f) {
      if (typeof readbuffer === 'function') {
        return new Uint8Array(readbuffer(f))
      }
      var data = read(f, 'binary')
      assert(typeof data === 'object')
      return data
    }
    if (typeof scriptArgs !== 'undefined') {
      Module['arguments'] = scriptArgs
    } else if (typeof arguments !== 'undefined') {
      Module['arguments'] = arguments
    }
    if (typeof quit === 'function') {
      Module['quit'] = function(status, toThrow) {
        quit(status)
      }
    }
  } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
    Module['read'] = function shell_read(url) {
      var xhr = new XMLHttpRequest()
      xhr.open('GET', url, false)
      xhr.send(null)
      return xhr.responseText
    }
    if (ENVIRONMENT_IS_WORKER) {
      Module['readBinary'] = function readBinary(url) {
        var xhr = new XMLHttpRequest()
        xhr.open('GET', url, false)
        xhr.responseType = 'arraybuffer'
        xhr.send(null)
        return new Uint8Array(xhr.response)
      }
    }
    Module['readAsync'] = function readAsync(url, onload, onerror) {
      var xhr = new XMLHttpRequest()
      xhr.open('GET', url, true)
      xhr.responseType = 'arraybuffer'
      xhr.onload = function xhr_onload() {
        if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
          onload(xhr.response)
        } else {
          onerror()
        }
      }
      xhr.onerror = onerror
      xhr.send(null)
    }
    if (typeof arguments !== 'undefined') {
      Module['arguments'] = arguments
    }
    if (typeof console !== 'undefined') {
      if (!Module['print']) {
        Module['print'] = function shell_print(x) {
          console.log(x)
        }
      }
      if (!Module['printErr']) {
        Module['printErr'] = function shell_printErr(x) {
          console.warn(x)
        }
      }
    } else {
      var TRY_USE_DUMP = false
      if (!Module['print']) {
        Module['print'] = TRY_USE_DUMP && typeof dump !== 'undefined' ? function(x) {
          dump(x)
        } : function(x) {}
      }
    }
    if (ENVIRONMENT_IS_WORKER) {
      Module['load'] = importScripts
    }
    if (typeof Module['setWindowTitle'] === 'undefined') {
      Module['setWindowTitle'] = function(title) {
        document.title = title
      }
    }
  } else {
    throw 'Unknown runtime environment. Where are we?'
  }
  function globalEval(x) {
    eval.call(null, x)
  }
  if (!Module['load'] && Module['read']) {
    Module['load'] = function load(f) {
      globalEval(Module['read'](f))
    }
  }
  if (!Module['print']) {
    Module['print'] = function() {}
  }
  if (!Module['printErr']) {
    Module['printErr'] = Module['print']
  }
  if (!Module['arguments']) {
    Module['arguments'] = []
  }
  if (!Module['thisProgram']) {
    Module['thisProgram'] = './this.program'
  }
  if (!Module['quit']) {
    Module['quit'] = function(status, toThrow) {
      throw toThrow
    }
  }
  Module.print = Module['print']
  Module.printErr = Module['printErr']
  Module['preRun'] = []
  Module['postRun'] = []
  for (var key in moduleOverrides) {
    if (moduleOverrides.hasOwnProperty(key)) {
      Module[key] = moduleOverrides[key]
    }
  }
  moduleOverrides = undefined
  var Runtime = {
    setTempRet0: function(value) {
      tempRet0 = value
      return value
    },
    getTempRet0: function() {
      return tempRet0
    },
    stackSave: function() {
      return STACKTOP
    },
    stackRestore: function(stackTop) {
      STACKTOP = stackTop
    },
    getNativeTypeSize: function(type) {
      switch (type) {
        case 'i1':
        case 'i8':
          return 1
        case 'i16':
          return 2
        case 'i32':
          return 4
        case 'i64':
          return 8
        case 'float':
          return 4
        case 'double':
          return 8
        default:
        {
          if (type[type.length - 1] === '*') {
            return Runtime.QUANTUM_SIZE
          } else if (type[0] === 'i') {
            var bits = parseInt(type.substr(1))
            assert(bits % 8 === 0)
            return bits / 8
          } else {
            return 0
          }
        }
      }
    },
    getNativeFieldSize: function(type) {
      return Math.max(Runtime.getNativeTypeSize(type), Runtime.QUANTUM_SIZE)
    },
    STACK_ALIGN: 16,
    prepVararg: function(ptr, type) {
      if (type === 'double' || type === 'i64') {
        if (ptr & 7) {
          assert((ptr & 7) === 4)
          ptr += 4
        }
      } else {
        assert((ptr & 3) === 0)
      }
      return ptr
    },
    getAlignSize: function(type, size, vararg) {
      if (!vararg && (type == 'i64' || type == 'double')) return 8
      if (!type) return Math.min(size, 8)
      return Math.min(size || (type ? Runtime.getNativeFieldSize(type) : 0), Runtime.QUANTUM_SIZE)
    },
    dynCall: function(sig, ptr, args) {
      if (args && args.length) {
        return Module['dynCall_' + sig].apply(null, [ptr].concat(args))
      } else {
        return Module['dynCall_' + sig].call(null, ptr)
      }
    },
    functionPointers: [],
    addFunction: function(func) {
      for (var i = 0; i < Runtime.functionPointers.length; i++) {
        if (!Runtime.functionPointers[i]) {
          Runtime.functionPointers[i] = func
          return 2 * (1 + i)
        }
      }
      throw 'Finished up all reserved function pointers. Use a higher value for RESERVED_FUNCTION_POINTERS.'
    },
    removeFunction: function(index) {
      Runtime.functionPointers[(index - 2) / 2] = null
    },
    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) {
      if (!func) return
      assert(sig)
      if (!Runtime.funcWrappers[sig]) {
        Runtime.funcWrappers[sig] = {}
      }
      var sigCache = Runtime.funcWrappers[sig]
      if (!sigCache[func]) {
        if (sig.length === 1) {
          sigCache[func] = function dynCall_wrapper() {
            return Runtime.dynCall(sig, func)
          }
        } else if (sig.length === 2) {
          sigCache[func] = function dynCall_wrapper(arg) {
            return Runtime.dynCall(sig, func, [arg])
          }
        } else {
          sigCache[func] = function dynCall_wrapper() {
            return Runtime.dynCall(sig, func, Array.prototype.slice.call(arguments))
          }
        }
      }
      return sigCache[func]
    },
    getCompilerSetting: function(name) {
      throw 'You must build with -s RETAIN_COMPILER_SETTINGS=1 for Runtime.getCompilerSetting or emscripten_get_compiler_setting to work'
    },
    stackAlloc: function(size) {
      var ret = STACKTOP
      STACKTOP = STACKTOP + size | 0
      STACKTOP = STACKTOP + 15 & -16
      return ret
    },
    staticAlloc: function(size) {
      var ret = STATICTOP
      STATICTOP = STATICTOP + size | 0
      STATICTOP = STATICTOP + 15 & -16
      return ret
    },
    dynamicAlloc: function(size) {
      var ret = HEAP32[DYNAMICTOP_PTR >> 2]
      var end = (ret + size + 15 | 0) & -16
      HEAP32[DYNAMICTOP_PTR >> 2] = end
      if (end >= TOTAL_MEMORY) {
        var success = enlargeMemory()
        if (!success) {
          HEAP32[DYNAMICTOP_PTR >> 2] = ret
          return 0
        }
      }
      return ret
    },
    alignMemory: function(size, quantum) {
      var ret = size = Math.ceil(size / (quantum || 16)) * (quantum || 16)
      return ret
    },
    makeBigInt: function(low, high, unsigned) {
      var ret = unsigned ? +(low >>> 0) + +(high >>> 0) * 4294967296 : +(low >>> 0) + +(high | 0) * 4294967296
      return ret
    },
    GLOBAL_BASE: 1024,
    QUANTUM_SIZE: 4,
    __dummy__: 0
  }
  Module['Runtime'] = Runtime
  var ABORT = 0
  var EXITSTATUS = 0
  
  function assert(condition, text) {
    if (!condition) {
      abort('Assertion failed: ' + text)
    }
  }
  function getCFunc(ident) {
    var func = Module['_' + ident]
    if (!func) {
      try {
        func = eval('_' + ident)
      } catch (e) {}
    }
    assert(func, 'Cannot call unknown function ' + ident + ' (perhaps LLVM optimizations or closure removed it?)')
    return func
  }
  var cwrap, ccall;
  (function() {
    var JSfuncs = {
      'stackSave': function() {
        Runtime.stackSave()
      },
      'stackRestore': function() {
        Runtime.stackRestore()
      },
      'arrayToC': function(arr) {
        var ret = Runtime.stackAlloc(arr.length)
        writeArrayToMemory(arr, ret)
        return ret
      },
      'stringToC': function(str) {
        var ret = 0
        if (str !== null && str !== undefined && str !== 0) {
          var len = (str.length << 2) + 1
          ret = Runtime.stackAlloc(len)
          stringToUTF8(str, ret, len)
        }
        return ret
      }
    }
    var toC = {
      'string': JSfuncs['stringToC'],
      'array': JSfuncs['arrayToC']
    }
    ccall = function ccallFunc(ident, returnType, argTypes, args, opts) {
      var func = getCFunc(ident)
      var cArgs = []
      var stack = 0
      if (args) {
        for (var i = 0; i < args.length; i++) {
          var converter = toC[argTypes[i]]
          if (converter) {
            if (stack === 0) stack = Runtime.stackSave()
            cArgs[i] = converter(args[i])
          } else {
            cArgs[i] = args[i]
          }
        }
      }
      var ret = func.apply(null, cArgs)
      if (returnType === 'string') ret = Pointer_stringify(ret)
      if (stack !== 0) {
        if (opts && opts.async) {
          EmterpreterAsync.asyncFinalizers.push(function() {
            Runtime.stackRestore(stack)
          })
          return
        }
        Runtime.stackRestore(stack)
      }
      return ret
    }
    var sourceRegex = /^function\s*[a-zA-Z$_0-9]*\s*\(([^)]*)\)\s*{\s*([^*]*?)[\s;]*(?:return\s*(.*?)[;\s]*)?}$/
  
    function parseJSFunc(jsfunc) {
      var parsed = jsfunc.toString().match(sourceRegex).slice(1)
      return {
        arguments: parsed[0],
        body: parsed[1],
        returnValue: parsed[2]
      }
    }
    var JSsource = null
  
    function ensureJSsource() {
      if (!JSsource) {
        JSsource = {}
        for (var fun in JSfuncs) {
          if (JSfuncs.hasOwnProperty(fun)) {
            JSsource[fun] = parseJSFunc(JSfuncs[fun])
          }
        }
      }
    }
    cwrap = function cwrap(ident, returnType, argTypes) {
      argTypes = argTypes || []
      var cfunc = getCFunc(ident)
      var numericArgs = argTypes.every(function(type) {
        return type === 'number'
      })
      var numericRet = returnType !== 'string'
      if (numericRet && numericArgs) {
        return cfunc
      }
      var argNames = argTypes.map(function(x, i) {
        return '$' + i
      })
      var funcstr = '(function(' + argNames.join(',') + ') {'
      var nargs = argTypes.length
      if (!numericArgs) {
        ensureJSsource()
        funcstr += 'var stack = ' + JSsource['stackSave'].body + ';'
        for (var i = 0; i < nargs; i++) {
          var arg = argNames[i]
          var type = argTypes[i]
          if (type === 'number') continue
          var convertCode = JSsource[type + 'ToC']
          funcstr += 'var ' + convertCode.arguments + ' = ' + arg + ';'
          funcstr += convertCode.body + ';'
          funcstr += arg + '=(' + convertCode.returnValue + ');'
        }
      }
      var cfuncname = parseJSFunc(function() {
        return cfunc
      }).returnValue
      funcstr += 'var ret = ' + cfuncname + '(' + argNames.join(',') + ');'
      if (!numericRet) {
        var strgfy = parseJSFunc(function() {
          return Pointer_stringify
        }).returnValue
        funcstr += 'ret = ' + strgfy + '(ret);'
      }
      if (!numericArgs) {
        ensureJSsource()
        funcstr += JSsource['stackRestore'].body.replace('()', '(stack)') + ';'
      }
      funcstr += 'return ret})'
      return eval(funcstr)
    }
  })()
  Module['ccall'] = ccall
  Module['cwrap'] = cwrap
  
  function setValue(ptr, value, type, noSafe) {
    type = type || 'i8'
    if (type.charAt(type.length - 1) === '*') type = 'i32'
    switch (type) {
      case 'i1':
        HEAP8[ptr >> 0] = value
        break
      case 'i8':
        HEAP8[ptr >> 0] = value
        break
      case 'i16':
        HEAP16[ptr >> 1] = value
        break
      case 'i32':
        HEAP32[ptr >> 2] = value
        break
      case 'i64':
        tempI64 = [value >>> 0, (tempDouble = value, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[ptr >> 2] = tempI64[0], HEAP32[ptr + 4 >> 2] = tempI64[1]
        break
      case 'float':
        HEAPF32[ptr >> 2] = value
        break
      case 'double':
        HEAPF64[ptr >> 3] = value
        break
      default:
        abort('invalid type for setValue: ' + type)
    }
  }
  Module['setValue'] = setValue
  
  function getValue(ptr, type, noSafe) {
    type = type || 'i8'
    if (type.charAt(type.length - 1) === '*') type = 'i32'
    switch (type) {
      case 'i1':
        return HEAP8[ptr >> 0]
      case 'i8':
        return HEAP8[ptr >> 0]
      case 'i16':
        return HEAP16[ptr >> 1]
      case 'i32':
        return HEAP32[ptr >> 2]
      case 'i64':
        return HEAP32[ptr >> 2]
      case 'float':
        return HEAPF32[ptr >> 2]
      case 'double':
        return HEAPF64[ptr >> 3]
      default:
        abort('invalid type for setValue: ' + type)
    }
    return null
  }
  Module['getValue'] = getValue
  var ALLOC_NORMAL = 0
  var ALLOC_STACK = 1
  var ALLOC_STATIC = 2
  var ALLOC_DYNAMIC = 3
  var ALLOC_NONE = 4
  Module['ALLOC_NORMAL'] = ALLOC_NORMAL
  Module['ALLOC_STACK'] = ALLOC_STACK
  Module['ALLOC_STATIC'] = ALLOC_STATIC
  Module['ALLOC_DYNAMIC'] = ALLOC_DYNAMIC
  Module['ALLOC_NONE'] = ALLOC_NONE
  
  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 = [typeof _malloc === 'function' ? _malloc : Runtime.staticAlloc, Runtime.stackAlloc, Runtime.staticAlloc, Runtime.dynamicAlloc][allocator === undefined ? ALLOC_STATIC : allocator](Math.max(size, singleType ? 1 : types.length))
    }
    if (zeroinit) {
      var ptr = ret
      var stop
      assert((ret & 3) == 0)
      stop = ret + (size & ~3)
      for (; ptr < stop; ptr += 4) {
        HEAP32[ptr >> 2] = 0
      }
      stop = ret + size
      while (ptr < stop) {
        HEAP8[ptr++ >> 0] = 0
      }
      return ret
    }
    if (singleType === 'i8') {
      if (slab.subarray || slab.slice) {
        HEAPU8.set(slab, ret)
      } else {
        HEAPU8.set(new Uint8Array(slab), ret)
      }
      return ret
    }
    var i = 0
    var type; var typeSize; var previousType
    while (i < size) {
      var curr = slab[i]
      if (typeof curr === 'function') {
        curr = Runtime.getFunctionIndex(curr)
      }
      type = singleType || types[i]
      if (type === 0) {
        i++
        continue
      }
      if (type == 'i64') type = 'i32'
      setValue(ret + i, curr, type)
      if (previousType !== type) {
        typeSize = Runtime.getNativeTypeSize(type)
        previousType = type
      }
      i += typeSize
    }
    return ret
  }
  Module['allocate'] = allocate
  
  function getMemory(size) {
    if (!staticSealed) return Runtime.staticAlloc(size)
    if (!runtimeInitialized) return Runtime.dynamicAlloc(size)
    return _malloc(size)
  }
  Module['getMemory'] = getMemory
  
  function Pointer_stringify(ptr, length) {
    if (length === 0 || !ptr) return ''
    var hasUtf = 0
    var t
    var i = 0
    while (1) {
      t = HEAPU8[ptr + i >> 0]
      hasUtf |= t
      if (t == 0 && !length) break
      i++
      if (length && i == length) break
    }
    if (!length) length = i
    var ret = ''
    if (hasUtf < 128) {
      var MAX_CHUNK = 1024
      var curr
      while (length > 0) {
        curr = String.fromCharCode.apply(String, HEAPU8.subarray(ptr, ptr + Math.min(length, MAX_CHUNK)))
        ret = ret ? ret + curr : curr
        ptr += MAX_CHUNK
        length -= MAX_CHUNK
      }
      return ret
    }
    return Module['UTF8ToString'](ptr)
  }
  Module['Pointer_stringify'] = Pointer_stringify
  
  function AsciiToString(ptr) {
    var str = ''
    while (1) {
      var ch = HEAP8[ptr++ >> 0]
      if (!ch) return str
      str += String.fromCharCode(ch)
    }
  }
  Module['AsciiToString'] = AsciiToString
  
  function stringToAscii(str, outPtr) {
    return writeAsciiToMemory(str, outPtr, false)
  }
  Module['stringToAscii'] = stringToAscii
  var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined
  
  function UTF8ArrayToString(u8Array, idx) {
    var endPtr = idx
    while (u8Array[endPtr])++endPtr
    if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
      return UTF8Decoder.decode(u8Array.subarray(idx, endPtr))
    } else {
      var u0, u1, u2, u3, u4, u5
      var str = ''
      while (1) {
        u0 = u8Array[idx++]
        if (!u0) return str
        if (!(u0 & 128)) {
          str += String.fromCharCode(u0)
          continue
        }
        u1 = u8Array[idx++] & 63
        if ((u0 & 224) == 192) {
          str += String.fromCharCode((u0 & 31) << 6 | u1)
          continue
        }
        u2 = u8Array[idx++] & 63
        if ((u0 & 240) == 224) {
          u0 = (u0 & 15) << 12 | u1 << 6 | u2
        } else {
          u3 = u8Array[idx++] & 63
          if ((u0 & 248) == 240) {
            u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u3
          } else {
            u4 = u8Array[idx++] & 63
            if ((u0 & 252) == 248) {
              u0 = (u0 & 3) << 24 | u1 << 18 | u2 << 12 | u3 << 6 | u4
            } else {
              u5 = u8Array[idx++] & 63
              u0 = (u0 & 1) << 30 | u1 << 24 | u2 << 18 | u3 << 12 | u4 << 6 | u5
            }
          }
        }
        if (u0 < 65536) {
          str += String.fromCharCode(u0)
        } else {
          var ch = u0 - 65536
          str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023)
        }
      }
    }
  }
  Module['UTF8ArrayToString'] = UTF8ArrayToString
  
  function UTF8ToString(ptr) {
    return UTF8ArrayToString(HEAPU8, ptr)
  }
  Module['UTF8ToString'] = UTF8ToString
  
  function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
    if (!(maxBytesToWrite > 0)) return 0
    var startIdx = outIdx
    var endIdx = outIdx + maxBytesToWrite - 1
    for (var i = 0; i < str.length; ++i) {
      var u = str.charCodeAt(i)
      if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023
      if (u <= 127) {
        if (outIdx >= endIdx) break
        outU8Array[outIdx++] = u
      } else if (u <= 2047) {
        if (outIdx + 1 >= endIdx) break
        outU8Array[outIdx++] = 192 | u >> 6
        outU8Array[outIdx++] = 128 | u & 63
      } else if (u <= 65535) {
        if (outIdx + 2 >= endIdx) break
        outU8Array[outIdx++] = 224 | u >> 12
        outU8Array[outIdx++] = 128 | u >> 6 & 63
        outU8Array[outIdx++] = 128 | u & 63
      } else if (u <= 2097151) {
        if (outIdx + 3 >= endIdx) break
        outU8Array[outIdx++] = 240 | u >> 18
        outU8Array[outIdx++] = 128 | u >> 12 & 63
        outU8Array[outIdx++] = 128 | u >> 6 & 63
        outU8Array[outIdx++] = 128 | u & 63
      } else if (u <= 67108863) {
        if (outIdx + 4 >= endIdx) break
        outU8Array[outIdx++] = 248 | u >> 24
        outU8Array[outIdx++] = 128 | u >> 18 & 63
        outU8Array[outIdx++] = 128 | u >> 12 & 63
        outU8Array[outIdx++] = 128 | u >> 6 & 63
        outU8Array[outIdx++] = 128 | u & 63
      } else {
        if (outIdx + 5 >= endIdx) break
        outU8Array[outIdx++] = 252 | u >> 30
        outU8Array[outIdx++] = 128 | u >> 24 & 63
        outU8Array[outIdx++] = 128 | u >> 18 & 63
        outU8Array[outIdx++] = 128 | u >> 12 & 63
        outU8Array[outIdx++] = 128 | u >> 6 & 63
        outU8Array[outIdx++] = 128 | u & 63
      }
    }
    outU8Array[outIdx] = 0
    return outIdx - startIdx
  }
  Module['stringToUTF8Array'] = stringToUTF8Array
  
  function stringToUTF8(str, outPtr, maxBytesToWrite) {
    return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite)
  }
  Module['stringToUTF8'] = stringToUTF8
  
  function lengthBytesUTF8(str) {
    var len = 0
    for (var i = 0; i < str.length; ++i) {
      var u = str.charCodeAt(i)
      if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023
      if (u <= 127) {
        ++len
      } else if (u <= 2047) {
        len += 2
      } else if (u <= 65535) {
        len += 3
      } else if (u <= 2097151) {
        len += 4
      } else if (u <= 67108863) {
        len += 5
      } else {
        len += 6
      }
    }
    return len
  }
  Module['lengthBytesUTF8'] = lengthBytesUTF8
  var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined
  
  function demangle(func) {
    var __cxa_demangle_func = Module['___cxa_demangle'] || Module['__cxa_demangle']
    if (__cxa_demangle_func) {
      try {
        var s = func.substr(1)
        var len = lengthBytesUTF8(s) + 1
        var buf = _malloc(len)
        stringToUTF8(s, buf, len)
        var status = _malloc(4)
        var ret = __cxa_demangle_func(buf, 0, 0, status)
        if (getValue(status, 'i32') === 0 && ret) {
          return Pointer_stringify(ret)
        }
      } catch (e) {} finally {
        if (buf) _free(buf)
        if (status) _free(status)
        if (ret) _free(ret)
      }
      return func
    }
    Runtime.warnOnce('warning: build with  -s DEMANGLE_SUPPORT=1  to link in libcxxabi demangling')
    return func
  }
  function demangleAll(text) {
    var regex = /__Z[\w\d_]+/g
    return text.replace(regex, function(x) {
      var y = demangle(x)
      return x === y ? x : x + ' [' + y + ']'
    })
  }
  function jsStackTrace() {
    var err = new Error()
    if (!err.stack) {
      try {
        throw new Error(0)
      } catch (e) {
        err = e
      }
      if (!err.stack) {
        return '(no stack trace available)'
      }
    }
    return err.stack.toString()
  }
  function stackTrace() {
    var js = jsStackTrace()
    if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace']()
    return demangleAll(js)
  }
  Module['stackTrace'] = stackTrace
  var WASM_PAGE_SIZE = 65536
  var ASMJS_PAGE_SIZE = 16777216
  
  function alignUp(x, multiple) {
    if (x % multiple > 0) {
      x += multiple - x % multiple
    }
    return x
  }
  var HEAP, buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64
  
  function updateGlobalBuffer(buf) {
    Module['buffer'] = buffer = buf
  }
  function updateGlobalBufferViews() {
    Module['HEAP8'] = HEAP8 = new Int8Array(buffer)
    Module['HEAP16'] = HEAP16 = new Int16Array(buffer)
    Module['HEAP32'] = HEAP32 = new Int32Array(buffer)
    Module['HEAPU8'] = HEAPU8 = new Uint8Array(buffer)
    Module['HEAPU16'] = HEAPU16 = new Uint16Array(buffer)
    Module['HEAPU32'] = HEAPU32 = new Uint32Array(buffer)
    Module['HEAPF32'] = HEAPF32 = new Float32Array(buffer)
    Module['HEAPF64'] = HEAPF64 = new Float64Array(buffer)
  }
  var STATIC_BASE, STATICTOP, staticSealed
  var STACK_BASE, STACKTOP, STACK_MAX
  var DYNAMIC_BASE, DYNAMICTOP_PTR
  STATIC_BASE = STATICTOP = STACK_BASE = STACKTOP = STACK_MAX = DYNAMIC_BASE = DYNAMICTOP_PTR = 0
  staticSealed = false
  
  function abortOnCannotGrowMemory() {
    abort('Cannot enlarge memory arrays. Either (1) compile with  -s TOTAL_MEMORY=X  with X higher than the current value ' + TOTAL_MEMORY + ', (2) compile with  -s ALLOW_MEMORY_GROWTH=1  which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with  -s ABORTING_MALLOC=0 ')
  }
  function enlargeMemory() {
    abortOnCannotGrowMemory()
  }
  var TOTAL_STACK = Module['TOTAL_STACK'] || 5242880
  var TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 134217728
  if (TOTAL_MEMORY < TOTAL_STACK) Module.printErr('TOTAL_MEMORY should be larger than TOTAL_STACK, was ' + TOTAL_MEMORY + '! (TOTAL_STACK=' + TOTAL_STACK + ')')
  if (Module['buffer']) {
    buffer = Module['buffer']
  } else {
    if (typeof WebAssembly === 'object' && typeof WebAssembly.Memory === 'function') {
      Module['wasmMemory'] = new WebAssembly.Memory({
        'initial': TOTAL_MEMORY / WASM_PAGE_SIZE,
        'maximum': TOTAL_MEMORY / WASM_PAGE_SIZE
      })
      buffer = Module['wasmMemory'].buffer
    } else {
      buffer = new ArrayBuffer(TOTAL_MEMORY)
    }
  }
  updateGlobalBufferViews()
  
  function getTotalMemory() {
    return TOTAL_MEMORY
  }
  HEAP32[0] = 1668509029
  HEAP16[1] = 25459
  if (HEAPU8[2] !== 115 || HEAPU8[3] !== 99) throw 'Runtime error: expected the system to be little-endian!'
  Module['HEAP'] = HEAP
  Module['buffer'] = buffer
  Module['HEAP8'] = HEAP8
  Module['HEAP16'] = HEAP16
  Module['HEAP32'] = HEAP32
  Module['HEAPU8'] = HEAPU8
  Module['HEAPU16'] = HEAPU16
  Module['HEAPU32'] = HEAPU32
  Module['HEAPF32'] = HEAPF32
  Module['HEAPF64'] = HEAPF64
  
  function callRuntimeCallbacks(callbacks) {
    while (callbacks.length > 0) {
      var callback = callbacks.shift()
      if (typeof callback === 'function') {
        callback()
        continue
      }
      var func = callback.func
      if (typeof func === 'number') {
        if (callback.arg === undefined) {
          Module['dynCall_v'](func)
        } else {
          Module['dynCall_vi'](func, callback.arg)
        }
      } else {
        func(callback.arg === undefined ? null : callback.arg)
      }
    }
  }
  var __ATPRERUN__ = []
  var __ATINIT__ = []
  var __ATMAIN__ = []
  var __ATEXIT__ = []
  var __ATPOSTRUN__ = []
  var runtimeInitialized = false
  var runtimeExited = false
  
  function preRun() {
    if (Module['preRun']) {
      if (typeof Module['preRun'] === 'function') Module['preRun'] = [Module['preRun']]
      while (Module['preRun'].length) {
        addOnPreRun(Module['preRun'].shift())
      }
    }
    callRuntimeCallbacks(__ATPRERUN__)
  }
  function ensureInitRuntime() {
    if (runtimeInitialized) return
    runtimeInitialized = true
    callRuntimeCallbacks(__ATINIT__)
  }
  function preMain() {
    callRuntimeCallbacks(__ATMAIN__)
  }
  function exitRuntime() {
    callRuntimeCallbacks(__ATEXIT__)
    runtimeExited = true
  }
  function postRun() {
    if (Module['postRun']) {
      if (typeof Module['postRun'] === 'function') Module['postRun'] = [Module['postRun']]
      while (Module['postRun'].length) {
        addOnPostRun(Module['postRun'].shift())
      }
    }
    callRuntimeCallbacks(__ATPOSTRUN__)
  }
  function addOnPreRun(cb) {
    __ATPRERUN__.unshift(cb)
  }
  Module['addOnPreRun'] = addOnPreRun
  
  function addOnInit(cb) {
    __ATINIT__.unshift(cb)
  }
  Module['addOnInit'] = addOnInit
  
  function addOnPreMain(cb) {
    __ATMAIN__.unshift(cb)
  }
  Module['addOnPreMain'] = addOnPreMain
  
  function addOnExit(cb) {
    __ATEXIT__.unshift(cb)
  }
  Module['addOnExit'] = addOnExit
  
  function addOnPostRun(cb) {
    __ATPOSTRUN__.unshift(cb)
  }
  Module['addOnPostRun'] = addOnPostRun
  
  function intArrayFromString(stringy, dontAddNull, length) {
    var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1
    var u8array = new Array(len)
    var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length)
    if (dontAddNull) u8array.length = numBytesWritten
    return u8array
  }
  Module['intArrayFromString'] = intArrayFromString
  
  function intArrayToString(array) {
    var ret = []
    for (var i = 0; i < array.length; i++) {
      var chr = array[i]
      if (chr > 255) {
        chr &= 255
      }
      ret.push(String.fromCharCode(chr))
    }
    return ret.join('')
  }
  Module['intArrayToString'] = intArrayToString
  
  function writeStringToMemory(string, buffer, dontAddNull) {
    Runtime.warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!')
    var lastChar, end
    if (dontAddNull) {
      end = buffer + lengthBytesUTF8(string)
      lastChar = HEAP8[end]
    }
    stringToUTF8(string, buffer, Infinity)
    if (dontAddNull) HEAP8[end] = lastChar
  }
  Module['writeStringToMemory'] = writeStringToMemory
  
  function writeArrayToMemory(array, buffer) {
    HEAP8.set(array, buffer)
  }
  Module['writeArrayToMemory'] = writeArrayToMemory
  
  function writeAsciiToMemory(str, buffer, dontAddNull) {
    for (var i = 0; i < str.length; ++i) {
      HEAP8[buffer++ >> 0] = str.charCodeAt(i)
    }
    if (!dontAddNull) HEAP8[buffer >> 0] = 0
  }
  Module['writeAsciiToMemory'] = writeAsciiToMemory
  if (!Math['imul'] || Math['imul'](4294967295, 5) !== -5) {
    Math['imul'] = function imul(a, b) {
      var ah = a >>> 16
      var al = a & 65535
      var bh = b >>> 16
      var bl = b & 65535
      return al * bl + (ah * bl + al * bh << 16) | 0
    }
  }
  Math.imul = Math['imul']
  if (!Math['fround']) {
    var froundBuffer = new Float32Array(1)
    Math['fround'] = function(x) {
      froundBuffer[0] = x
      return froundBuffer[0]
    }
  }
  Math.fround = Math['fround']
  if (!Math['clz32']) {
    Math['clz32'] = function(x) {
      x = x >>> 0
      for (var i = 0; i < 32; i++) {
        if (x & 1 << 31 - i) return i
      }
      return 32
    }
  }
  Math.clz32 = Math['clz32']
  if (!Math['trunc']) {
    Math['trunc'] = function(x) {
      return x < 0 ? Math.ceil(x) : Math.floor(x)
    }
  }
  Math.trunc = Math['trunc']
  var Math_abs = Math.abs
  var Math_cos = Math.cos
  var Math_sin = Math.sin
  var Math_tan = Math.tan
  var Math_acos = Math.acos
  var Math_asin = Math.asin
  var Math_atan = Math.atan
  var Math_atan2 = Math.atan2
  var Math_exp = Math.exp
  var Math_log = Math.log
  var Math_sqrt = Math.sqrt
  var Math_ceil = Math.ceil
  var Math_floor = Math.floor
  var Math_pow = Math.pow
  var Math_imul = Math.imul
  var Math_fround = Math.fround
  var Math_round = Math.round
  var Math_min = Math.min
  var Math_clz32 = Math.clz32
  var Math_trunc = Math.trunc
  var runDependencies = 0
  var runDependencyWatcher = null
  var dependenciesFulfilled = null
  
  function addRunDependency(id) {
    runDependencies++
    if (Module['monitorRunDependencies']) {
      Module['monitorRunDependencies'](runDependencies)
    }
  }
  Module['addRunDependency'] = addRunDependency
  
  function removeRunDependency(id) {
    runDependencies--
    if (Module['monitorRunDependencies']) {
      Module['monitorRunDependencies'](runDependencies)
    }
    if (runDependencies == 0) {
      if (runDependencyWatcher !== null) {
        clearInterval(runDependencyWatcher)
        runDependencyWatcher = null
      }
      if (dependenciesFulfilled) {
        var callback = dependenciesFulfilled
        dependenciesFulfilled = null
        callback()
      }
    }
  }
  Module['removeRunDependency'] = removeRunDependency
  Module['preloadedImages'] = {}
  Module['preloadedAudios'] = {}
  var memoryInitializer = null
  
  function integrateWasmJS() {
    var method = Module['wasmJSMethod'] || 'native-wasm'
    Module['wasmJSMethod'] = method
    var wasmTextFile = Module['wasmTextFile'] || 'Decoder.wast'
    var wasmBinaryFile = Module['wasmBinaryFile'] || 'Decoder.wasm'
    var asmjsCodeFile = Module['asmjsCodeFile'] || 'Decoder.temp.asm.js'
    if (typeof Module['locateFile'] === 'function') {
      wasmTextFile = Module['locateFile'](wasmTextFile)
      wasmBinaryFile = Module['locateFile'](wasmBinaryFile)
      asmjsCodeFile = Module['locateFile'](asmjsCodeFile)
    }
    var wasmPageSize = 64 * 1024
    var asm2wasmImports = {
      'f64-rem': function(x, y) {
        return x % y
      },
      'f64-to-int': function(x) {
        return x | 0
      },
      'i32s-div': function(x, y) {
        return (x | 0) / (y | 0) | 0
      },
      'i32u-div': function(x, y) {
        return (x >>> 0) / (y >>> 0) >>> 0
      },
      'i32s-rem': function(x, y) {
        return (x | 0) % (y | 0) | 0
      },
      'i32u-rem': function(x, y) {
        return (x >>> 0) % (y >>> 0) >>> 0
      },
      'debugger': function() {
        debugger
      }
    }
    var info = {
      'global': null,
      'env': null,
      'asm2wasm': asm2wasmImports,
      'parent': Module
    }
    var exports = null
  
    function lookupImport(mod, base) {
      var lookup = info
      if (mod.indexOf('.') < 0) {
        lookup = (lookup || {})[mod]
      } else {
        var parts = mod.split('.')
        lookup = (lookup || {})[parts[0]]
        lookup = (lookup || {})[parts[1]]
      }
      if (base) {
        lookup = (lookup || {})[base]
      }
      if (lookup === undefined) {
        abort('bad lookupImport to (' + mod + ').' + base)
      }
      return lookup
    }
    function mergeMemory(newBuffer) {
      var oldBuffer = Module['buffer']
      if (newBuffer.byteLength < oldBuffer.byteLength) {
        Module['printErr']('the new buffer in mergeMemory is smaller than the previous one. in native wasm, we should grow memory here')
      }
      var oldView = new Int8Array(oldBuffer)
      var newView = new Int8Array(newBuffer)
      if (!memoryInitializer) {
        oldView.set(newView.subarray(Module['STATIC_BASE'], Module['STATIC_BASE'] + Module['STATIC_BUMP']), Module['STATIC_BASE'])
      }
      newView.set(oldView)
      updateGlobalBuffer(newBuffer)
      updateGlobalBufferViews()
    }
    var WasmTypes = {
      none: 0,
      i32: 1,
      i64: 2,
      f32: 3,
      f64: 4
    }
  
    function fixImports(imports) {
      if (!0) return imports
      var ret = {}
      for (var i in imports) {
        var fixed = i
        if (fixed[0] == '_') fixed = fixed.substr(1)
        ret[fixed] = imports[i]
      }
      return ret
    }
    function getBinary() {
      try {
        var binary
        if (Module['wasmBinary']) {
          binary = Module['wasmBinary']
          binary = new Uint8Array(binary)
        } else if (Module['readBinary']) {
          binary = Module['readBinary'](wasmBinaryFile)
        } else {
          throw "on the web, we need the wasm binary to be preloaded and set on Module['wasmBinary']. emcc.py will do that for you when generating HTML (but not JS)"
        }
        return binary
      } catch (err) {
        abort(err)
      }
    }
    function getBinaryPromise() {
      if (!Module['wasmBinary'] && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === 'function') {
        return fetch(wasmBinaryFile, {
          credentials: 'same-origin'
        }).then(function(response) {
          if (!response['ok']) {
            throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"
          }
          return response['arrayBuffer']()
        })
      }
      return new Promise(function(resolve, reject) {
        resolve(getBinary())
      })
    }
    function doNativeWasm(global, env, providedBuffer) {
      if (typeof WebAssembly !== 'object') {
        Module['printErr']('no native wasm support detected')
        return false
      }
      if (!(Module['wasmMemory'] instanceof WebAssembly.Memory)) {
        Module['printErr']('no native wasm Memory in use')
        return false
      }
      env['memory'] = Module['wasmMemory']
      info['global'] = {
        'NaN': NaN,
        'Infinity': Infinity
      }
      info['global.Math'] = global.Math
      info['env'] = env
  
      function receiveInstance(instance) {
        exports = instance.exports
        if (exports.memory) mergeMemory(exports.memory)
        Module['asm'] = exports
        Module['usingWasm'] = true
        removeRunDependency('wasm-instantiate')
      }
      addRunDependency('wasm-instantiate')
      if (Module['instantiateWasm']) {
        try {
          return Module['instantiateWasm'](info, receiveInstance)
        } catch (e) {
          Module['printErr']('Module.instantiateWasm callback failed with error: ' + e)
          return false
        }
      }
      function receiveInstantiatedSource(output) {
        receiveInstance(output['instance'])
      }
      function instantiateArrayBuffer(receiver) {
        getBinaryPromise().then(function(binary) {
          return WebAssembly.instantiate(binary, info)
        }).then(receiver)
          .catch(function(reason) {
            Module['printErr']('failed to asynchronously prepare wasm: ' + reason)
            abort(reason)
          })
      }
      if (!Module['wasmBinary'] && typeof WebAssembly.instantiateStreaming === 'function') {
        WebAssembly.instantiateStreaming(fetch(wasmBinaryFile, {
          credentials: 'same-origin'
        }), info).then(receiveInstantiatedSource)
          .catch(function(reason) {
            Module['printErr']('wasm streaming compile failed: ' + reason)
            Module['printErr']('falling back to ArrayBuffer instantiation')
            instantiateArrayBuffer(receiveInstantiatedSource)
          })
      } else {
        instantiateArrayBuffer(receiveInstantiatedSource)
      }
      return {}
    }
    Module['asmPreload'] = Module['asm']
    var asmjsReallocBuffer = Module['reallocBuffer']
    var wasmReallocBuffer = function(size) {
      var PAGE_MULTIPLE = Module['usingWasm'] ? WASM_PAGE_SIZE : ASMJS_PAGE_SIZE
      size = alignUp(size, PAGE_MULTIPLE)
      var old = Module['buffer']
      var oldSize = old.byteLength
      if (Module['usingWasm']) {
        try {
          var result = Module['wasmMemory'].grow((size - oldSize) / wasmPageSize)
          if (result !== (-1 | 0)) {
            return Module['buffer'] = Module['wasmMemory'].buffer
          } else {
            return null
          }
        } catch (e) {
          return null
        }
      } else {
        exports['__growWasmMemory']((size - oldSize) / wasmPageSize)
        return Module['buffer'] !== old ? Module['buffer'] : null
      }
    }
    Module['reallocBuffer'] = function(size) {
      if (finalMethod === 'asmjs') {
        return asmjsReallocBuffer(size)
      } else {
        return wasmReallocBuffer(size)
      }
    }
    var finalMethod = ''
    Module['asm'] = function(global, env, providedBuffer) {
      global = fixImports(global)
      env = fixImports(env)
      if (!env['table']) {
        var TABLE_SIZE = Module['wasmTableSize']
        if (TABLE_SIZE === undefined) TABLE_SIZE = 1024
        var MAX_TABLE_SIZE = Module['wasmMaxTableSize']
        if (typeof WebAssembly === 'object' && typeof WebAssembly.Table === 'function') {
          if (MAX_TABLE_SIZE !== undefined) {
            env['table'] = new WebAssembly.Table({
              'initial': TABLE_SIZE,
              'maximum': MAX_TABLE_SIZE,
              'element': 'anyfunc'
            })
          } else {
            env['table'] = new WebAssembly.Table({
              'initial': TABLE_SIZE,
              element: 'anyfunc'
            })
          }
        } else {
          env['table'] = new Array(TABLE_SIZE)
        }
        Module['wasmTable'] = env['table']
      }
      if (!env['memoryBase']) {
        env['memoryBase'] = Module['STATIC_BASE']
      }
      if (!env['tableBase']) {
        env['tableBase'] = 0
      }
      var exports
      exports = doNativeWasm(global, env, providedBuffer)
      if (!exports) abort('no binaryen method succeeded. consider enabling more options, like interpreting, if you want that: https://github.com/kripken/emscripten/wiki/WebAssembly#binaryen-methods')
      return exports
    }
    var methodHandler = Module['asm']
  }
  integrateWasmJS()
  var ASM_CONSTS = []
  STATIC_BASE = Runtime.GLOBAL_BASE
  STATICTOP = STATIC_BASE + 163120
  __ATINIT__.push({
    func: function() {
      __GLOBAL__sub_I_Decoder_cpp()
    }
  }, {
    func: function() {
      __GLOBAL__sub_I_bind_cpp()
    }
  })
  memoryInitializer = Module['wasmJSMethod'].indexOf('asmjs') >= 0 || Module['wasmJSMethod'].indexOf('interpret-asm2wasm') >= 0 ? 'Decoder.js.mem' : null
  var STATIC_BUMP = 163120
  Module['STATIC_BASE'] = STATIC_BASE
  Module['STATIC_BUMP'] = STATIC_BUMP
  var tempDoublePtr = STATICTOP
  STATICTOP += 16
  var structRegistrations = {}
  
  function embind_init_charCodes() {
    var codes = new Array(256)
    for (var i = 0; i < 256; ++i) {
      codes[i] = String.fromCharCode(i)
    }
    embind_charCodes = codes
  }
  var embind_charCodes = undefined
  
  function readLatin1String(ptr) {
    var ret = ''
    var c = ptr
    while (HEAPU8[c]) {
      ret += embind_charCodes[HEAPU8[c++]]
    }
    return ret
  }
  var char_0 = 48
  var char_9 = 57
  
  function makeLegalFunctionName(name) {
    if (undefined === name) {
      return '_unknown'
    }
    name = name.replace(/[^a-zA-Z0-9_]/g, '$')
    var f = name.charCodeAt(0)
    if (f >= char_0 && f <= char_9) {
      return '_' + name
    } else {
      return name
    }
  }
  function createNamedFunction(name, body) {
    name = makeLegalFunctionName(name)
    return (new Function('body', 'return function ' + name + '() {\n' + '    "use strict";' + '    return body.apply(this, arguments);\n' + '};\n'))(body)
  }
  function extendError(baseErrorType, errorName) {
    var errorClass = createNamedFunction(errorName, function(message) {
      this.name = errorName
      this.message = message
      var stack = (new Error(message)).stack
      if (stack !== undefined) {
        this.stack = this.toString() + '\n' + stack.replace(/^Error(:[^\n]*)?\n/, '')
      }
    })
    errorClass.prototype = Object.create(baseErrorType.prototype)
    errorClass.prototype.constructor = errorClass
    errorClass.prototype.toString = function() {
      if (this.message === undefined) {
        return this.name
      } else {
        return this.name + ': ' + this.message
      }
    }
    return errorClass
  }
  var BindingError = undefined
  
  function throwBindingError(message) {
    throw new BindingError(message)
  }
  function requireFunction(signature, rawFunction) {
    signature = readLatin1String(signature)
  
    function makeDynCaller(dynCall) {
      var args = []
      for (var i = 1; i < signature.length; ++i) {
        args.push('a' + i)
      }
      var name = 'dynCall_' + signature + '_' + rawFunction
      var body = 'return function ' + name + '(' + args.join(', ') + ') {\n'
      body += '    return dynCall(rawFunction' + (args.length ? ', ' : '') + args.join(', ') + ');\n'
      body += '};\n'
      return (new Function('dynCall', 'rawFunction', body))(dynCall, rawFunction)
    }
    var fp
    if (Module['FUNCTION_TABLE_' + signature] !== undefined) {
      fp = Module['FUNCTION_TABLE_' + signature][rawFunction]
    } else if (typeof FUNCTION_TABLE !== 'undefined') {
      fp = FUNCTION_TABLE[rawFunction]
    } else {
      var dc = Module['asm']['dynCall_' + signature]
      if (dc === undefined) {
        dc = Module['asm']['dynCall_' + signature.replace(/f/g, 'd')]
        if (dc === undefined) {
          throwBindingError('No dynCall invoker for signature: ' + signature)
        }
      }
      fp = makeDynCaller(dc)
    }
    if (typeof fp !== 'function') {
      throwBindingError('unknown function pointer with signature ' + signature + ': ' + rawFunction)
    }
    return fp
  }
  function __embind_register_value_object(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) {
    structRegistrations[rawType] = {
      name: readLatin1String(name),
      rawConstructor: requireFunction(constructorSignature, rawConstructor),
      rawDestructor: requireFunction(destructorSignature, rawDestructor),
      fields: []
    }
  }
  function ___assert_fail(condition, filename, line, func) {
    ABORT = true
    throw 'Assertion failed: ' + Pointer_stringify(condition) + ', at: ' + [filename ? Pointer_stringify(filename) : 'unknown filename', line, func ? Pointer_stringify(func) : 'unknown function'] + ' at ' + stackTrace()
  }
  var awaitingDependencies = {}
  var registeredTypes = {}
  var typeDependencies = {}
  var InternalError = undefined
  
  function throwInternalError(message) {
    throw new InternalError(message)
  }
  function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {
    myTypes.forEach(function(type) {
      typeDependencies[type] = dependentTypes
    })
  
    function onComplete(typeConverters) {
      var myTypeConverters = getTypeConverters(typeConverters)
      if (myTypeConverters.length !== myTypes.length) {
        throwInternalError('Mismatched type converter count')
      }
      for (var i = 0; i < myTypes.length; ++i) {
        registerType(myTypes[i], myTypeConverters[i])
      }
    }
    var typeConverters = new Array(dependentTypes.length)
    var unregisteredTypes = []
    var registered = 0
    dependentTypes.forEach(function(dt, i) {
      if (registeredTypes.hasOwnProperty(dt)) {
        typeConverters[i] = registeredTypes[dt]
      } else {
        unregisteredTypes.push(dt)
        if (!awaitingDependencies.hasOwnProperty(dt)) {
          awaitingDependencies[dt] = []
        }
        awaitingDependencies[dt].push(function() {
          typeConverters[i] = registeredTypes[dt]
          ++registered
          if (registered === unregisteredTypes.length) {
            onComplete(typeConverters)
          }
        })
      }
    })
    if (unregisteredTypes.length === 0) {
      onComplete(typeConverters)
    }
  }
  function registerType(rawType, registeredInstance, options) {
    options = options || {}
    if (!('argPackAdvance' in registeredInstance)) {
      throw new TypeError('registerType registeredInstance requires argPackAdvance')
    }
    var name = registeredInstance.name
    if (!rawType) {
      throwBindingError('type "' + name + '" must have a positive integer typeid pointer')
    }
    if (registeredTypes.hasOwnProperty(rawType)) {
      if (options.ignoreDuplicateRegistrations) {
        return
      } else {
        throwBindingError("Cannot register type '" + name + "' twice")
      }
    }
    registeredTypes[rawType] = registeredInstance
    delete typeDependencies[rawType]
    if (awaitingDependencies.hasOwnProperty(rawType)) {
      var callbacks = awaitingDependencies[rawType]
      delete awaitingDependencies[rawType]
      callbacks.forEach(function(cb) {
        cb()
      })
    }
  }
  function __embind_register_void(rawType, name) {
    name = readLatin1String(name)
    registerType(rawType, {
      isVoid: true,
      name: name,
      'argPackAdvance': 0,
      'fromWireType': function() {
        return undefined
      },
      'toWireType': function(destructors, o) {
        return undefined
      }
    })
  }
  function _pthread_mutex_destroy() {}
  function __ZSt18uncaught_exceptionv() {
    return !!__ZSt18uncaught_exceptionv.uncaught_exception
  }
  var EXCEPTIONS = {
    last: 0,
    caught: [],
    infos: {},
    deAdjust: function(adjusted) {
      if (!adjusted || EXCEPTIONS.infos[adjusted]) return adjusted
      for (var ptr in EXCEPTIONS.infos) {
        var info = EXCEPTIONS.infos[ptr]
        if (info.adjusted === adjusted) {
          return ptr
        }
      }
      return adjusted
    },
    addRef: function(ptr) {
      if (!ptr) return
      var info = EXCEPTIONS.infos[ptr]
      info.refcount++
    },
    decRef: function(ptr) {
      if (!ptr) return
      var info = EXCEPTIONS.infos[ptr]
      assert(info.refcount > 0)
      info.refcount--
      if (info.refcount === 0 && !info.rethrown) {
        if (info.destructor) {
          Module['dynCall_vi'](info.destructor, ptr)
        }
        delete EXCEPTIONS.infos[ptr]
        ___cxa_free_exception(ptr)
      }
    },
    clearRef: function(ptr) {
      if (!ptr) return
      var info = EXCEPTIONS.infos[ptr]
      info.refcount = 0
    }
  }
  
  function ___resumeException(ptr) {
    if (!EXCEPTIONS.last) {
      EXCEPTIONS.last = ptr
    }
    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 ___cxa_find_matching_catch() {
    var thrown = EXCEPTIONS.last
    if (!thrown) {
      return (Runtime.setTempRet0(0), 0) | 0
    }
    var info = EXCEPTIONS.infos[thrown]
    var throwntype = info.type
    if (!throwntype) {
      return (Runtime.setTempRet0(0), thrown) | 0
    }
    var typeArray = Array.prototype.slice.call(arguments)
    var pointer = Module['___cxa_is_pointer_type'](throwntype)
    if (!___cxa_find_matching_catch.buffer) ___cxa_find_matching_catch.buffer = _malloc(4)
    HEAP32[___cxa_find_matching_catch.buffer >> 2] = thrown
    thrown = ___cxa_find_matching_catch.buffer
    for (var i = 0; i < typeArray.length; i++) {
      if (typeArray[i] && Module['___cxa_can_catch'](typeArray[i], throwntype, thrown)) {
        thrown = HEAP32[thrown >> 2]
        info.adjusted = thrown
        return (Runtime.setTempRet0(typeArray[i]), thrown) | 0
      }
    }
    thrown = HEAP32[thrown >> 2]
    return (Runtime.setTempRet0(throwntype), thrown) | 0
  }
  function ___cxa_throw(ptr, type, destructor) {
    EXCEPTIONS.infos[ptr] = {
      ptr: ptr,
      adjusted: ptr,
      type: type,
      destructor: destructor,
      refcount: 0,
      caught: false,
      rethrown: false
    }
    EXCEPTIONS.last = ptr
    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 getShiftFromSize(size) {
    switch (size) {
      case 1:
        return 0
      case 2:
        return 1
      case 4:
        return 2
      case 8:
        return 3
      default:
        throw new TypeError('Unknown type size: ' + size)
    }
  }
  function __embind_register_bool(rawType, name, size, trueValue, falseValue) {
    var shift = getShiftFromSize(size)
    name = readLatin1String(name)
    registerType(rawType, {
      name: name,
      'fromWireType': function(wt) {
        return !!wt
      },
      'toWireType': function(destructors, o) {
        return o ? trueValue : falseValue
      },
      'argPackAdvance': 8,
      'readValueFromPointer': function(pointer) {
        var heap
        if (size === 1) {
          heap = HEAP8
        } else if (size === 2) {
          heap = HEAP16
        } else if (size === 4) {
          heap = HEAP32
        } else {
          throw new TypeError('Unknown boolean type size: ' + name)
        }
        return this['fromWireType'](heap[pointer >> shift])
      },
      destructorFunction: null
    })
  }
  function ___gxx_personality_v0() {}
  function _pthread_cond_signal() {
    return 0
  }
  function _abort() {
    Module['abort']()
  }
  function _pthread_cond_destroy() {
    return 0
  }
  function simpleReadValueFromPointer(pointer) {
    return this['fromWireType'](HEAPU32[pointer >> 2])
  }
  function __embind_register_std_string(rawType, name) {
    name = readLatin1String(name)
    registerType(rawType, {
      name: name,
      'fromWireType': function(value) {
        var length = HEAPU32[value >> 2]
        var a = new Array(length)
        for (var i = 0; i < length; ++i) {
          a[i] = String.fromCharCode(HEAPU8[value + 4 + i])
        }
        _free(value)
        return a.join('')
      },
      'toWireType': function(destructors, value) {
        if (value instanceof ArrayBuffer) {
          value = new Uint8Array(value)
        }
        function getTAElement(ta, index) {
          return ta[index]
        }
        function getStringElement(string, index) {
          return string.charCodeAt(index)
        }
        var getElement
        if (value instanceof Uint8Array) {
          getElement = getTAElement
        } else if (value instanceof Uint8ClampedArray) {
          getElement = getTAElement
        } else if (value instanceof Int8Array) {
          getElement = getTAElement
        } else if (typeof value === 'string') {
          getElement = getStringElement
        } else {
          throwBindingError('Cannot pass non-string to std::string')
        }
        var length = value.length
        var ptr = _malloc(4 + length)
        HEAPU32[ptr >> 2] = length
        for (var i = 0; i < length; ++i) {
          var charCode = getElement(value, i)
          if (charCode > 255) {
            _free(ptr)
            throwBindingError('String has UTF-16 code units that do not fit in 8 bits')
          }
          HEAPU8[ptr + 4 + i] = charCode
        }
        if (destructors !== null) {
          destructors.push(_free, ptr)
        }
        return ptr
      },
      'argPackAdvance': 8,
      'readValueFromPointer': simpleReadValueFromPointer,
      destructorFunction: function(ptr) {
        _free(ptr)
      }
    })
  }
  function _embind_repr(v) {
    if (v === null) {
      return 'null'
    }
    var t = typeof v
    if (t === 'object' || t === 'array' || t === 'function') {
      return v.toString()
    } else {
      return '' + v
    }
  }
  function integerReadValueFromPointer(name, shift, signed) {
    switch (shift) {
      case 0:
        return signed
          ? function readS8FromPointer(pointer) {
            return HEAP8[pointer]
          } : function readU8FromPointer(pointer) {
            return HEAPU8[pointer]
          }
      case 1:
        return signed
          ? function readS16FromPointer(pointer) {
            return HEAP16[pointer >> 1]
          } : function readU16FromPointer(pointer) {
            return HEAPU16[pointer >> 1]
          }
      case 2:
        return signed
          ? function readS32FromPointer(pointer) {
            return HEAP32[pointer >> 2]
          } : function readU32FromPointer(pointer) {
            return HEAPU32[pointer >> 2]
          }
      default:
        throw new TypeError('Unknown integer type: ' + name)
    }
  }
  function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
    name = readLatin1String(name)
    if (maxRange === -1) {
      maxRange = 4294967295
    }
    var shift = getShiftFromSize(size)
    var fromWireType = function(value) {
      return value
    }
    if (minRange === 0) {
      var bitshift = 32 - 8 * size
      fromWireType = function(value) {
        return value << bitshift >>> bitshift
      }
    }
    var isUnsignedType = name.indexOf('unsigned') != -1
    registerType(primitiveType, {
      name: name,
      'fromWireType': fromWireType,
      'toWireType': function(destructors, value) {
        if (typeof value !== 'number' && typeof value !== 'boolean') {
          throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name)
        }
        if (value < minRange || value > maxRange) {
          throw new TypeError('Passing a number "' + _embind_repr(value) + '" from JS side to C/C++ side to an argument of type "' + name + '", which is outside the valid range [' + minRange + ', ' + maxRange + ']!')
        }
        return isUnsignedType ? value >>> 0 : value | 0
      },
      'argPackAdvance': 8,
      'readValueFromPointer': integerReadValueFromPointer(name, shift, minRange !== 0),
      destructorFunction: null
    })
  }
  function _pthread_once(ptr, func) {
    if (!_pthread_once.seen) _pthread_once.seen = {}
    if (ptr in _pthread_once.seen) return
    Module['dynCall_v'](func)
    _pthread_once.seen[ptr] = 1
  }
  function _pthread_create() {
    return 11
  }
  function __embind_register_value_object_field(structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
    structRegistrations[structType].fields.push({
      fieldName: readLatin1String(fieldName),
      getterReturnType: getterReturnType,
      getter: requireFunction(getterSignature, getter),
      getterContext: getterContext,
      setterArgumentType: setterArgumentType,
      setter: requireFunction(setterSignature, setter),
      setterContext: setterContext
    })
  }
  function ___lock() {}
  function ___unlock() {}
  var PTHREAD_SPECIFIC = {}
  
  function _pthread_getspecific(key) {
    return PTHREAD_SPECIFIC[key] || 0
  }
  function runDestructors(destructors) {
    while (destructors.length) {
      var ptr = destructors.pop()
      var del = destructors.pop()
      del(ptr)
    }
  }
  function __embind_finalize_value_object(structType) {
    var reg = structRegistrations[structType]
    delete structRegistrations[structType]
    var rawConstructor = reg.rawConstructor
    var rawDestructor = reg.rawDestructor
    var fieldRecords = reg.fields
    var fieldTypes = fieldRecords.map(function(field) {
      return field.getterReturnType
    }).concat(fieldRecords.map(function(field) {
      return field.setterArgumentType
    }))
    whenDependentTypesAreResolved([structType], fieldTypes, function(fieldTypes) {
      var fields = {}
      fieldRecords.forEach(function(field, i) {
        var fieldName = field.fieldName
        var getterReturnType = fieldTypes[i]
        var getter = field.getter
        var getterContext = field.getterContext
        var setterArgumentType = fieldTypes[i + fieldRecords.length]
        var setter = field.setter
        var setterContext = field.setterContext
        fields[fieldName] = {
          read: function(ptr) {
            return getterReturnType['fromWireType'](getter(getterContext, ptr))
          },
          write: function(ptr, o) {
            var destructors = []
            setter(setterContext, ptr, setterArgumentType['toWireType'](destructors, o))
            runDestructors(destructors)
          }
        }
      })
      return [{
        name: reg.name,
        'fromWireType': function(ptr) {
          var rv = {}
          for (var i in fields) {
            rv[i] = fields[i].read(ptr)
          }
          rawDestructor(ptr)
          return rv
        },
        'toWireType': function(destructors, o) {
          for (var fieldName in fields) {
            if (!(fieldName in o)) {
              throw new TypeError('Missing field')
            }
          }
          var ptr = rawConstructor()
          for (fieldName in fields) {
            fields[fieldName].write(ptr, o[fieldName])
          }
          if (destructors !== null) {
            destructors.push(rawDestructor, ptr)
          }
          return ptr
        },
        'argPackAdvance': 8,
        'readValueFromPointer': simpleReadValueFromPointer,
        destructorFunction: rawDestructor
      }]
    })
  }
  function _clock() {
    if (_clock.start === undefined) _clock.start = Date.now()
    return (Date.now() - _clock.start) * (1e6 / 1e3) | 0
  }
  var PTHREAD_SPECIFIC_NEXT_KEY = 1
  var ERRNO_CODES = {
    EPERM: 1,
    ENOENT: 2,
    ESRCH: 3,
    EINTR: 4,
    EIO: 5,
    ENXIO: 6,
    E2BIG: 7,
    ENOEXEC: 8,
    EBADF: 9,
    ECHILD: 10,
    EAGAIN: 11,
    EWOULDBLOCK: 11,
    ENOMEM: 12,
    EACCES: 13,
    EFAULT: 14,
    ENOTBLK: 15,
    EBUSY: 16,
    EEXIST: 17,
    EXDEV: 18,
    ENODEV: 19,
    ENOTDIR: 20,
    EISDIR: 21,
    EINVAL: 22,
    ENFILE: 23,
    EMFILE: 24,
    ENOTTY: 25,
    ETXTBSY: 26,
    EFBIG: 27,
    ENOSPC: 28,
    ESPIPE: 29,
    EROFS: 30,
    EMLINK: 31,
    EPIPE: 32,
    EDOM: 33,
    ERANGE: 34,
    ENOMSG: 42,
    EIDRM: 43,
    ECHRNG: 44,
    EL2NSYNC: 45,
    EL3HLT: 46,
    EL3RST: 47,
    ELNRNG: 48,
    EUNATCH: 49,
    ENOCSI: 50,
    EL2HLT: 51,
    EDEADLK: 35,
    ENOLCK: 37,
    EBADE: 52,
    EBADR: 53,
    EXFULL: 54,
    ENOANO: 55,
    EBADRQC: 56,
    EBADSLT: 57,
    EDEADLOCK: 35,
    EBFONT: 59,
    ENOSTR: 60,
    ENODATA: 61,
    ETIME: 62,
    ENOSR: 63,
    ENONET: 64,
    ENOPKG: 65,
    EREMOTE: 66,
    ENOLINK: 67,
    EADV: 68,
    ESRMNT: 69,
    ECOMM: 70,
    EPROTO: 71,
    EMULTIHOP: 72,
    EDOTDOT: 73,
    EBADMSG: 74,
    ENOTUNIQ: 76,
    EBADFD: 77,
    EREMCHG: 78,
    ELIBACC: 79,
    ELIBBAD: 80,
    ELIBSCN: 81,
    ELIBMAX: 82,
    ELIBEXEC: 83,
    ENOSYS: 38,
    ENOTEMPTY: 39,
    ENAMETOOLONG: 36,
    ELOOP: 40,
    EOPNOTSUPP: 95,
    EPFNOSUPPORT: 96,
    ECONNRESET: 104,
    ENOBUFS: 105,
    EAFNOSUPPORT: 97,
    EPROTOTYPE: 91,
    ENOTSOCK: 88,
    ENOPROTOOPT: 92,
    ESHUTDOWN: 108,
    ECONNREFUSED: 111,
    EADDRINUSE: 98,
    ECONNABORTED: 103,
    ENETUNREACH: 101,
    ENETDOWN: 100,
    ETIMEDOUT: 110,
    EHOSTDOWN: 112,
    EHOSTUNREACH: 113,
    EINPROGRESS: 115,
    EALREADY: 114,
    EDESTADDRREQ: 89,
    EMSGSIZE: 90,
    EPROTONOSUPPORT: 93,
    ESOCKTNOSUPPORT: 94,
    EADDRNOTAVAIL: 99,
    ENETRESET: 102,
    EISCONN: 106,
    ENOTCONN: 107,
    ETOOMANYREFS: 109,
    EUSERS: 87,
    EDQUOT: 122,
    ESTALE: 116,
    ENOTSUP: 95,
    ENOMEDIUM: 123,
    EILSEQ: 84,
    EOVERFLOW: 75,
    ECANCELED: 125,
    ENOTRECOVERABLE: 131,
    EOWNERDEAD: 130,
    ESTRPIPE: 86
  }
  
  function _pthread_key_create(key, destructor) {
    if (key == 0) {
      return ERRNO_CODES.EINVAL
    }
    HEAP32[key >> 2] = PTHREAD_SPECIFIC_NEXT_KEY
    PTHREAD_SPECIFIC[PTHREAD_SPECIFIC_NEXT_KEY] = 0
    PTHREAD_SPECIFIC_NEXT_KEY++
    return 0
  }
  function _pthread_mutex_init() {}
  var emval_free_list = []
  var emval_handle_array = [{}, {
    value: undefined
  }, {
    value: null
  }, {
    value: true
  }, {
    value: false
  }]
  
  function __emval_decref(handle) {
    if (handle > 4 && --emval_handle_array[handle].refcount === 0) {
      emval_handle_array[handle] = undefined
      emval_free_list.push(handle)
    }
  }
  function count_emval_handles() {
    var count = 0
    for (var i = 5; i < emval_handle_array.length; ++i) {
      if (emval_handle_array[i] !== undefined) {
        ++count
      }
    }
    return count
  }
  function get_first_emval() {
    for (var i = 5; i < emval_handle_array.length; ++i) {
      if (emval_handle_array[i] !== undefined) {
        return emval_handle_array[i]
      }
    }
    return null
  }
  function init_emval() {
    Module['count_emval_handles'] = count_emval_handles
    Module['get_first_emval'] = get_first_emval
  }
  function __emval_register(value) {
    switch (value) {
      case undefined:
      {
        return 1
      }
      case null:
      {
        return 2
      }
      case true:
      {
        return 3
      }
      case false:
      {
        return 4
      }
      default:
      {
        var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length
        emval_handle_array[handle] = {
          refcount: 1,
          value: value
        }
        return handle
      }
    }
  }
  function __embind_register_emval(rawType, name) {
    name = readLatin1String(name)
    registerType(rawType, {
      name: name,
      'fromWireType': function(handle) {
        var rv = emval_handle_array[handle].value
        __emval_decref(handle)
        return rv
      },
      'toWireType': function(destructors, value) {
        return __emval_register(value)
      },
      'argPackAdvance': 8,
      'readValueFromPointer': simpleReadValueFromPointer,
      destructorFunction: null
    })
  }
  function _pthread_setspecific(key, value) {
    if (!(key in PTHREAD_SPECIFIC)) {
      return ERRNO_CODES.EINVAL
    }
    PTHREAD_SPECIFIC[key] = value
    return 0
  }
  function ___cxa_allocate_exception(size) {
    return _malloc(size)
  }
  var SYSCALLS = {
    varargs: 0,
    get: function(varargs) {
      SYSCALLS.varargs += 4
      var ret = HEAP32[SYSCALLS.varargs - 4 >> 2]
      return ret
    },
    getStr: function() {
      var ret = Pointer_stringify(SYSCALLS.get())
      return ret
    },
    get64: function() {
      var low = SYSCALLS.get()
      var high = SYSCALLS.get()
      if (low >= 0) assert(high === 0)
      else assert(high === -1)
      return low
    },
    getZero: function() {
      assert(SYSCALLS.get() === 0)
    }
  }
  
  function ___syscall54(which, varargs) {
    SYSCALLS.varargs = varargs
    try {
      return 0
    } catch (e) {
      if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e)
      return -e.errno
    }
  }
  function ___cxa_pure_virtual() {
    ABORT = true
    throw 'Pure virtual function called!'
  }
  function floatReadValueFromPointer(name, shift) {
    switch (shift) {
      case 2:
        return function(pointer) {
          return this['fromWireType'](HEAPF32[pointer >> 2])
        }
      case 3:
        return function(pointer) {
          return this['fromWireType'](HEAPF64[pointer >> 3])
        }
      default:
        throw new TypeError('Unknown float type: ' + name)
    }
  }
  function __embind_register_float(rawType, name, size) {
    var shift = getShiftFromSize(size)
    name = readLatin1String(name)
    registerType(rawType, {
      name: name,
      'fromWireType': function(value) {
        return value
      },
      'toWireType': function(destructors, value) {
        if (typeof value !== 'number' && typeof value !== 'boolean') {
          throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name)
        }
        return value
      },
      'argPackAdvance': 8,
      'readValueFromPointer': floatReadValueFromPointer(name, shift),
      destructorFunction: null
    })
  }
  function new_(constructor, argumentList) {
    if (!(constructor instanceof Function)) {
      throw new TypeError('new_ called with constructor type ' + typeof constructor + ' which is not a function')
    }
    var dummy = createNamedFunction(constructor.name || 'unknownFunctionName', function() {})
    dummy.prototype = constructor.prototype
    var obj = new dummy()
    var r = constructor.apply(obj, argumentList)
    return r instanceof Object ? r : obj
  }
  function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) {
    var argCount = argTypes.length
    if (argCount < 2) {
      throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!")
    }
    var isClassMethodFunc = argTypes[1] !== null && classType !== null
    var needsDestructorStack = false
    for (var i = 1; i < argTypes.length; ++i) {
      if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
        needsDestructorStack = true
        break
      }
    }
    var returns = argTypes[0].name !== 'void'
    var argsList = ''
    var argsListWired = ''
    for (var i = 0; i < argCount - 2; ++i) {
      argsList += (i !== 0 ? ', ' : '') + 'arg' + i
      argsListWired += (i !== 0 ? ', ' : '') + 'arg' + i + 'Wired'
    }
    var invokerFnBody = 'return function ' + makeLegalFunctionName(humanName) + '(' + argsList + ') {\n' + 'if (arguments.length !== ' + (argCount - 2) + ') {\n' + "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" + '}\n'
    if (needsDestructorStack) {
      invokerFnBody += 'var destructors = [];\n'
    }
    var dtorStack = needsDestructorStack ? 'destructors' : 'null'
    var args1 = ['throwBindingError', 'invoker', 'fn', 'runDestructors', 'retType', 'classParam']
    var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]]
    if (isClassMethodFunc) {
      invokerFnBody += 'var thisWired = classParam.toWireType(' + dtorStack + ', this);\n'
    }
    for (var i = 0; i < argCount - 2; ++i) {
      invokerFnBody += 'var arg' + i + 'Wired = argType' + i + '.toWireType(' + dtorStack + ', arg' + i + '); // ' + argTypes[i + 2].name + '\n'
      args1.push('argType' + i)
      args2.push(argTypes[i + 2])
    }
    if (isClassMethodFunc) {
      argsListWired = 'thisWired' + (argsListWired.length > 0 ? ', ' : '') + argsListWired
    }
    invokerFnBody += (returns ? 'var rv = ' : '') + 'invoker(fn' + (argsListWired.length > 0 ? ', ' : '') + argsListWired + ');\n'
    if (needsDestructorStack) {
      invokerFnBody += 'runDestructors(destructors);\n'
    } else {
      for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
        var paramName = i === 1 ? 'thisWired' : 'arg' + (i - 2) + 'Wired'
        if (argTypes[i].destructorFunction !== null) {
          invokerFnBody += paramName + '_dtor(' + paramName + '); // ' + argTypes[i].name + '\n'
          args1.push(paramName + '_dtor')
          args2.push(argTypes[i].destructorFunction)
        }
      }
    }
    if (returns) {
      invokerFnBody += 'var ret = retType.fromWireType(rv);\n' + 'return ret;\n'
    } else {}
    invokerFnBody += '}\n'
    args1.push(invokerFnBody)
    var invokerFunction = new_(Function, args1).apply(null, args2)
    return invokerFunction
  }
  function ensureOverloadTable(proto, methodName, humanName) {
    if (undefined === proto[methodName].overloadTable) {
      var prevFunc = proto[methodName]
      proto[methodName] = function() {
        if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
          throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ') - expects one of (' + proto[methodName].overloadTable + ')!')
        }
        return proto[methodName].overloadTable[arguments.length].apply(this, arguments)
      }
      proto[methodName].overloadTable = []
      proto[methodName].overloadTable[prevFunc.argCount] = prevFunc
    }
  }
  function exposePublicSymbol(name, value, numArguments) {
    if (Module.hasOwnProperty(name)) {
      if (undefined === numArguments || undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments]) {
        throwBindingError("Cannot register public name '" + name + "' twice")
      }
      ensureOverloadTable(Module, name, name)
      if (Module.hasOwnProperty(numArguments)) {
        throwBindingError('Cannot register multiple overloads of a function with the same number of arguments (' + numArguments + ')!')
      }
      Module[name].overloadTable[numArguments] = value
    } else {
      Module[name] = value
      if (undefined !== numArguments) {
        Module[name].numArguments = numArguments
      }
    }
  }
  function heap32VectorToArray(count, firstElement) {
    var array = []
    for (var i = 0; i < count; i++) {
      array.push(HEAP32[(firstElement >> 2) + i])
    }
    return array
  }
  function replacePublicSymbol(name, value, numArguments) {
    if (!Module.hasOwnProperty(name)) {
      throwInternalError('Replacing nonexistant public symbol')
    }
    if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
      Module[name].overloadTable[numArguments] = value
    } else {
      Module[name] = value
      Module[name].argCount = numArguments
    }
  }
  var UnboundTypeError = undefined
  
  function getTypeName(type) {
    var ptr = ___getTypeName(type)
    var rv = readLatin1String(ptr)
    _free(ptr)
    return rv
  }
  function throwUnboundTypeError(message, types) {
    var unboundTypes = []
    var seen = {}
  
    function visit(type) {
      if (seen[type]) {
        return
      }
      if (registeredTypes[type]) {
        return
      }
      if (typeDependencies[type]) {
        typeDependencies[type].forEach(visit)
        return
      }
      unboundTypes.push(type)
      seen[type] = true
    }
    types.forEach(visit)
    throw new UnboundTypeError(message + ': ' + unboundTypes.map(getTypeName).join([', ']))
  }
  function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn) {
    var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr)
    name = readLatin1String(name)
    rawInvoker = requireFunction(signature, rawInvoker)
    exposePublicSymbol(name, function() {
      throwUnboundTypeError('Cannot call ' + name + ' due to unbound types', argTypes)
    }, argCount - 1)
    whenDependentTypesAreResolved([], argTypes, function(argTypes) {
      var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1))
      replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn), argCount - 1)
      return []
    })
  }
  function _pthread_join() {}
  function _pthread_cond_init() {
    return 0
  }
  function ___syscall6(which, varargs) {
    SYSCALLS.varargs = varargs
    try {
      var stream = SYSCALLS.getStreamFromFD()
      FS.close(stream)
      return 0
    } catch (e) {
      if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e)
      return -e.errno
    }
  }
  function ___setErrNo(value) {
    if (Module['___errno_location']) HEAP32[Module['___errno_location']() >> 2] = value
    return value
  }
  function _emscripten_memcpy_big(dest, src, num) {
    HEAPU8.set(HEAPU8.subarray(src, src + num), dest)
    return dest
  }
  function __embind_register_std_wstring(rawType, charSize, name) {
    name = readLatin1String(name)
    var getHeap, shift
    if (charSize === 2) {
      getHeap = function() {
        return HEAPU16
      }
      shift = 1
    } else if (charSize === 4) {
      getHeap = function() {
        return HEAPU32
      }
      shift = 2
    }
    registerType(rawType, {
      name: name,
      'fromWireType': function(value) {
        var HEAP = getHeap()
        var length = HEAPU32[value >> 2]
        var a = new Array(length)
        var start = value + 4 >> shift
        for (var i = 0; i < length; ++i) {
          a[i] = String.fromCharCode(HEAP[start + i])
        }
        _free(value)
        return a.join('')
      },
      'toWireType': function(destructors, value) {
        var HEAP = getHeap()
        var length = value.length
        var ptr = _malloc(4 + length * charSize)
        HEAPU32[ptr >> 2] = length
        var start = ptr + 4 >> shift
        for (var i = 0; i < length; ++i) {
          HEAP[start + i] = value.charCodeAt(i)
        }
        if (destructors !== null) {
          destructors.push(_free, ptr)
        }
        return ptr
      },
      'argPackAdvance': 8,
      'readValueFromPointer': simpleReadValueFromPointer,
      destructorFunction: function(ptr) {
        _free(ptr)
      }
    })
  }
  function ___cxa_begin_catch(ptr) {
    var info = EXCEPTIONS.infos[ptr]
    if (info && !info.caught) {
      info.caught = true
      __ZSt18uncaught_exceptionv.uncaught_exception--
    }
    if (info) info.rethrown = false
    EXCEPTIONS.caught.push(ptr)
    EXCEPTIONS.addRef(EXCEPTIONS.deAdjust(ptr))
    return ptr
  }
  function _gettimeofday(ptr) {
    var now = Date.now()
    HEAP32[ptr >> 2] = now / 1e3 | 0
    HEAP32[ptr + 4 >> 2] = now % 1e3 * 1e3 | 0
    return 0
  }
  function _pthread_cond_wait() {
    return 0
  }
  function __embind_register_memory_view(rawType, dataTypeIndex, name) {
    var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array]
    var TA = typeMapping[dataTypeIndex]
  
    function decodeMemoryView(handle) {
      handle = handle >> 2
      var heap = HEAPU32
      var size = heap[handle]
      var data = heap[handle + 1]
      return new TA(heap['buffer'], data, size)
    }
    name = readLatin1String(name)
    registerType(rawType, {
      name: name,
      'fromWireType': decodeMemoryView,
      'argPackAdvance': 8,
      'readValueFromPointer': decodeMemoryView
    }, {
      ignoreDuplicateRegistrations: true
    })
  }
  function ___syscall140(which, varargs) {
    SYSCALLS.varargs = varargs
    try {
      var stream = SYSCALLS.getStreamFromFD()
      var offset_high = SYSCALLS.get()
      var offset_low = SYSCALLS.get()
      var result = SYSCALLS.get()
      var whence = SYSCALLS.get()
      var offset = offset_low
      FS.llseek(stream, offset, whence)
      HEAP32[result >> 2] = stream.position
      if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null
      return 0
    } catch (e) {
      if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e)
      return -e.errno
    }
  }
  function ___syscall146(which, varargs) {
    SYSCALLS.varargs = varargs
    try {
      var stream = SYSCALLS.get()
      var iov = SYSCALLS.get()
      var iovcnt = SYSCALLS.get()
      var ret = 0
      if (!___syscall146.buffer) {
        ___syscall146.buffers = [null, [],
          []
        ]
        ___syscall146.printChar = function(stream, curr) {
          var buffer = ___syscall146.buffers[stream]
          assert(buffer)
          if (curr === 0 || curr === 10) {
            (stream === 1 ? Module['print'] : Module['printErr'])(UTF8ArrayToString(buffer, 0))
            buffer.length = 0
          } else {
            buffer.push(curr)
          }
        }
      }
      for (var i = 0; i < iovcnt; i++) {
        var ptr = HEAP32[iov + i * 8 >> 2]
        var len = HEAP32[iov + (i * 8 + 4) >> 2]
        for (var j = 0; j < len; j++) {
          ___syscall146.printChar(stream, HEAPU8[ptr + j])
        }
        ret += len
      }
      return ret
    } catch (e) {
      if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e)
      return -e.errno
    }
  }
  embind_init_charCodes()
  BindingError = Module['BindingError'] = extendError(Error, 'BindingError')
  InternalError = Module['InternalError'] = extendError(Error, 'InternalError')
  init_emval()
  UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError')
  __ATEXIT__.push(function() {
    var fflush = Module['_fflush']
    if (fflush) fflush(0)
    var printChar = ___syscall146.printChar
    if (!printChar) return
    var buffers = ___syscall146.buffers
    if (buffers[1].length) printChar(1, 10)
    if (buffers[2].length) printChar(2, 10)
  })
  DYNAMICTOP_PTR = allocate(1, 'i32', ALLOC_STATIC)
  STACK_BASE = STACKTOP = Runtime.alignMemory(STATICTOP)
  STACK_MAX = STACK_BASE + TOTAL_STACK
  DYNAMIC_BASE = Runtime.alignMemory(STACK_MAX)
  HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE
  staticSealed = true
  Module['wasmTableSize'] = 494
  Module['wasmMaxTableSize'] = 494
  
  function invoke_iiiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
    try {
      return Module['dynCall_iiiiiiii'](index, a1, a2, a3, a4, a5, a6, a7)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_viiiii(index, a1, a2, a3, a4, a5) {
    try {
      Module['dynCall_viiiii'](index, a1, a2, a3, a4, a5)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_vi(index, a1) {
    try {
      Module['dynCall_vi'](index, a1)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_vii(index, a1, a2) {
    try {
      Module['dynCall_vii'](index, a1, a2)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
    try {
      return Module['dynCall_iiiiiii'](index, a1, a2, a3, a4, a5, a6)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_ii(index, a1) {
    try {
      return Module['dynCall_ii'](index, a1)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_viiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) {
    try {
      Module['dynCall_viiiiiiiiiii'](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
    try {
      return Module['dynCall_iiiiii'](index, a1, a2, a3, a4, a5)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_iiii(index, a1, a2, a3) {
    try {
      return Module['dynCall_iiii'](index, a1, a2, a3)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_viiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
    try {
      Module['dynCall_viiiiiiii'](index, a1, a2, a3, a4, a5, a6, a7, a8)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
    try {
      Module['dynCall_viiiiii'](index, a1, a2, a3, a4, a5, a6)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_viiiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) {
    try {
      Module['dynCall_viiiiiiiiiiiii'](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_viiiiiii(index, a1, a2, a3, a4, a5, a6, a7) {
    try {
      Module['dynCall_viiiiiii'](index, a1, a2, a3, a4, a5, a6, a7)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
    try {
      Module['dynCall_viiiiiiiii'](index, a1, a2, a3, a4, a5, a6, a7, a8, a9)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_viiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
    try {
      Module['dynCall_viiiiiiiiii'](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_iii(index, a1, a2) {
    try {
      return Module['dynCall_iii'](index, a1, a2)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_i(index) {
    try {
      return Module['dynCall_i'](index)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_viiiiiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) {
    try {
      Module['dynCall_viiiiiiiiiiii'](index, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_iiiii(index, a1, a2, a3, a4) {
    try {
      return Module['dynCall_iiiii'](index, a1, a2, a3, a4)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_viii(index, a1, a2, a3) {
    try {
      Module['dynCall_viii'](index, a1, a2, a3)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_v(index) {
    try {
      Module['dynCall_v'](index)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_iiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8) {
    try {
      return Module['dynCall_iiiiiiiii'](index, a1, a2, a3, a4, a5, a6, a7, a8)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  function invoke_viiii(index, a1, a2, a3, a4) {
    try {
      Module['dynCall_viiii'](index, a1, a2, a3, a4)
    } catch (e) {
      if (typeof e !== 'number' && e !== 'longjmp') throw e
      Module['setThrew'](1, 0)
    }
  }
  Module.asmGlobalArg = {
    'Math': Math,
    'Int8Array': Int8Array,
    'Int16Array': Int16Array,
    'Int32Array': Int32Array,
    'Uint8Array': Uint8Array,
    'Uint16Array': Uint16Array,
    'Uint32Array': Uint32Array,
    'Float32Array': Float32Array,
    'Float64Array': Float64Array,
    'NaN': NaN,
    'Infinity': Infinity
  }
  Module.asmLibraryArg = {
    'abort': abort,
    'assert': assert,
    'enlargeMemory': enlargeMemory,
    'getTotalMemory': getTotalMemory,
    'abortOnCannotGrowMemory': abortOnCannotGrowMemory,
    'invoke_iiiiiiii': invoke_iiiiiiii,
    'invoke_viiiii': invoke_viiiii,
    'invoke_vi': invoke_vi,
    'invoke_vii': invoke_vii,
    'invoke_iiiiiii': invoke_iiiiiii,
    'invoke_ii': invoke_ii,
    'invoke_viiiiiiiiiii': invoke_viiiiiiiiiii,
    'invoke_iiiiii': invoke_iiiiii,
    'invoke_iiii': invoke_iiii,
    'invoke_viiiiiiii': invoke_viiiiiiii,
    'invoke_viiiiii': invoke_viiiiii,
    'invoke_viiiiiiiiiiiii': invoke_viiiiiiiiiiiii,
    'invoke_viiiiiii': invoke_viiiiiii,
    'invoke_viiiiiiiii': invoke_viiiiiiiii,
    'invoke_viiiiiiiiii': invoke_viiiiiiiiii,
    'invoke_iii': invoke_iii,
    'invoke_i': invoke_i,
    'invoke_viiiiiiiiiiii': invoke_viiiiiiiiiiii,
    'invoke_iiiii': invoke_iiiii,
    'invoke_viii': invoke_viii,
    'invoke_v': invoke_v,
    'invoke_iiiiiiiii': invoke_iiiiiiiii,
    'invoke_viiii': invoke_viiii,
    'requireFunction': requireFunction,
    '_pthread_cond_wait': _pthread_cond_wait,
    '_pthread_join': _pthread_join,
    'simpleReadValueFromPointer': simpleReadValueFromPointer,
    'new_': new_,
    '___syscall54': ___syscall54,
    '__embind_register_integer': __embind_register_integer,
    'throwInternalError': throwInternalError,
    'get_first_emval': get_first_emval,
    '_abort': _abort,
    'whenDependentTypesAreResolved': whenDependentTypesAreResolved,
    '___gxx_personality_v0': ___gxx_personality_v0,
    'extendError': extendError,
    '___assert_fail': ___assert_fail,
    '__embind_register_void': __embind_register_void,
    '___cxa_find_matching_catch': ___cxa_find_matching_catch,
    '__embind_register_value_object_field': __embind_register_value_object_field,
    'exposePublicSymbol': exposePublicSymbol,
    '_pthread_cond_init': _pthread_cond_init,
    '__embind_register_function': __embind_register_function,
    'embind_init_charCodes': embind_init_charCodes,
    '___cxa_begin_catch': ___cxa_begin_catch,
    '___setErrNo': ___setErrNo,
    '__emval_register': __emval_register,
    'readLatin1String': readLatin1String,
    '___cxa_allocate_exception': ___cxa_allocate_exception,
    '_emscripten_memcpy_big': _emscripten_memcpy_big,
    '__embind_register_bool': __embind_register_bool,
    '___resumeException': ___resumeException,
    '__ZSt18uncaught_exceptionv': __ZSt18uncaught_exceptionv,
    '_embind_repr': _embind_repr,
    '__embind_register_std_wstring': __embind_register_std_wstring,
    '_pthread_getspecific': _pthread_getspecific,
    '_clock': _clock,
    'createNamedFunction': createNamedFunction,
    '__embind_register_emval': __embind_register_emval,
    '_pthread_cond_signal': _pthread_cond_signal,
    '__embind_finalize_value_object': __embind_finalize_value_object,
    '_pthread_mutex_destroy': _pthread_mutex_destroy,
    'throwUnboundTypeError': throwUnboundTypeError,
    'craftInvokerFunction': craftInvokerFunction,
    '__emval_decref': __emval_decref,
    '_pthread_once': _pthread_once,
    'getShiftFromSize': getShiftFromSize,
    'makeLegalFunctionName': makeLegalFunctionName,
    '_pthread_key_create': _pthread_key_create,
    '___unlock': ___unlock,
    'heap32VectorToArray': heap32VectorToArray,
    'init_emval': init_emval,
    '_pthread_create': _pthread_create,
    'floatReadValueFromPointer': floatReadValueFromPointer,
    '__embind_register_value_object': __embind_register_value_object,
    '_pthread_setspecific': _pthread_setspecific,
    'integerReadValueFromPointer': integerReadValueFromPointer,
    'registerType': registerType,
    '___cxa_throw': ___cxa_throw,
    '___lock': ___lock,
    '___syscall6': ___syscall6,
    'throwBindingError': throwBindingError,
    'ensureOverloadTable': ensureOverloadTable,
    'count_emval_handles': count_emval_handles,
    '_pthread_cond_destroy': _pthread_cond_destroy,
    '__embind_register_float': __embind_register_float,
    '_gettimeofday': _gettimeofday,
    'getTypeName': getTypeName,
    '___syscall140': ___syscall140,
    '_pthread_mutex_init': _pthread_mutex_init,
    '__embind_register_memory_view': __embind_register_memory_view,
    '__embind_register_std_string': __embind_register_std_string,
    'replacePublicSymbol': replacePublicSymbol,
    '___cxa_pure_virtual': ___cxa_pure_virtual,
    '___syscall146': ___syscall146,
    'runDestructors': runDestructors,
    'DYNAMICTOP_PTR': DYNAMICTOP_PTR,
    'tempDoublePtr': tempDoublePtr,
    'ABORT': ABORT,
    'STACKTOP': STACKTOP,
    'STACK_MAX': STACK_MAX
  }
  var asm = Module['asm'](Module.asmGlobalArg, Module.asmLibraryArg, buffer)
  Module['asm'] = asm
  var stackSave = Module['stackSave'] = function() {
    return Module['asm']['stackSave'].apply(null, arguments)
  }
  var _SetIFrameDecInterval = Module['_SetIFrameDecInterval'] = function() {
    return Module['asm']['_SetIFrameDecInterval'].apply(null, arguments)
  }
  var _CloseStream = Module['_CloseStream'] = function() {
    return Module['asm']['_CloseStream'].apply(null, arguments)
  }
  var setThrew = Module['setThrew'] = function() {
    return Module['asm']['setThrew'].apply(null, arguments)
  }
  var _GetFrameData = Module['_GetFrameData'] = function() {
    return Module['asm']['_GetFrameData'].apply(null, arguments)
  }
  var _sbrk = Module['_sbrk'] = function() {
    return Module['asm']['_sbrk'].apply(null, arguments)
  }
  var _fflush = Module['_fflush'] = function() {
    return Module['asm']['_fflush'].apply(null, arguments)
  }
  var ___cxa_is_pointer_type = Module['___cxa_is_pointer_type'] = function() {
    return Module['asm']['___cxa_is_pointer_type'].apply(null, arguments)
  }
  var _memset = Module['_memset'] = function() {
    return Module['asm']['_memset'].apply(null, arguments)
  }
  var _SetDisplayRegion = Module['_SetDisplayRegion'] = function() {
    return Module['asm']['_SetDisplayRegion'].apply(null, arguments)
  }
  var _memcpy = Module['_memcpy'] = function() {
    return Module['asm']['_memcpy'].apply(null, arguments)
  }
  var _llvm_bswap_i32 = Module['_llvm_bswap_i32'] = function() {
    return Module['asm']['_llvm_bswap_i32'].apply(null, arguments)
  }
  var stackAlloc = Module['stackAlloc'] = function() {
    return Module['asm']['stackAlloc'].apply(null, arguments)
  }
  var getTempRet0 = Module['getTempRet0'] = function() {
    return Module['asm']['getTempRet0'].apply(null, arguments)
  }
  var __GLOBAL__sub_I_bind_cpp = Module['__GLOBAL__sub_I_bind_cpp'] = function() {
    return Module['asm']['__GLOBAL__sub_I_bind_cpp'].apply(null, arguments)
  }
  var setTempRet0 = Module['setTempRet0'] = function() {
    return Module['asm']['setTempRet0'].apply(null, arguments)
  }
  var _SetSecretKey = Module['_SetSecretKey'] = function() {
    return Module['asm']['_SetSecretKey'].apply(null, arguments)
  }
  var _pthread_mutex_unlock = Module['_pthread_mutex_unlock'] = function() {
    return Module['asm']['_pthread_mutex_unlock'].apply(null, arguments)
  }
  var __GLOBAL__sub_I_Decoder_cpp = Module['__GLOBAL__sub_I_Decoder_cpp'] = function() {
    return Module['asm']['__GLOBAL__sub_I_Decoder_cpp'].apply(null, arguments)
  }
  var _emscripten_get_global_libc = Module['_emscripten_get_global_libc'] = function() {
    return Module['asm']['_emscripten_get_global_libc'].apply(null, arguments)
  }
  var _InputData = Module['_InputData'] = function() {
    return Module['asm']['_InputData'].apply(null, arguments)
  }
  var ___getTypeName = Module['___getTypeName'] = function() {
    return Module['asm']['___getTypeName'].apply(null, arguments)
  }
  var _GetJPEG = Module['_GetJPEG'] = function() {
    return Module['asm']['_GetJPEG'].apply(null, arguments)
  }
  var _OpenStream = Module['_OpenStream'] = function() {
    return Module['asm']['_OpenStream'].apply(null, arguments)
  }
  var _GetBMP = Module['_GetBMP'] = function() {
    return Module['asm']['_GetBMP'].apply(null, arguments)
  }
  var _pthread_cond_broadcast = Module['_pthread_cond_broadcast'] = function() {
    return Module['asm']['_pthread_cond_broadcast'].apply(null, arguments)
  }
  var ___errno_location = Module['___errno_location'] = function() {
    return Module['asm']['___errno_location'].apply(null, arguments)
  }
  var runPostSets = Module['runPostSets'] = function() {
    return Module['asm']['runPostSets'].apply(null, arguments)
  }
  var ___cxa_can_catch = Module['___cxa_can_catch'] = function() {
    return Module['asm']['___cxa_can_catch'].apply(null, arguments)
  }
  var _free = Module['_free'] = function() {
    return Module['asm']['_free'].apply(null, arguments)
  }
  var _GetFrameBuffer = Module['_GetFrameBuffer'] = function() {
    return Module['asm']['_GetFrameBuffer'].apply(null, arguments)
  }
  var establishStackSpace = Module['establishStackSpace'] = function() {
    return Module['asm']['establishStackSpace'].apply(null, arguments)
  }
  var _memmove = Module['_memmove'] = function() {
    return Module['asm']['_memmove'].apply(null, arguments)
  }
  var _SetStreamOpenMode = Module['_SetStreamOpenMode'] = function() {
    return Module['asm']['_SetStreamOpenMode'].apply(null, arguments)
  }
  var stackRestore = Module['stackRestore'] = function() {
    return Module['asm']['stackRestore'].apply(null, arguments)
  }
  var _malloc = Module['_malloc'] = function() {
    return Module['asm']['_malloc'].apply(null, arguments)
  }
  var _pthread_mutex_lock = Module['_pthread_mutex_lock'] = function() {
    return Module['asm']['_pthread_mutex_lock'].apply(null, arguments)
  }
  var _SetDecodeFrameType = Module['_SetDecodeFrameType'] = function() {
    return Module['asm']['_SetDecodeFrameType'].apply(null, arguments)
  }
  var _Stop = Module['_Stop'] = function() {
    return Module['asm']['_Stop'].apply(null, arguments)
  }
  var dynCall_iiiiiiii = Module['dynCall_iiiiiiii'] = function() {
    return Module['asm']['dynCall_iiiiiiii'].apply(null, arguments)
  }
  var dynCall_viiiii = Module['dynCall_viiiii'] = function() {
    return Module['asm']['dynCall_viiiii'].apply(null, arguments)
  }
  var dynCall_vi = Module['dynCall_vi'] = function() {
    return Module['asm']['dynCall_vi'].apply(null, arguments)
  }
  var dynCall_vii = Module['dynCall_vii'] = function() {
    return Module['asm']['dynCall_vii'].apply(null, arguments)
  }
  var dynCall_iiiiiii = Module['dynCall_iiiiiii'] = function() {
    return Module['asm']['dynCall_iiiiiii'].apply(null, arguments)
  }
  var dynCall_ii = Module['dynCall_ii'] = function() {
    return Module['asm']['dynCall_ii'].apply(null, arguments)
  }
  var dynCall_viiiiiiiiiii = Module['dynCall_viiiiiiiiiii'] = function() {
    return Module['asm']['dynCall_viiiiiiiiiii'].apply(null, arguments)
  }
  var dynCall_iiiiii = Module['dynCall_iiiiii'] = function() {
    return Module['asm']['dynCall_iiiiii'].apply(null, arguments)
  }
  var dynCall_iiii = Module['dynCall_iiii'] = function() {
    return Module['asm']['dynCall_iiii'].apply(null, arguments)
  }
  var dynCall_viiiiiiii = Module['dynCall_viiiiiiii'] = function() {
    return Module['asm']['dynCall_viiiiiiii'].apply(null, arguments)
  }
  var dynCall_viiiiii = Module['dynCall_viiiiii'] = function() {
    return Module['asm']['dynCall_viiiiii'].apply(null, arguments)
  }
  var dynCall_viiiiiiiiiiiii = Module['dynCall_viiiiiiiiiiiii'] = function() {
    return Module['asm']['dynCall_viiiiiiiiiiiii'].apply(null, arguments)
  }
  var dynCall_viiiiiii = Module['dynCall_viiiiiii'] = function() {
    return Module['asm']['dynCall_viiiiiii'].apply(null, arguments)
  }
  var dynCall_viiiiiiiii = Module['dynCall_viiiiiiiii'] = function() {
    return Module['asm']['dynCall_viiiiiiiii'].apply(null, arguments)
  }
  var dynCall_viiiiiiiiii = Module['dynCall_viiiiiiiiii'] = function() {
    return Module['asm']['dynCall_viiiiiiiiii'].apply(null, arguments)
  }
  var dynCall_iii = Module['dynCall_iii'] = function() {
    return Module['asm']['dynCall_iii'].apply(null, arguments)
  }
  var dynCall_i = Module['dynCall_i'] = function() {
    return Module['asm']['dynCall_i'].apply(null, arguments)
  }
  var dynCall_viiiiiiiiiiii = Module['dynCall_viiiiiiiiiiii'] = function() {
    return Module['asm']['dynCall_viiiiiiiiiiii'].apply(null, arguments)
  }
  var dynCall_iiiii = Module['dynCall_iiiii'] = function() {
    return Module['asm']['dynCall_iiiii'].apply(null, arguments)
  }
  var dynCall_viii = Module['dynCall_viii'] = function() {
    return Module['asm']['dynCall_viii'].apply(null, arguments)
  }
  var dynCall_v = Module['dynCall_v'] = function() {
    return Module['asm']['dynCall_v'].apply(null, arguments)
  }
  var dynCall_iiiiiiiii = Module['dynCall_iiiiiiiii'] = function() {
    return Module['asm']['dynCall_iiiiiiiii'].apply(null, arguments)
  }
  var dynCall_viiii = Module['dynCall_viiii'] = function() {
    return Module['asm']['dynCall_viiii'].apply(null, arguments)
  }
  Runtime.stackAlloc = Module['stackAlloc']
  Runtime.stackSave = Module['stackSave']
  Runtime.stackRestore = Module['stackRestore']
  Runtime.establishStackSpace = Module['establishStackSpace']
  Runtime.setTempRet0 = Module['setTempRet0']
  Runtime.getTempRet0 = Module['getTempRet0']
  Module['asm'] = asm
  if (memoryInitializer) {
    if (typeof Module['locateFile'] === 'function') {
      memoryInitializer = Module['locateFile'](memoryInitializer)
    } else if (Module['memoryInitializerPrefixURL']) {
      memoryInitializer = Module['memoryInitializerPrefixURL'] + memoryInitializer
    }
    if (ENVIRONMENT_IS_NODE || ENVIRONMENT_IS_SHELL) {
      var data = Module['readBinary'](memoryInitializer)
      HEAPU8.set(data, Runtime.GLOBAL_BASE)
    } else {
      addRunDependency('memory initializer')
      var applyMemoryInitializer = function(data) {
        if (data.byteLength) data = new Uint8Array(data)
        HEAPU8.set(data, Runtime.GLOBAL_BASE)
        if (Module['memoryInitializerRequest']) delete Module['memoryInitializerRequest'].response
        removeRunDependency('memory initializer')
      }
  
      function doBrowserLoad() {
        Module['readAsync'](memoryInitializer, applyMemoryInitializer, function() {
          throw 'could not load memory initializer ' + memoryInitializer
        })
      }
      if (Module['memoryInitializerRequest']) {
        function useRequest() {
          var request = Module['memoryInitializerRequest']
          if (request.status !== 200 && request.status !== 0) {
            console.warn('a problem seems to have happened with Module.memoryInitializerRequest, status: ' + request.status + ', retrying ' + memoryInitializer)
            doBrowserLoad()
            return
          }
          applyMemoryInitializer(request.response)
        }
        if (Module['memoryInitializerRequest'].response) {
          setTimeout(useRequest, 0)
        } else {
          Module['memoryInitializerRequest'].addEventListener('load', useRequest)
        }
      } else {
        doBrowserLoad()
      }
    }
  }
  function ExitStatus(status) {
    this.name = 'ExitStatus'
    this.message = 'Program terminated with exit(' + status + ')'
    this.status = status
  }
  ExitStatus.prototype = new Error()
  ExitStatus.prototype.constructor = ExitStatus
  var initialStackTop
  var preloadStartTime = null
  var calledMain = false
  dependenciesFulfilled = function runCaller() {
    if (!Module['calledRun']) run()
    if (!Module['calledRun']) dependenciesFulfilled = runCaller
  }
  Module['callMain'] = Module.callMain = function callMain(args) {
    args = args || []
    ensureInitRuntime()
    var argc = args.length + 1
  
    function pad() {
      for (var i = 0; i < 4 - 1; i++) {
        argv.push(0)
      }
    }
    var argv = [allocate(intArrayFromString(Module['thisProgram']), 'i8', ALLOC_NORMAL)]
    pad()
    for (var i = 0; i < argc - 1; i = i + 1) {
      argv.push(allocate(intArrayFromString(args[i]), 'i8', ALLOC_NORMAL))
      pad()
    }
    argv.push(0)
    argv = allocate(argv, 'i32', ALLOC_NORMAL)
    try {
      var ret = Module['_main'](argc, argv, 0)
      exit(ret, true)
    } catch (e) {
      if (e instanceof ExitStatus) {
        return
      } else if (e == 'SimulateInfiniteLoop') {
        Module['noExitRuntime'] = true
        return
      } else {
        var toLog = e
        if (e && typeof e === 'object' && e.stack) {
          toLog = [e, e.stack]
        }
        Module.printErr('exception thrown: ' + toLog)
        Module['quit'](1, e)
      }
    } finally {
      calledMain = true
    }
  }
  
  function run(args) {
    args = args || Module['arguments']
    if (preloadStartTime === null) preloadStartTime = Date.now()
    if (runDependencies > 0) {
      return
    }
    preRun()
    if (runDependencies > 0) return
    if (Module['calledRun']) return
  
    function doRun() {
      if (Module['calledRun']) return
      Module['calledRun'] = true
      if (ABORT) return
      ensureInitRuntime()
      preMain()
      if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']()
      if (Module['_main'] && shouldRunNow) Module['callMain'](args)
      postRun()
    }
    if (Module['setStatus']) {
      Module['setStatus']('Running...')
      setTimeout(function() {
        setTimeout(function() {
          Module['setStatus']('')
        }, 1)
        doRun()
      }, 1)
    } else {
      doRun()
    }
  }
  Module['run'] = Module.run = run
  
  function exit(status, implicit) {
    if (implicit && Module['noExitRuntime']) {
      return
    }
    if (Module['noExitRuntime']) {} else {
      ABORT = true
      EXITSTATUS = status
      STACKTOP = initialStackTop
      exitRuntime()
      if (Module['onExit']) Module['onExit'](status)
    }
    if (ENVIRONMENT_IS_NODE) {
      process['exit'](status)
    }
    Module['quit'](status, new ExitStatus(status))
  }
  Module['exit'] = Module.exit = exit
  var abortDecorators = []
  
  function abort(what) {
    if (Module['onAbort']) {
      Module['onAbort'](what)
    }
    if (what !== undefined) {
      Module.print(what)
      Module.printErr(what)
      what = JSON.stringify(what)
    } else {
      what = ''
    }
    ABORT = true
    EXITSTATUS = 1
    var extra = '\nIf this abort() is unexpected, build with -s ASSERTIONS=1 which can give more information.'
    var output = 'abort(' + what + ') at ' + stackTrace() + extra
    if (abortDecorators) {
      abortDecorators.forEach(function(decorator) {
        output = decorator(output, what)
      })
    }
    throw output
  }
  Module['abort'] = Module.abort = abort
  if (Module['preInit']) {
    if (typeof Module['preInit'] === 'function') Module['preInit'] = [Module['preInit']]
    while (Module['preInit'].length > 0) {
      Module['preInit'].pop()()
    }
  }
  var shouldRunNow = true
  if (Module['noInitialRun']) {
    shouldRunNow = false
  }
  run()
  