任务新增导出

zhongrj

2023-06-27 d74b495736f0c04522ec54274b70fed0ded2878d

 public/map/lib/videoPlay/js/playctrl/Decoder.min.js

New file
@@ -0,0 +1,3305 @@
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 ? quantum : 16)) * (quantum ? quantum : 16);
      return ret
   }),
   makeBigInt: (function(low, high, unsigned) {
      var ret = unsigned ? +(low >>> 0) + +(high >>> 0) * 4294967296 : +(low >>> 0) + +(high | 0) * 4294967296;
      return ret
   }),
   GLOBAL_BASE: 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],
               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,
         stop;
      assert((ret & 3) == 0);
      stop = ret + (size & ~3);
      for (; ptr < stop; ptr += 4) {
         HEAP32[ptr >> 2] = 0
      }
      stop = ret + size;
      while (ptr < stop) {
         HEAP8[ptr++ >> 0] = 0
      }
      return ret
   }
   if (singleType === "i8") {
      if (slab.subarray || slab.slice) {
         HEAPU8.set(slab, ret)
      } else {
         HEAPU8.set(new Uint8Array(slab), ret)
      }
      return ret
   }
   var i = 0,
      type, typeSize, previousType;
   while (i < size) {
      var curr = slab[i];
      if (typeof curr === "function") {
         curr = Runtime.getFunctionIndex(curr)
      }
      type = singleType || types[i];
      if (type === 0) {
         i++;
         continue
      }
      if (type == "i64") type = "i32";
      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 (0 === unregisteredTypes.length) {
      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 && 0 === --emval_handle_array[handle].refcount) {
      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(),
         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(),
         offset_high = SYSCALLS.get(),
         offset_low = SYSCALLS.get(),
         result = SYSCALLS.get(),
         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(),
         iov = SYSCALLS.get(),
         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()