@aislamov/onnxruntime-web64/lib/wasm/binding/ort-wasm-simd.jsep-copy5-working.js

A Javascript library for running ONNX models on browsers

var ortWasm = (() => {
  var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
  if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename;
  return (
function(ortWasm = {})  {

var Module = typeof ortWasm != "undefined" ? ortWasm : {};

var readyPromiseResolve, readyPromiseReject;

Module["ready"] = new Promise((resolve, reject) => {
 readyPromiseResolve = resolve;
 readyPromiseReject = reject;
});

var moduleOverrides = Object.assign({}, Module);

var arguments_ = [];

var thisProgram = "./this.program";

var quit_ = (status, toThrow) => {
 throw toThrow;
};

var ENVIRONMENT_IS_WEB = typeof window == "object";

var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";

var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";

var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;

var scriptDirectory = "";

function locateFile(path) {
 if (Module["locateFile"]) {
  return Module["locateFile"](path, scriptDirectory);
 }
 return scriptDirectory + path;
}

var read_, readAsync, readBinary, setWindowTitle;

if (ENVIRONMENT_IS_NODE) {
 var fs = require("fs");
 var nodePath = require("path");
 if (ENVIRONMENT_IS_WORKER) {
  scriptDirectory = nodePath.dirname(scriptDirectory) + "/";
 } else {
  scriptDirectory = __dirname + "/";
 }
 read_ = (filename, binary) => {
  filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
  return fs.readFileSync(filename, binary ? undefined : "utf8");
 };
 readBinary = filename => {
  var ret = read_(filename, true);
  if (!ret.buffer) {
   ret = new Uint8Array(ret);
  }
  return ret;
 };
 readAsync = (filename, onload, onerror, binary = true) => {
  filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
  fs.readFile(filename, binary ? undefined : "utf8", (err, data) => {
   if (err) onerror(err); else onload(binary ? data.buffer : data);
  });
 };
 if (!Module["thisProgram"] && process.argv.length > 1) {
  thisProgram = process.argv[1].replace(/\\/g, "/");
 }
 arguments_ = process.argv.slice(2);
 quit_ = (status, toThrow) => {
  process.exitCode = status;
  throw toThrow;
 };
 Module["inspect"] = () => "[Emscripten Module object]";
} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
 if (ENVIRONMENT_IS_WORKER) {
  scriptDirectory = self.location.href;
 } else if (typeof document != "undefined" && document.currentScript) {
  scriptDirectory = document.currentScript.src;
 }
 if (_scriptDir) {
  scriptDirectory = _scriptDir;
 }
 if (scriptDirectory.indexOf("blob:") !== 0) {
  scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
 } else {
  scriptDirectory = "";
 }
 {
  read_ = url => {
   var xhr = new XMLHttpRequest();
   xhr.open("GET", url, false);
   xhr.send(null);
   return xhr.responseText;
  };
  if (ENVIRONMENT_IS_WORKER) {
   readBinary = url => {
    var xhr = new XMLHttpRequest();
    xhr.open("GET", url, false);
    xhr.responseType = "arraybuffer";
    xhr.send(null);
    return new Uint8Array(xhr.response);
   };
  }
  readAsync = (url, onload, onerror) => {
   var xhr = new XMLHttpRequest();
   xhr.open("GET", url, true);
   xhr.responseType = "arraybuffer";
   xhr.onload = () => {
    if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
     onload(xhr.response);
     return;
    }
    onerror();
   };
   xhr.onerror = onerror;
   xhr.send(null);
  };
 }
 setWindowTitle = title => document.title = title;
} else {}

var out = Module["print"] || console.log.bind(console);

var err = Module["printErr"] || console.error.bind(console);

Object.assign(Module, moduleOverrides);

moduleOverrides = null;

if (Module["arguments"]) arguments_ = Module["arguments"];

if (Module["thisProgram"]) thisProgram = Module["thisProgram"];

if (Module["quit"]) quit_ = Module["quit"];

var wasmBinary;

if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];

var noExitRuntime = Module["noExitRuntime"] || true;

if (typeof WebAssembly != "object") {
 abort("no native wasm support detected");
}

var wasmMemory;

var ABORT = false;

var EXITSTATUS;

function assert(condition, text) {
 if (!condition) {
  abort(text);
 }
}

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

const getHeapBlock = (type, offset, byteLength) => {
 const maxMemory = 4 * 1024 * 1024 * 1e3;
 const maxSize = Math.min(wasmMemory.buffer.byteLength, maxMemory);
 const heap = wasmMemory.buffer;
 switch (type) {
 case "i1":
 case "i8":
  return new Int8Array(heap, offset, byteLength || maxSize / Int8Array.BYTES_PER_ELEMENT);

 case "u1":
 case "u8":
  return new Uint8Array(heap, offset, byteLength || maxSize / Uint8Array.BYTES_PER_ELEMENT);

 case "i16":
  return new Int16Array(heap, offset, byteLength || maxSize / Int16Array.BYTES_PER_ELEMENT);

 case "u16":
  return new Uint16Array(heap, offset, byteLength || maxSize / Uint16Array.BYTES_PER_ELEMENT);

 case "i32":
  return new Int32Array(heap, offset, byteLength || maxSize / Int32Array.BYTES_PER_ELEMENT);

 case "u32":
  return new Uint32Array(heap, offset, byteLength || maxSize / Uint32Array.BYTES_PER_ELEMENT);

 case "f32":
  return new Float32Array(heap, offset, byteLength || maxSize / Float32Array.BYTES_PER_ELEMENT);

 case "f64":
  return new Float64Array(heap, offset, byteLength || maxSize / Float64Array.BYTES_PER_ELEMENT);

 case "i64":
  return new BigInt64Array(heap, offset, byteLength || maxSize / BigInt64Array.BYTES_PER_ELEMENT);

 case "*":
 case "u64":
  return new BigUint64Array(heap, offset, byteLength || maxSize / BigUint64Array.BYTES_PER_ELEMENT);

 default:
  throw new Error("Invalid type");
 }
};

function updateMemoryViews() {
 var b = wasmMemory.buffer;
 var maxSize = Math.min(b.byteLength, 4 * 1024 * 1024 * 1e3);
 const maxMemory = 4 * 1024 * 1024 * 1e3;
 var proxyHandler = (type, hb) => ({
  heapBlock: hb,
  copyWithin: function(target, start, end) {
   const bpe = hb.BYTES_PER_ELEMENT;
   if (target * bpe >= maxSize || start * bpe >= maxSize || end && end * bpe >= maxSize) {
    // console.log("copy within overridden", target, start, end, maxSize);
    const len = (end - start) * bpe;
    const targetArray = getHeapBlock(type, target * bpe, len);
    const sourceArray = getHeapBlock(type, start * bpe, len);
    targetArray.set(sourceArray);
    return hb;
   } else {
    return hb.copyWithin(target, start, end);
   }
  },
  setOverridden: function(array, offset) {
   const offsetReal = (offset || 0) * hb.BYTES_PER_ELEMENT;
   if (offsetReal >= maxSize || array.byteLength + offsetReal >= maxSize) {
    // console.log("set overridden", offset);
    const targetArray = getHeapBlock(type, offsetReal, array.byteLength);
    targetArray.set(array);
   } else {
    hb.set(array, offset);
   }
  },
  get: function(target, property) {
   if (typeof property === "number" || typeof property === "bigint") {
    var memoryOffset = Number(property) * target.BYTES_PER_ELEMENT;
    if (memoryOffset >= maxMemory) {
     // console.log("get overridden", property);
     var heap = getHeapBlock(type, memoryOffset, target.BYTES_PER_ELEMENT * 2);
     return heap[0 >>> 0];
    } else {
     return this.heapBlock[property];
    }
   }
   if (property === "copyWithin") {
    return this.copyWithin;
   }
   if (property === "set") {
    return this.setOverridden;
   }
   if (property === "subarray") {
    const subarray = (start, end) => {
     const startReal = (start || 0) * this.heapBlock.BYTES_PER_ELEMENT;
     const endReal = end ? end * this.heapBlock.BYTES_PER_ELEMENT : wasmMemory.byteLength;
     if (startReal >= maxSize || endReal >= maxSize) {
      // console.log("subarray overridden", start, end);
      return getHeapBlock(type, startReal, endReal - startReal);
     } else {
      return this.heapBlock.subarray(start, end);
     }
    };
    return subarray;
   }
   console.log("returning default", property);
   return this.heapBlock[property];
  },
  set: function(target, property, value) {
   if (typeof property === "number" || typeof property === "bigint") {
    var memoryOffset = Number(property) * target.BYTES_PER_ELEMENT;
    if (memoryOffset >= maxMemory) {
     // console.log("set overridden", property);
     var heap = getHeapBlock(type, memoryOffset, target.BYTES_PER_ELEMENT);
     heap[0 >>> 0] = value;
     return true;
    }
   }
   this.heapBlock[property] = value;
   return true;
  }
 });
 console.log("max size", maxSize, b.byteLength);
 function createMemoryProxy(type) {
  const block = getHeapBlock(type, 0);
  return new Proxy(block, proxyHandler(type, block));
 }
 try {
  Module["HEAP8"] = HEAP8 = createMemoryProxy("i8");
 } catch (e) {
  console.error(e);
  throw e;
 }
 Module["HEAP16"] = HEAP16 = createMemoryProxy("i16");
 Module["HEAP32"] = HEAP32 = createMemoryProxy("i32");
 Module["HEAPU8"] = HEAPU8 = createMemoryProxy("u8");
 Module["HEAPU16"] = HEAPU16 = createMemoryProxy("u16");
 Module["HEAPU32"] = HEAPU32 = createMemoryProxy("u32");
 Module["HEAPF32"] = HEAPF32 = createMemoryProxy("f32");
 Module["HEAPF64"] = HEAPF64 = createMemoryProxy("f64");
 Module["HEAP64"] = HEAP64 = createMemoryProxy("i64");
 Module["HEAPU64"] = HEAPU64 = createMemoryProxy("u64");
 Module["MEMORY"] = b;
}

var wasmTable;

var __ATPRERUN__ = [];

var __ATINIT__ = [];

var __ATEXIT__ = [];

var __ATPOSTRUN__ = [];

var runtimeInitialized = false;

var runtimeKeepaliveCounter = 0;

function keepRuntimeAlive() {
 return noExitRuntime || runtimeKeepaliveCounter > 0;
}

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 initRuntime() {
 runtimeInitialized = true;
 callRuntimeCallbacks(__ATINIT__);
}

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

function addOnInit(cb) {
 __ATINIT__.unshift(cb);
}

function addOnExit(cb) {}

function addOnPostRun(cb) {
 __ATPOSTRUN__.unshift(cb);
}

var runDependencies = 0;

var runDependencyWatcher = null;

var dependenciesFulfilled = null;

function getUniqueRunDependency(id) {
 return id;
}

function addRunDependency(id) {
 runDependencies++;
 if (Module["monitorRunDependencies"]) {
  Module["monitorRunDependencies"](runDependencies);
 }
}

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

function abort(what) {
 if (Module["onAbort"]) {
  Module["onAbort"](what);
 }
 what = "Aborted(" + what + ")";
 err(what);
 ABORT = true;
 EXITSTATUS = 1;
 what += ". Build with -sASSERTIONS for more info.";
 var e = new WebAssembly.RuntimeError(what);
 readyPromiseReject(e);
 throw e;
}

var dataURIPrefix = "data:application/octet-stream;base64,";

function isDataURI(filename) {
 return filename.startsWith(dataURIPrefix);
}

function isFileURI(filename) {
 return filename.startsWith("file://");
}

var wasmBinaryFile;

wasmBinaryFile = "ort-wasm-simd.wasm";

if (!isDataURI(wasmBinaryFile)) {
 wasmBinaryFile = locateFile(wasmBinaryFile);
}

function getBinary(file) {
 try {
  if (file == wasmBinaryFile && wasmBinary) {
   return new Uint8Array(wasmBinary);
  }
  if (readBinary) {
   return readBinary(file);
  }
  throw "both async and sync fetching of the wasm failed";
 } catch (err) {
  abort(err);
 }
}

function getBinaryPromise(binaryFile) {
 if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
  if (typeof fetch == "function" && !isFileURI(binaryFile)) {
   return fetch(binaryFile, {
    credentials: "same-origin"
   }).then(response => {
    if (!response["ok"]) {
     throw "failed to load wasm binary file at '" + binaryFile + "'";
    }
    return response["arrayBuffer"]();
   }).catch(() => getBinary(binaryFile));
  } else {
   if (readAsync) {
    return new Promise((resolve, reject) => {
     readAsync(binaryFile, response => resolve(new Uint8Array(response)), reject);
    });
   }
  }
 }
 return Promise.resolve().then(() => getBinary(binaryFile));
}

function instantiateArrayBuffer(binaryFile, imports, receiver) {
 return getBinaryPromise(binaryFile).then(binary => {
  return WebAssembly.instantiate(binary, imports);
 }).then(instance => {
  return instance;
 }).then(receiver, reason => {
  err("failed to asynchronously prepare wasm: " + reason);
  abort(reason);
 });
}

function instantiateAsync(binary, binaryFile, imports, callback) {
 if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
  return fetch(binaryFile, {
   credentials: "same-origin"
  }).then(response => {
   var result = WebAssembly.instantiateStreaming(response, imports);
   return result.then(callback, function(reason) {
    err("wasm streaming compile failed: " + reason);
    err("falling back to ArrayBuffer instantiation");
    return instantiateArrayBuffer(binaryFile, imports, callback);
   });
  });
 } else {
  return instantiateArrayBuffer(binaryFile, imports, callback);
 }
}

function createWasm() {
 var info = {
  "env": wasmImports,
  "wasi_snapshot_preview1": wasmImports
 };
 function receiveInstance(instance, module) {
  var exports = instance.exports;
  exports = instrumentWasmExportsForMemory64(exports);
  Module["asm"] = exports;
  wasmMemory = Module["asm"]["memory"];
  updateMemoryViews();
  wasmTable = Module["asm"]["__indirect_function_table"];
  addOnInit(Module["asm"]["__wasm_call_ctors"]);
  removeRunDependency("wasm-instantiate");
  return exports;
 }
 addRunDependency("wasm-instantiate");
 function receiveInstantiationResult(result) {
  receiveInstance(result["instance"]);
 }
 if (Module["instantiateWasm"]) {
  try {
   return Module["instantiateWasm"](info, receiveInstance);
  } catch (e) {
   err("Module.instantiateWasm callback failed with error: " + e);
   readyPromiseReject(e);
  }
 }
 instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
 return {};
}

function ExitStatus(status) {
 this.name = "ExitStatus";
 this.message = `Program terminated with exit(${status})`;
 this.status = status;
}

function callRuntimeCallbacks(callbacks) {
 while (callbacks.length > 0) {
  callbacks.shift()(Module);
 }
}

function getValue(ptr, type = "i8") {
 if (type.endsWith("*")) type = "*";
 switch (type) {
 case "i1":
  return HEAP8[ptr / 2 ** 0 >>> 0];

 case "i8":
  return HEAP8[ptr / 2 ** 0 >>> 0];

 case "i16":
  return HEAP16[ptr / 2 ** 1 >>> 0];

 case "i32":
  return HEAP32[ptr / 2 ** 2 >>> 0];

 case "i64":
  return HEAP64[ptr / 2 ** 3];

 case "float":
  return HEAPF32[ptr / 2 ** 2 >>> 0];

 case "double":
  return HEAPF64[ptr / 2 ** 3 >>> 0];

 case "*":
  return Number(HEAPU64[ptr / 2 ** 3]);

 default:
  abort(`invalid type for getValue: ${type}`);
 }
}

function setValue(ptr, value, type = "i8") {
 if (type.endsWith("*")) type = "*";
 switch (type) {
 case "i1":
  HEAP8[ptr / 2 ** 0 >>> 0] = value;
  break;

 case "i8":
  HEAP8[ptr / 2 ** 0 >>> 0] = value;
  break;

 case "i16":
  HEAP16[ptr / 2 ** 1 >>> 0] = value;
  break;

 case "i32":
  HEAP32[ptr / 2 ** 2 >>> 0] = value;
  break;

 case "i64":
  HEAP64[ptr / 2 ** 3] = BigInt(value);
  break;

 case "float":
  HEAPF32[ptr / 2 ** 2 >>> 0] = value;
  break;

 case "double":
  HEAPF64[ptr / 2 ** 3 >>> 0] = value;
  break;

 case "*":
  HEAPU64[ptr / 2 ** 3] = BigInt(value);
  break;

 default:
  abort(`invalid type for setValue: ${type}`);
 }
}

var exceptionCaught = [];

var uncaughtExceptionCount = 0;

function ___cxa_begin_catch(ptr) {
 var ret = (ptr => {
  var info = new ExceptionInfo(ptr);
  if (!info.get_caught()) {
   info.set_caught(true);
   uncaughtExceptionCount--;
  }
  info.set_rethrown(false);
  exceptionCaught.push(info);
  ___cxa_increment_exception_refcount(info.excPtr);
  return info.get_exception_ptr();
 })(Number(ptr));
 return BigInt(ret);
}

var exceptionLast = 0;

function ___cxa_end_catch() {
 _setThrew(0);
 var info = exceptionCaught.pop();
 ___cxa_decrement_exception_refcount(info.excPtr);
 exceptionLast = 0;
}

function ExceptionInfo(excPtr) {
 this.excPtr = excPtr;
 this.ptr = excPtr - 48;
 this.set_type = function(type) {
  HEAPU64[(this.ptr + 8) / 2 ** 3] = BigInt(type);
 };
 this.get_type = function() {
  return Number(HEAPU64[(this.ptr + 8) / 2 ** 3]);
 };
 this.set_destructor = function(destructor) {
  HEAPU64[(this.ptr + 16) / 2 ** 3] = BigInt(destructor);
 };
 this.get_destructor = function() {
  return Number(HEAPU64[(this.ptr + 16) / 2 ** 3]);
 };
 this.set_caught = function(caught) {
  caught = caught ? 1 : 0;
  HEAP8[(this.ptr + 24) / 2 ** 0 >>> 0] = caught;
 };
 this.get_caught = function() {
  return HEAP8[(this.ptr + 24) / 2 ** 0 >>> 0] != 0;
 };
 this.set_rethrown = function(rethrown) {
  rethrown = rethrown ? 1 : 0;
  HEAP8[(this.ptr + 25) / 2 ** 0 >>> 0] = rethrown;
 };
 this.get_rethrown = function() {
  return HEAP8[(this.ptr + 25) / 2 ** 0 >>> 0] != 0;
 };
 this.init = function(type, destructor) {
  this.set_adjusted_ptr(0);
  this.set_type(type);
  this.set_destructor(destructor);
 };
 this.set_adjusted_ptr = function(adjustedPtr) {
  HEAPU64[(this.ptr + 32) / 2 ** 3] = BigInt(adjustedPtr);
 };
 this.get_adjusted_ptr = function() {
  return Number(HEAPU64[(this.ptr + 32) / 2 ** 3]);
 };
 this.get_exception_ptr = function() {
  var isPointer = ___cxa_is_pointer_type(this.get_type());
  if (isPointer) {
   return Number(HEAPU64[this.excPtr / 2 ** 3]);
  }
  var adjusted = this.get_adjusted_ptr();
  if (adjusted !== 0) return adjusted;
  return this.excPtr;
 };
}

function ___resumeException(ptr) {
 ptr = Number(ptr);
 if (!exceptionLast) {
  exceptionLast = ptr;
 }
 throw exceptionLast;
}

function ___cxa_find_matching_catch() {
 var thrown = exceptionLast;
 if (!thrown) {
  setTempRet0(0);
  return BigInt(0);
 }
 var info = new ExceptionInfo(thrown);
 info.set_adjusted_ptr(thrown);
 var thrownType = info.get_type();
 if (!thrownType) {
  setTempRet0(0);
  return BigInt(thrown);
 }
 for (var i = 0; i < arguments.length; i++) {
  var caughtType = arguments[i];
  caughtType = Number(caughtType);
  if (caughtType === 0 || caughtType === thrownType) {
   break;
  }
  var adjusted_ptr_addr = info.ptr + 32;
  if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {
   setTempRet0(caughtType);
   return BigInt(thrown);
  }
 }
 setTempRet0(thrownType);
 return BigInt(thrown);
}

var ___cxa_find_matching_catch_2 = ___cxa_find_matching_catch;

var ___cxa_find_matching_catch_3 = ___cxa_find_matching_catch;

var ___cxa_find_matching_catch_4 = ___cxa_find_matching_catch;

var ___cxa_find_matching_catch_5 = ___cxa_find_matching_catch;

function ___cxa_rethrow() {
 var info = exceptionCaught.pop();
 if (!info) {
  abort("no exception to throw");
 }
 var ptr = info.excPtr;
 if (!info.get_rethrown()) {
  exceptionCaught.push(info);
  info.set_rethrown(true);
  info.set_caught(false);
  uncaughtExceptionCount++;
 }
 exceptionLast = ptr;
 throw exceptionLast;
}

function ___cxa_throw(ptr, type, destructor) {
 ptr = Number(ptr);
 type = Number(type);
 destructor = Number(destructor);
 var info = new ExceptionInfo(ptr);
 info.init(type, destructor);
 exceptionLast = ptr;
 uncaughtExceptionCount++;
 throw exceptionLast;
}

function ___cxa_uncaught_exceptions() {
 return uncaughtExceptionCount;
}

var dlopenMissingError = "To use dlopen, you need enable dynamic linking, see https://emscripten.org/docs/compiling/Dynamic-Linking.html";

function ___dlsym(handle, symbol, ra) {
 var ret = ((handle, symbol, ra) => {
  abort(dlopenMissingError);
 })(Number(handle), Number(symbol), Number(ra));
 return BigInt(ret);
}

function setErrNo(value) {
 HEAP32[___errno_location() / 2 ** 2 >>> 0] = value;
 return value;
}

var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;

function fixPointer (idx) {
 if (idx < 0) {
  return idx >>> 0
 }

 return idx;
}

function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
 idx = fixPointer(idx);
 var endIdx = idx + maxBytesToRead;
 var endPtr = idx;
 while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
 if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
  return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
 }
 var str = "";
 while (idx < endPtr) {
  var u0 = heapOrArray[idx++];
  if (!(u0 & 128)) {
   str += String.fromCharCode(u0);
   continue;
  }
  var u1 = heapOrArray[idx++] & 63;
  if ((u0 & 224) == 192) {
   str += String.fromCharCode((u0 & 31) << 6 | u1);
   continue;
  }
  var u2 = heapOrArray[idx++] & 63;
  if ((u0 & 240) == 224) {
   u0 = (u0 & 15) << 12 | u1 << 6 | u2;
  } else {
   u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
  }
  if (u0 < 65536) {
   str += String.fromCharCode(u0);
  } else {
   var ch = u0 - 65536;
   str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
  }
 }
 return str;
}

function UTF8ToString(ptr, maxBytesToRead) {
 if (typeof ptr !== "bigint") {
  ptr = fixPointer(ptr);
 } else {
  ptr = Number(ptr);
 }
 return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
}

var SYSCALLS = {
 varargs: undefined,
 get: function() {
  SYSCALLS.varargs += 4;
  var ret = HEAP32[(SYSCALLS.varargs - 4) / 2 ** 2 >>> 0];
  return ret;
 },
 getStr: function(ptr) {
  var ret = UTF8ToString(ptr);
  return ret;
 }
};

function ___syscall_fcntl64(fd, cmd, varargs) {
 varargs = Number(varargs);
 SYSCALLS.varargs = varargs;
 return 0;
}

function ___syscall_fstat64(fd, buf) {
 buf = Number(buf);
}

function lengthBytesUTF8(str) {
 var len = 0;
 for (var i = 0; i < str.length; ++i) {
  var c = str.charCodeAt(i);
  if (c <= 127) {
   len++;
  } else if (c <= 2047) {
   len += 2;
  } else if (c >= 55296 && c <= 57343) {
   len += 4;
   ++i;
  } else {
   len += 3;
  }
 }
 return len;
}

function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
 outIdx = fixPointer(outIdx);
 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) {
   var u1 = str.charCodeAt(++i);
   u = 65536 + ((u & 1023) << 10) | u1 & 1023;
  }
  if (u <= 127) {
   if (outIdx >= endIdx) break;
   heap[outIdx++] = u;
  } else if (u <= 2047) {
   if (outIdx + 1 >= endIdx) break;
   heap[outIdx++] = 192 | u >> 6;
   heap[outIdx++] = 128 | u & 63;
  } else if (u <= 65535) {
   if (outIdx + 2 >= endIdx) break;
   heap[outIdx++] = 224 | u >> 12;
   heap[outIdx++] = 128 | u >> 6 & 63;
   heap[outIdx++] = 128 | u & 63;
  } else {
   if (outIdx + 3 >= endIdx) break;
   heap[outIdx++] = 240 | u >> 18;
   heap[outIdx++] = 128 | u >> 12 & 63;
   heap[outIdx++] = 128 | u >> 6 & 63;
   heap[outIdx++] = 128 | u & 63;
  }
 }
 heap[outIdx] = 0;
 return outIdx - startIdx;
}

function stringToUTF8(str, outPtr, maxBytesToWrite) {
 return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
}

function ___syscall_getcwd(buf, size) {
 buf = Number(buf);
 size = Number(size);
}

function ___syscall_getdents64(fd, dirp, count) {
 dirp = Number(dirp);
 count = Number(count);
}

function ___syscall_ioctl(fd, op, varargs) {
 varargs = Number(varargs);
 SYSCALLS.varargs = varargs;
 return 0;
}

function ___syscall_lstat64(path, buf) {
 path = Number(path);
 buf = Number(buf);
}

function ___syscall_mkdirat(dirfd, path, mode) {
 path = Number(path);
}

function ___syscall_newfstatat(dirfd, path, buf, flags) {
 path = Number(path);
 buf = Number(buf);
}

function ___syscall_openat(dirfd, path, flags, varargs) {
 path = Number(path);
 varargs = Number(varargs);
 SYSCALLS.varargs = varargs;
}

function ___syscall_readlinkat(dirfd, path, buf, bufsize) {
 path = Number(path);
 buf = Number(buf);
 bufsize = Number(bufsize);
}

function ___syscall_rmdir(path) {
 path = Number(path);
}

function ___syscall_stat64(path, buf) {
 path = Number(path);
 buf = Number(buf);
}

function ___syscall_unlinkat(dirfd, path, flags) {
 path = Number(path);
}

function embindRepr(v) {
 if (v === null) {
  return "null";
 }
 var t = typeof v;
 if (t === "object" || t === "array" || t === "function") {
  return v.toString();
 } else {
  return "" + v;
 }
}

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 >>> 0]) {
  ret += embind_charCodes[HEAPU8[c++ >>> 0]];
 }
 return ret;
}

var awaitingDependencies = {};

var registeredTypes = {};

var typeDependencies = {};

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}`;
 }
 return name;
}

function createNamedFunction(name, body) {
 name = makeLegalFunctionName(name);
 return {
  [name]: function() {
   return body.apply(this, arguments);
  }
 }[name];
}

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

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((dt, i) => {
  if (registeredTypes.hasOwnProperty(dt)) {
   typeConverters[i] = registeredTypes[dt];
  } else {
   unregisteredTypes.push(dt);
   if (!awaitingDependencies.hasOwnProperty(dt)) {
    awaitingDependencies[dt] = [];
   }
   awaitingDependencies[dt].push(() => {
    typeConverters[i] = registeredTypes[dt];
    ++registered;
    if (registered === unregisteredTypes.length) {
     onComplete(typeConverters);
    }
   });
  }
 });
 if (0 === unregisteredTypes.length) {
  onComplete(typeConverters);
 }
}

function registerType(rawType, registeredInstance, 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(cb => cb());
 }
}

function integerReadValueFromPointer(name, shift, signed) {
 switch (shift) {
 case 0:
  return signed ? function readS8FromPointer(pointer) {
   return HEAP8[pointer >>> 0];
  } : function readU8FromPointer(pointer) {
   return HEAPU8[pointer >>> 0];
  };

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

 case 3:
  return signed ? function readS64FromPointer(pointer) {
   return HEAP64[pointer >> 3];
  } : function readU64FromPointer(pointer) {
   return HEAPU64[pointer >> 3];
  };

 default:
  throw new TypeError("Unknown integer type: " + name);
 }
}

function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {
 primitiveType = Number(primitiveType);
 name = Number(name);
 size = Number(size);
 name = readLatin1String(name);
 var shift = getShiftFromSize(size);
 var isUnsignedType = name.indexOf("u") != -1;
 if (isUnsignedType) {
  maxRange = (1n << 64n) - 1n;
 }
 registerType(primitiveType, {
  name: name,
  "fromWireType": function(value) {
   return value;
  },
  "toWireType": function(destructors, value) {
   if (typeof value != "bigint" && typeof value != "number") {
    throw new TypeError(`Cannot convert "${embindRepr(value)}" to ${this.name}`);
   }
   if (value < minRange || value > maxRange) {
    throw new TypeError(`Passing a number "${embindRepr(value)}" from JS side to C/C++ side to an argument of type "${name}", which is outside the valid range [${minRange}, ${maxRange}]!`);
   }
   return value;
  },
  "argPackAdvance": 8,
  "readValueFromPointer": integerReadValueFromPointer(name, shift, !isUnsignedType),
  destructorFunction: null
 });
}

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) {
 rawType = Number(rawType);
 name = Number(name);
 size = Number(size);
 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 HandleAllocator() {
 this.allocated = [ undefined ];
 this.freelist = [];
 this.get = function(id) {
  return this.allocated[id];
 };
 this.has = function(id) {
  return this.allocated[id] !== undefined;
 };
 this.allocate = function(handle) {
  var id = this.freelist.pop() || this.allocated.length;
  this.allocated[id] = handle;
  return id;
 };
 this.free = function(id) {
  this.allocated[id] = undefined;
  this.freelist.push(id);
 };
}

var emval_handles = new HandleAllocator();

function __emval_decref(handle) {
 handle = Number(handle);
 if (handle >= emval_handles.reserved && 0 === --emval_handles.get(handle).refcount) {
  emval_handles.free(handle);
 }
}

function count_emval_handles() {
 var count = 0;
 for (var i = emval_handles.reserved; i < emval_handles.allocated.length; ++i) {
  if (emval_handles.allocated[i] !== undefined) {
   ++count;
  }
 }
 return count;
}

function init_emval() {
 emval_handles.allocated.push({
  value: undefined
 }, {
  value: null
 }, {
  value: true
 }, {
  value: false
 });
 emval_handles.reserved = emval_handles.allocated.length;
 Module["count_emval_handles"] = count_emval_handles;
}

var Emval = {
 toValue: handle => {
  if (!handle) {
   throwBindingError("Cannot use deleted val. handle = " + handle);
  }
  return emval_handles.get(handle).value;
 },
 toHandle: value => {
  switch (value) {
  case undefined:
   return 1;

  case null:
   return 2;

  case true:
   return 3;

  case false:
   return 4;

  default:
   {
    return emval_handles.allocate({
     refcount: 1,
     value: value
    });
   }
  }
 }
};

function simpleReadValueFromPointer(pointer) {
 return this["fromWireType"](HEAP32[pointer / 2 ** 2 >>> 0]);
}

function __embind_register_emval(rawType, name) {
 rawType = Number(rawType);
 name = Number(name);
 name = readLatin1String(name);
 registerType(rawType, {
  name: name,
  "fromWireType": function(handle) {
   var rv = Emval.toValue(handle);
   __emval_decref(handle);
   return rv;
  },
  "toWireType": function(destructors, value) {
   return Emval.toHandle(value);
  },
  "argPackAdvance": 8,
  "readValueFromPointer": simpleReadValueFromPointer,
  destructorFunction: null
 });
}

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) {
 rawType = Number(rawType);
 name = Number(name);
 size = Number(size);
 var shift = getShiftFromSize(size);
 name = readLatin1String(name);
 registerType(rawType, {
  name: name,
  "fromWireType": function(value) {
   return value;
  },
  "toWireType": function(destructors, value) {
   return value;
  },
  "argPackAdvance": 8,
  "readValueFromPointer": floatReadValueFromPointer(name, shift),
  destructorFunction: null
 });
}

function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
 primitiveType = Number(primitiveType);
 name = Number(name);
 size = Number(size);
 name = readLatin1String(name);
 if (maxRange === -1) {
  maxRange = 4294967295;
 }
 var shift = getShiftFromSize(size);
 var fromWireType = value => value;
 if (minRange === 0) {
  var bitshift = 32 - 8 * size;
  fromWireType = value => value << bitshift >>> bitshift;
 }
 var isUnsignedType = name.includes("unsigned");
 var checkAssertions = (value, toTypeName) => {};
 var toWireType;
 if (isUnsignedType) {
  toWireType = function(destructors, value) {
   checkAssertions(value, this.name);
   return value >>> 0;
  };
 } else {
  toWireType = function(destructors, value) {
   checkAssertions(value, this.name);
   return value;
  };
 }
 registerType(primitiveType, {
  name: name,
  "fromWireType": fromWireType,
  "toWireType": toWireType,
  "argPackAdvance": 8,
  "readValueFromPointer": integerReadValueFromPointer(name, shift, minRange !== 0),
  destructorFunction: null
 });
}

function __embind_register_memory_view(rawType, dataTypeIndex, name) {
 rawType = Number(rawType);
 name = Number(name);
 var typeMapping = [ Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array ];
 var TA = typeMapping[dataTypeIndex];
 function decodeMemoryView(handle) {
  handle = handle >> 2;
  var heap = HEAPU32;
  var size = heap[handle >>> 0];
  var data = heap[handle + 1 >>> 0];
  return new TA(heap.buffer, data, size);
 }
 name = readLatin1String(name);
 registerType(rawType, {
  name: name,
  "fromWireType": decodeMemoryView,
  "argPackAdvance": 8,
  "readValueFromPointer": decodeMemoryView
 }, {
  ignoreDuplicateRegistrations: true
 });
}

function __embind_register_std_string(rawType, name) {
 rawType = Number(rawType);
 name = Number(name);
 name = readLatin1String(name);
 var stdStringIsUTF8 = name === "std::string";
 registerType(rawType, {
  name: name,
  "fromWireType": function(value) {
   var length = HEAPU64[value / 2 ** 3];
   var payload = value + 8;
   var str;
   if (stdStringIsUTF8) {
    var decodeStartPtr = payload;
    for (var i = 0; i <= length; ++i) {
     var currentBytePtr = payload + i;
     if (i == length || HEAPU8[currentBytePtr >>> 0] == 0) {
      var maxRead = currentBytePtr - decodeStartPtr;
      var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
      if (str === undefined) {
       str = stringSegment;
      } else {
       str += String.fromCharCode(0);
       str += stringSegment;
      }
      decodeStartPtr = currentBytePtr + 1;
     }
    }
   } else {
    var a = new Array(length);
    for (var i = 0; i < length; ++i) {
     a[i] = String.fromCharCode(HEAPU8[payload + i >>> 0]);
    }
    str = a.join("");
   }
   _free(value);
   return str;
  },
  "toWireType": function(destructors, value) {
   if (value instanceof ArrayBuffer) {
    value = new Uint8Array(value);
   }
   var length;
   var valueIsOfTypeString = typeof value == "string";
   if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) {
    throwBindingError("Cannot pass non-string to std::string");
   }
   if (stdStringIsUTF8 && valueIsOfTypeString) {
    length = lengthBytesUTF8(value);
   } else {
    length = value.length;
   }
   var base = _malloc(8 + length + 1);
   var ptr = base + 8;
   ptr >>>= 0;
   HEAPU64[base / 2 ** 3] = BigInt(length);
   if (stdStringIsUTF8 && valueIsOfTypeString) {
    stringToUTF8(value, ptr, length + 1);
   } else {
    if (valueIsOfTypeString) {
     for (var i = 0; i < length; ++i) {
      var charCode = value.charCodeAt(i);
      if (charCode > 255) {
       _free(ptr);
       throwBindingError("String has UTF-16 code units that do not fit in 8 bits");
      }
      HEAPU8[ptr + i >>> 0] = charCode;
     }
    } else {
     for (var i = 0; i < length; ++i) {
      HEAPU8[ptr + i >>> 0] = value[i];
     }
    }
   }
   if (destructors !== null) {
    destructors.push(_free, base);
   }
   return base;
  },
  "argPackAdvance": 8,
  "readValueFromPointer": simpleReadValueFromPointer,
  destructorFunction: function(ptr) {
   _free(ptr);
  }
 });
}

var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined;

function UTF16ToString(ptr, maxBytesToRead) {
 var endPtr = ptr;
 var idx = endPtr >> 1;
 var maxIdx = idx + maxBytesToRead / 2;
 while (!(idx >= maxIdx) && HEAPU16[idx >>> 0]) ++idx;
 endPtr = idx << 1;
 if (endPtr - ptr > 32 && UTF16Decoder) return UTF16Decoder.decode(HEAPU8.subarray(ptr >>> 0, endPtr >>> 0));
 var str = "";
 for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
  var codeUnit = HEAP16[(ptr + i * 2) / 2 ** 1 >>> 0];
  if (codeUnit == 0) break;
  str += String.fromCharCode(codeUnit);
 }
 return str;
}

function stringToUTF16(str, outPtr, maxBytesToWrite) {
 if (maxBytesToWrite === undefined) {
  maxBytesToWrite = 2147483647;
 }
 if (maxBytesToWrite < 2) return 0;
 maxBytesToWrite -= 2;
 var startPtr = outPtr;
 var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
 for (var i = 0; i < numCharsToWrite; ++i) {
  var codeUnit = str.charCodeAt(i);
  HEAP16[outPtr / 2 ** 1 >>> 0] = codeUnit;
  outPtr += 2;
 }
 HEAP16[outPtr / 2 ** 1 >>> 0] = 0;
 return outPtr - startPtr;
}

function lengthBytesUTF16(str) {
 return str.length * 2;
}

function UTF32ToString(ptr, maxBytesToRead) {
 var i = 0;
 var str = "";
 while (!(i >= maxBytesToRead / 4)) {
  var utf32 = HEAP32[(ptr + i * 4) / 2 ** 2 >>> 0];
  if (utf32 == 0) break;
  ++i;
  if (utf32 >= 65536) {
   var ch = utf32 - 65536;
   str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
  } else {
   str += String.fromCharCode(utf32);
  }
 }
 return str;
}

function stringToUTF32(str, outPtr, maxBytesToWrite) {
 outPtr >>>= 0;
 if (maxBytesToWrite === undefined) {
  maxBytesToWrite = 2147483647;
 }
 if (maxBytesToWrite < 4) return 0;
 var startPtr = outPtr;
 var endPtr = startPtr + maxBytesToWrite - 4;
 for (var i = 0; i < str.length; ++i) {
  var codeUnit = str.charCodeAt(i);
  if (codeUnit >= 55296 && codeUnit <= 57343) {
   var trailSurrogate = str.charCodeAt(++i);
   codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
  }
  HEAP32[outPtr / 2 ** 2 >>> 0] = codeUnit;
  outPtr += 4;
  if (outPtr + 4 > endPtr) break;
 }
 HEAP32[outPtr / 2 ** 2 >>> 0] = 0;
 return outPtr - startPtr;
}

function lengthBytesUTF32(str) {
 var len = 0;
 for (var i = 0; i < str.length; ++i) {
  var codeUnit = str.charCodeAt(i);
  if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
  len += 4;
 }
 return len;
}

function __embind_register_std_wstring(rawType, charSize, name) {
 rawType = Number(rawType);
 charSize = Number(charSize);
 name = Number(name);
 name = readLatin1String(name);
 var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
 if (charSize === 2) {
  decodeString = UTF16ToString;
  encodeString = stringToUTF16;
  lengthBytesUTF = lengthBytesUTF16;
  getHeap = () => HEAPU16;
  shift = 1;
 } else if (charSize === 4) {
  decodeString = UTF32ToString;
  encodeString = stringToUTF32;
  lengthBytesUTF = lengthBytesUTF32;
  getHeap = () => HEAPU32;
  shift = 2;
 }
 registerType(rawType, {
  name: name,
  "fromWireType": function(value) {
   var length = HEAPU32[value >>> 2];
   var HEAP = getHeap();
   var str;
   var decodeStartPtr = value + 4;
   for (var i = 0; i <= length; ++i) {
    var currentBytePtr = value + 4 + i * charSize;
    if (i == length || HEAP[currentBytePtr >>> shift] == 0) {
     var maxReadBytes = currentBytePtr - decodeStartPtr;
     var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
     if (str === undefined) {
      str = stringSegment;
     } else {
      str += String.fromCharCode(0);
      str += stringSegment;
     }
     decodeStartPtr = currentBytePtr + charSize;
    }
   }
   _free(value);
   return str;
  },
  "toWireType": function(destructors, value) {
   if (!(typeof value == "string")) {
    throwBindingError(`Cannot pass non-string to C++ string type ${name}`);
   }
   var length = lengthBytesUTF(value);
   var ptr = _malloc(4 + length + charSize);
   ptr >>>= 0;
   HEAPU32[ptr >>> 2] = length >> shift;
   encodeString(value, ptr + 4, length + charSize);
   if (destructors !== null) {
    destructors.push(_free, ptr);
   }
   return ptr;
  },
  "argPackAdvance": 8,
  "readValueFromPointer": simpleReadValueFromPointer,
  destructorFunction: function(ptr) {
   _free(ptr);
  }
 });
}

function __embind_register_void(rawType, name) {
 rawType = Number(rawType);
 name = Number(name);
 name = readLatin1String(name);
 registerType(rawType, {
  isVoid: true,
  name: name,
  "argPackAdvance": 0,
  "fromWireType": function() {
   return undefined;
  },
  "toWireType": function(destructors, o) {
   return undefined;
  }
 });
}

var nowIsMonotonic = true;

function __emscripten_get_now_is_monotonic() {
 return nowIsMonotonic;
}

function getTypeName(type) {
 var ptr = ___getTypeName(type);
 var rv = readLatin1String(ptr);
 _free(ptr);
 return rv;
}

function requireRegisteredType(rawType, humanName) {
 var impl = registeredTypes[rawType];
 if (undefined === impl) {
  throwBindingError(humanName + " has unknown type " + getTypeName(rawType));
 }
 return impl;
}

function __emval_as(handle, returnType, destructorsRef) {
 handle = Number(handle);
 returnType = Number(returnType);
 destructorsRef = Number(destructorsRef);
 handle = Emval.toValue(handle);
 returnType = requireRegisteredType(returnType, "emval::as");
 var destructors = [];
 var rd = Emval.toHandle(destructors);
 HEAPU64[destructorsRef / 2 ** 3] = BigInt(rd);
 return returnType["toWireType"](destructors, handle);
}

function emval_allocateDestructors(destructorsRef) {
 var destructors = [];
 HEAPU64[destructorsRef / 2 ** 3] = BigInt(Emval.toHandle(destructors));
 return destructors;
}

var emval_symbols = {};

function getStringOrSymbol(address) {
 var symbol = emval_symbols[address];
 if (symbol === undefined) {
  return readLatin1String(address);
 }
 return symbol;
}

var emval_methodCallers = [];

function __emval_call_method(caller, handle, methodName, destructorsRef, args) {
 caller = Number(caller);
 handle = Number(handle);
 methodName = Number(methodName);
 destructorsRef = Number(destructorsRef);
 args = Number(args);
 caller = emval_methodCallers[caller];
 handle = Emval.toValue(handle);
 methodName = getStringOrSymbol(methodName);
 return caller(handle, methodName, emval_allocateDestructors(destructorsRef), args);
}

function __emval_call_void_method(caller, handle, methodName, args) {
 caller = Number(caller);
 handle = Number(handle);
 methodName = Number(methodName);
 args = Number(args);
 caller = emval_methodCallers[caller];
 handle = Emval.toValue(handle);
 methodName = getStringOrSymbol(methodName);
 caller(handle, methodName, null, args);
}

function __emval_equals(first, second) {
 first = Number(first);
 second = Number(second);
 first = Emval.toValue(first);
 second = Emval.toValue(second);
 return first == second;
}

function emval_get_global() {
 if (typeof globalThis == "object") {
  return globalThis;
 }
 return function() {
  return Function;
 }()("return this")();
}

function __emval_get_global(name) {
 var ret = (name => {
  if (name === 0) {
   return Emval.toHandle(emval_get_global());
  } else {
   name = getStringOrSymbol(name);
   return Emval.toHandle(emval_get_global()[name]);
  }
 })(Number(name));
 return BigInt(ret);
}

function emval_addMethodCaller(caller) {
 var id = emval_methodCallers.length;
 emval_methodCallers.push(caller);
 return id;
}

function emval_lookupTypes(argCount, argTypes) {
 var a = new Array(argCount);
 for (var i = 0; i < argCount; ++i) {
  a[i] = requireRegisteredType(Number(HEAPU64[(argTypes + i * 8) / 2 ** 3]), "parameter " + i);
 }
 return a;
}

var emval_registeredMethods = [];

function newFunc(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 __emval_get_method_caller(argCount, argTypes) {
 var ret = ((argCount, argTypes) => {
  var types = emval_lookupTypes(argCount, argTypes);
  var retType = types[0];
  var signatureName = retType.name + "_$" + types.slice(1).map(function(t) {
   return t.name;
  }).join("_") + "$";
  var returnId = emval_registeredMethods[signatureName];
  if (returnId !== undefined) {
   return returnId;
  }
  var params = [ "retType" ];
  var args = [ retType ];
  var argsList = "";
  for (var i = 0; i < argCount - 1; ++i) {
   argsList += (i !== 0 ? ", " : "") + "arg" + i;
   params.push("argType" + i);
   args.push(types[1 + i]);
  }
  var functionName = makeLegalFunctionName("methodCaller_" + signatureName);
  var functionBody = "return function " + functionName + "(handle, name, destructors, args) {\n";
  var offset = 0;
  for (var i = 0; i < argCount - 1; ++i) {
   functionBody += "    var arg" + i + " = argType" + i + ".readValueFromPointer(args" + (offset ? "+" + offset : "") + ");\n";
   offset += types[i + 1]["argPackAdvance"];
  }
  functionBody += "    var rv = handle[name](" + argsList + ");\