@sketch-hq/sketch-web-renderer 12.0.0 → 12.0.1

package/out/web-renderer/web-renderer-release-60255953.js

@@ -0,0 +1,4320 @@
+import { _ as _inherits, a as _createClass, b as _typeof, c as _wrapNativeSuper, d as _classCallCheck, e as _callSuper, f as _createForOfIteratorHelper, g as _slicedToArray } from './index-eb861739.js';
+import 'react';
+
+var WebRendererWasmFactory = function () {
+  var _scriptName = import.meta.url;
+  return function () {
+    var moduleArg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var moduleRtn;
+    var Module = Object.assign({}, moduleArg);
+    var readyPromiseResolve, readyPromiseReject;
+    var readyPromise = new Promise(function (resolve, reject) {
+      readyPromiseResolve = resolve;
+      readyPromiseReject = reject;
+    });
+    var moduleOverrides = Object.assign({}, Module);
+    var thisProgram = "./this.program";
+    var quit_ = function quit_(status, toThrow) {
+      throw toThrow;
+    };
+    var scriptDirectory = "";
+    function locateFile(path) {
+      if (Module["locateFile"]) {
+        return Module["locateFile"](path, scriptDirectory);
+      }
+      return scriptDirectory + path;
+    }
+    {
+      if (typeof document != "undefined" && document.currentScript) {
+        scriptDirectory = document.currentScript.src;
+      }
+      if (_scriptName) {
+        scriptDirectory = _scriptName;
+      }
+      if (scriptDirectory.startsWith("blob:")) {
+        scriptDirectory = "";
+      } else {
+        scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
+      }
+    }
+    var out = Module["print"] || console.log.bind(console);
+    var err = Module["printErr"] || console.error.bind(console);
+    Object.assign(Module, moduleOverrides);
+    moduleOverrides = null;
+    var wasmBinary;
+    var wasmMemory;
+    var ABORT = false;
+    var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPU64, HEAPF64;
+    function updateMemoryViews() {
+      var b = wasmMemory.buffer;
+      HEAP8 = new Int8Array(b);
+      HEAP16 = new Int16Array(b);
+      HEAPU8 = new Uint8Array(b);
+      HEAPU16 = new Uint16Array(b);
+      HEAP32 = new Int32Array(b);
+      HEAPU32 = new Uint32Array(b);
+      HEAPF32 = new Float32Array(b);
+      HEAPF64 = new Float64Array(b);
+      HEAP64 = new BigInt64Array(b);
+      HEAPU64 = new BigUint64Array(b);
+    }
+    var __ATPRERUN__ = [];
+    var __ATINIT__ = [];
+    var __ATPOSTRUN__ = [];
+    function preRun() {
+      callRuntimeCallbacks(__ATPRERUN__);
+    }
+    function initRuntime() {
+      callRuntimeCallbacks(__ATINIT__);
+    }
+    function postRun() {
+      callRuntimeCallbacks(__ATPOSTRUN__);
+    }
+    function addOnInit(cb) {
+      __ATINIT__.unshift(cb);
+    }
+    var runDependencies = 0;
+    var dependenciesFulfilled = null;
+    function addRunDependency(id) {
+      runDependencies++;
+    }
+    function removeRunDependency(id) {
+      runDependencies--;
+      if (runDependencies == 0) {
+        if (dependenciesFulfilled) {
+          var callback = dependenciesFulfilled;
+          dependenciesFulfilled = null;
+          callback();
+        }
+      }
+    }
+    function abort(what) {
+      var _Module$onAbort;
+      (_Module$onAbort = Module["onAbort"]) === null || _Module$onAbort === void 0 || _Module$onAbort.call(Module, what);
+      what = "Aborted(" + what + ")";
+      err(what);
+      ABORT = true;
+      what += ". Build with -sASSERTIONS for more info.";
+      var e = new WebAssembly.RuntimeError(what);
+      readyPromiseReject(e);
+      throw e;
+    }
+    var dataURIPrefix = "data:application/octet-stream;base64,";
+    var isDataURI = function isDataURI(filename) {
+      return filename.startsWith(dataURIPrefix);
+    };
+    function findWasmBinary() {
+      if (Module["locateFile"]) {
+        var f = "web-renderer-release.wasm";
+        if (!isDataURI(f)) {
+          return locateFile(f);
+        }
+        return f;
+      }
+      return new URL("web-renderer-release.wasm", import.meta.url).href;
+    }
+    var wasmBinaryFile;
+    function getBinarySync(file) {
+      if (file == wasmBinaryFile && wasmBinary) {
+        return new Uint8Array(wasmBinary);
+      }
+      throw "both async and sync fetching of the wasm failed";
+    }
+    function getBinaryPromise(binaryFile) {
+      {
+        if (typeof fetch == "function") {
+          return fetch(binaryFile, {
+            credentials: "same-origin"
+          }).then(function (response) {
+            if (!response["ok"]) {
+              throw "failed to load wasm binary file at '".concat(binaryFile, "'");
+            }
+            return response["arrayBuffer"]();
+          })["catch"](function () {
+            return getBinarySync(binaryFile);
+          });
+        }
+      }
+      return Promise.resolve().then(function () {
+        return getBinarySync(binaryFile);
+      });
+    }
+    function instantiateArrayBuffer(binaryFile, imports, receiver) {
+      return getBinaryPromise(binaryFile).then(function (binary) {
+        return WebAssembly.instantiate(binary, imports);
+      }).then(receiver, function (reason) {
+        err("failed to asynchronously prepare wasm: ".concat(reason));
+        abort(reason);
+      });
+    }
+    function instantiateAsync(binary, binaryFile, imports, callback) {
+      if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && typeof fetch == "function") {
+        return fetch(binaryFile, {
+          credentials: "same-origin"
+        }).then(function (response) {
+          var result = WebAssembly.instantiateStreaming(response, imports);
+          return result.then(callback, function (reason) {
+            err("wasm streaming compile failed: ".concat(reason));
+            err("falling back to ArrayBuffer instantiation");
+            return instantiateArrayBuffer(binaryFile, imports, callback);
+          });
+        });
+      }
+      return instantiateArrayBuffer(binaryFile, imports, callback);
+    }
+    function getWasmImports() {
+      return {
+        "a": wasmImports
+      };
+    }
+    function createWasm() {
+      var info = getWasmImports();
+      function receiveInstance(instance, module) {
+        wasmExports = instance.exports;
+        wasmMemory = wasmExports["Tc"];
+        updateMemoryViews();
+        wasmTable = wasmExports["Xc"];
+        addOnInit(wasmExports["Uc"]);
+        removeRunDependency();
+        return wasmExports;
+      }
+      addRunDependency();
+      function receiveInstantiationResult(result) {
+        receiveInstance(result["instance"]);
+      }
+      if (Module["instantiateWasm"]) {
+        try {
+          return Module["instantiateWasm"](info, receiveInstance);
+        } catch (e) {
+          err("Module.instantiateWasm callback failed with error: ".concat(e));
+          readyPromiseReject(e);
+        }
+      }
+      if (!wasmBinaryFile) wasmBinaryFile = findWasmBinary();
+      instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult)["catch"](readyPromiseReject);
+      return {};
+    }
+    function ExitStatus(status) {
+      this.name = "ExitStatus";
+      this.message = "Program terminated with exit(".concat(status, ")");
+      this.status = status;
+    }
+    var callRuntimeCallbacks = function callRuntimeCallbacks(callbacks) {
+      while (callbacks.length > 0) {
+        callbacks.shift()(Module);
+      }
+    };
+    var noExitRuntime = Module["noExitRuntime"] || true;
+    var stackRestore = function stackRestore(val) {
+      return _emscripten_stack_restore(val);
+    };
+    var stackSave = function stackSave() {
+      return _emscripten_stack_get_current2();
+    };
+    var __abort_js = function __abort_js() {
+      abort("");
+    };
+    var structRegistrations = {};
+    var runDestructors = function runDestructors(destructors) {
+      while (destructors.length) {
+        var ptr = destructors.pop();
+        var del = destructors.pop();
+        del(ptr);
+      }
+    };
+    function readPointer(pointer) {
+      return this["fromWireType"](HEAPU32[pointer >> 2]);
+    }
+    var awaitingDependencies = {};
+    var registeredTypes = {};
+    var typeDependencies = {};
+    var InternalError;
+    var throwInternalError = function throwInternalError(message) {
+      throw new InternalError(message);
+    };
+    var whenDependentTypesAreResolved = 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);
+      }
+    };
+    var __embind_finalize_value_object = 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 read(ptr) {
+              return getterReturnType["fromWireType"](getter(getterContext, ptr));
+            },
+            write: function write(ptr, o) {
+              var destructors = [];
+              setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o));
+              runDestructors(destructors);
+            }
+          };
+        });
+        return [{
+          name: reg.name,
+          "fromWireType": function fromWireType(ptr) {
+            var rv = {};
+            for (var i in fields) {
+              rv[i] = fields[i].read(ptr);
+            }
+            rawDestructor(ptr);
+            return rv;
+          },
+          "toWireType": function toWireType(destructors, o) {
+            for (var fieldName in fields) {
+              if (!(fieldName in o)) {
+                throw new TypeError("Missing field: \"".concat(fieldName, "\""));
+              }
+            }
+            var ptr = rawConstructor();
+            for (fieldName in fields) {
+              fields[fieldName].write(ptr, o[fieldName]);
+            }
+            if (destructors !== null) {
+              destructors.push(rawDestructor, ptr);
+            }
+            return ptr;
+          },
+          "argPackAdvance": GenericWireTypeSize,
+          "readValueFromPointer": readPointer,
+          destructorFunction: rawDestructor
+        }];
+      });
+    };
+    var embindRepr = 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;
+      }
+    };
+    var embind_init_charCodes = 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;
+    var readLatin1String = function readLatin1String(ptr) {
+      var ret = "";
+      var c = ptr;
+      while (HEAPU8[c]) {
+        ret += embind_charCodes[HEAPU8[c++]];
+      }
+      return ret;
+    };
+    var BindingError;
+    var throwBindingError = function throwBindingError(message) {
+      throw new BindingError(message);
+    };
+    function sharedRegisterType(rawType, registeredInstance) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var name = registeredInstance.name;
+      if (!rawType) {
+        throwBindingError("type \"".concat(name, "\" must have a positive integer typeid pointer"));
+      }
+      if (registeredTypes.hasOwnProperty(rawType)) {
+        if (options.ignoreDuplicateRegistrations) {
+          return;
+        } else {
+          throwBindingError("Cannot register type '".concat(name, "' twice"));
+        }
+      }
+      registeredTypes[rawType] = registeredInstance;
+      delete typeDependencies[rawType];
+      if (awaitingDependencies.hasOwnProperty(rawType)) {
+        var callbacks = awaitingDependencies[rawType];
+        delete awaitingDependencies[rawType];
+        callbacks.forEach(function (cb) {
+          return cb();
+        });
+      }
+    }
+    function registerType(rawType, registeredInstance) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      if (!("argPackAdvance" in registeredInstance)) {
+        throw new TypeError("registerType registeredInstance requires argPackAdvance");
+      }
+      return sharedRegisterType(rawType, registeredInstance, options);
+    }
+    var integerReadValueFromPointer = function integerReadValueFromPointer(name, width, signed) {
+      switch (width) {
+        case 1:
+          return signed ? function (pointer) {
+            return HEAP8[pointer];
+          } : function (pointer) {
+            return HEAPU8[pointer];
+          };
+        case 2:
+          return signed ? function (pointer) {
+            return HEAP16[pointer >> 1];
+          } : function (pointer) {
+            return HEAPU16[pointer >> 1];
+          };
+        case 4:
+          return signed ? function (pointer) {
+            return HEAP32[pointer >> 2];
+          } : function (pointer) {
+            return HEAPU32[pointer >> 2];
+          };
+        case 8:
+          return signed ? function (pointer) {
+            return HEAP64[pointer >> 3];
+          } : function (pointer) {
+            return HEAPU64[pointer >> 3];
+          };
+        default:
+          throw new TypeError("invalid integer width (".concat(width, "): ").concat(name));
+      }
+    };
+    var __embind_register_bigint = function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {
+      name = readLatin1String(name);
+      var isUnsignedType = name.indexOf("u") != -1;
+      registerType(primitiveType, {
+        name: name,
+        "fromWireType": function fromWireType(value) {
+          return value;
+        },
+        "toWireType": function toWireType(destructors, value) {
+          if (typeof value != "bigint" && typeof value != "number") {
+            throw new TypeError("Cannot convert \"".concat(embindRepr(value), "\" to ").concat(this.name));
+          }
+          if (typeof value == "number") {
+            value = BigInt(value);
+          }
+          return value;
+        },
+        "argPackAdvance": GenericWireTypeSize,
+        "readValueFromPointer": integerReadValueFromPointer(name, size, !isUnsignedType),
+        destructorFunction: null
+      });
+    };
+    var GenericWireTypeSize = 8;
+    var __embind_register_bool = function __embind_register_bool(rawType, name, trueValue, falseValue) {
+      name = readLatin1String(name);
+      registerType(rawType, {
+        name: name,
+        "fromWireType": function fromWireType(wt) {
+          return !!wt;
+        },
+        "toWireType": function toWireType(destructors, o) {
+          return o ? trueValue : falseValue;
+        },
+        "argPackAdvance": GenericWireTypeSize,
+        "readValueFromPointer": function readValueFromPointer(pointer) {
+          return this["fromWireType"](HEAPU8[pointer]);
+        },
+        destructorFunction: null
+      });
+    };
+    var shallowCopyInternalPointer = function shallowCopyInternalPointer(o) {
+      return {
+        count: o.count,
+        deleteScheduled: o.deleteScheduled,
+        preservePointerOnDelete: o.preservePointerOnDelete,
+        ptr: o.ptr,
+        ptrType: o.ptrType,
+        smartPtr: o.smartPtr,
+        smartPtrType: o.smartPtrType
+      };
+    };
+    var throwInstanceAlreadyDeleted = function throwInstanceAlreadyDeleted(obj) {
+      function getInstanceTypeName(handle) {
+        return handle.$$.ptrType.registeredClass.name;
+      }
+      throwBindingError(getInstanceTypeName(obj) + " instance already deleted");
+    };
+    var finalizationRegistry = false;
+    var detachFinalizer = function detachFinalizer(handle) {};
+    var runDestructor = function runDestructor($$) {
+      if ($$.smartPtr) {
+        $$.smartPtrType.rawDestructor($$.smartPtr);
+      } else {
+        $$.ptrType.registeredClass.rawDestructor($$.ptr);
+      }
+    };
+    var releaseClassHandle = function releaseClassHandle($$) {
+      $$.count.value -= 1;
+      var toDelete = 0 === $$.count.value;
+      if (toDelete) {
+        runDestructor($$);
+      }
+    };
+    var _downcastPointer = function downcastPointer(ptr, ptrClass, desiredClass) {
+      if (ptrClass === desiredClass) {
+        return ptr;
+      }
+      if (undefined === desiredClass.baseClass) {
+        return null;
+      }
+      var rv = _downcastPointer(ptr, ptrClass, desiredClass.baseClass);
+      if (rv === null) {
+        return null;
+      }
+      return desiredClass.downcast(rv);
+    };
+    var registeredPointers = {};
+    var getInheritedInstanceCount = function getInheritedInstanceCount() {
+      return Object.keys(registeredInstances).length;
+    };
+    var getLiveInheritedInstances = function getLiveInheritedInstances() {
+      var rv = [];
+      for (var k in registeredInstances) {
+        if (registeredInstances.hasOwnProperty(k)) {
+          rv.push(registeredInstances[k]);
+        }
+      }
+      return rv;
+    };
+    var deletionQueue = [];
+    var flushPendingDeletes = function flushPendingDeletes() {
+      while (deletionQueue.length) {
+        var obj = deletionQueue.pop();
+        obj.$$.deleteScheduled = false;
+        obj["delete"]();
+      }
+    };
+    var delayFunction;
+    var setDelayFunction = function setDelayFunction(fn) {
+      delayFunction = fn;
+      if (deletionQueue.length && delayFunction) {
+        delayFunction(flushPendingDeletes);
+      }
+    };
+    var init_embind = function init_embind() {
+      Module["getInheritedInstanceCount"] = getInheritedInstanceCount;
+      Module["getLiveInheritedInstances"] = getLiveInheritedInstances;
+      Module["flushPendingDeletes"] = flushPendingDeletes;
+      Module["setDelayFunction"] = setDelayFunction;
+    };
+    var registeredInstances = {};
+    var getBasestPointer = function getBasestPointer(class_, ptr) {
+      if (ptr === undefined) {
+        throwBindingError("ptr should not be undefined");
+      }
+      while (class_.baseClass) {
+        ptr = class_.upcast(ptr);
+        class_ = class_.baseClass;
+      }
+      return ptr;
+    };
+    var getInheritedInstance = function getInheritedInstance(class_, ptr) {
+      ptr = getBasestPointer(class_, ptr);
+      return registeredInstances[ptr];
+    };
+    var makeClassHandle = function makeClassHandle(prototype, record) {
+      if (!record.ptrType || !record.ptr) {
+        throwInternalError("makeClassHandle requires ptr and ptrType");
+      }
+      var hasSmartPtrType = !!record.smartPtrType;
+      var hasSmartPtr = !!record.smartPtr;
+      if (hasSmartPtrType !== hasSmartPtr) {
+        throwInternalError("Both smartPtrType and smartPtr must be specified");
+      }
+      record.count = {
+        value: 1
+      };
+      return _attachFinalizer(Object.create(prototype, {
+        $$: {
+          value: record,
+          writable: true
+        }
+      }));
+    };
+    function RegisteredPointer_fromWireType(ptr) {
+      var rawPointer = this.getPointee(ptr);
+      if (!rawPointer) {
+        this.destructor(ptr);
+        return null;
+      }
+      var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);
+      if (undefined !== registeredInstance) {
+        if (0 === registeredInstance.$$.count.value) {
+          registeredInstance.$$.ptr = rawPointer;
+          registeredInstance.$$.smartPtr = ptr;
+          return registeredInstance["clone"]();
+        } else {
+          var rv = registeredInstance["clone"]();
+          this.destructor(ptr);
+          return rv;
+        }
+      }
+      function makeDefaultHandle() {
+        if (this.isSmartPointer) {
+          return makeClassHandle(this.registeredClass.instancePrototype, {
+            ptrType: this.pointeeType,
+            ptr: rawPointer,
+            smartPtrType: this,
+            smartPtr: ptr
+          });
+        } else {
+          return makeClassHandle(this.registeredClass.instancePrototype, {
+            ptrType: this,
+            ptr: ptr
+          });
+        }
+      }
+      var actualType = this.registeredClass.getActualType(rawPointer);
+      var registeredPointerRecord = registeredPointers[actualType];
+      if (!registeredPointerRecord) {
+        return makeDefaultHandle.call(this);
+      }
+      var toType;
+      if (this.isConst) {
+        toType = registeredPointerRecord.constPointerType;
+      } else {
+        toType = registeredPointerRecord.pointerType;
+      }
+      var dp = _downcastPointer(rawPointer, this.registeredClass, toType.registeredClass);
+      if (dp === null) {
+        return makeDefaultHandle.call(this);
+      }
+      if (this.isSmartPointer) {
+        return makeClassHandle(toType.registeredClass.instancePrototype, {
+          ptrType: toType,
+          ptr: dp,
+          smartPtrType: this,
+          smartPtr: ptr
+        });
+      } else {
+        return makeClassHandle(toType.registeredClass.instancePrototype, {
+          ptrType: toType,
+          ptr: dp
+        });
+      }
+    }
+    var _attachFinalizer = function attachFinalizer(handle) {
+      if ("undefined" === typeof FinalizationRegistry) {
+        _attachFinalizer = function attachFinalizer(handle) {
+          return handle;
+        };
+        return handle;
+      }
+      finalizationRegistry = new FinalizationRegistry(function (info) {
+        releaseClassHandle(info.$$);
+      });
+      _attachFinalizer = function attachFinalizer(handle) {
+        var $$ = handle.$$;
+        var hasSmartPtr = !!$$.smartPtr;
+        if (hasSmartPtr) {
+          var info = {
+            $$: $$
+          };
+          finalizationRegistry.register(handle, info, handle);
+        }
+        return handle;
+      };
+      detachFinalizer = function detachFinalizer(handle) {
+        return finalizationRegistry.unregister(handle);
+      };
+      return _attachFinalizer(handle);
+    };
+    var init_ClassHandle = function init_ClassHandle() {
+      Object.assign(ClassHandle.prototype, {
+        "isAliasOf": function isAliasOf(other) {
+          if (!(this instanceof ClassHandle)) {
+            return false;
+          }
+          if (!(other instanceof ClassHandle)) {
+            return false;
+          }
+          var leftClass = this.$$.ptrType.registeredClass;
+          var left = this.$$.ptr;
+          other.$$ = other.$$;
+          var rightClass = other.$$.ptrType.registeredClass;
+          var right = other.$$.ptr;
+          while (leftClass.baseClass) {
+            left = leftClass.upcast(left);
+            leftClass = leftClass.baseClass;
+          }
+          while (rightClass.baseClass) {
+            right = rightClass.upcast(right);
+            rightClass = rightClass.baseClass;
+          }
+          return leftClass === rightClass && left === right;
+        },
+        "clone": function clone() {
+          if (!this.$$.ptr) {
+            throwInstanceAlreadyDeleted(this);
+          }
+          if (this.$$.preservePointerOnDelete) {
+            this.$$.count.value += 1;
+            return this;
+          } else {
+            var clone = _attachFinalizer(Object.create(Object.getPrototypeOf(this), {
+              $$: {
+                value: shallowCopyInternalPointer(this.$$)
+              }
+            }));
+            clone.$$.count.value += 1;
+            clone.$$.deleteScheduled = false;
+            return clone;
+          }
+        },
+        "delete": function _delete() {
+          if (!this.$$.ptr) {
+            throwInstanceAlreadyDeleted(this);
+          }
+          if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
+            throwBindingError("Object already scheduled for deletion");
+          }
+          detachFinalizer(this);
+          releaseClassHandle(this.$$);
+          if (!this.$$.preservePointerOnDelete) {
+            this.$$.smartPtr = undefined;
+            this.$$.ptr = undefined;
+          }
+        },
+        "isDeleted": function isDeleted() {
+          return !this.$$.ptr;
+        },
+        "deleteLater": function deleteLater() {
+          if (!this.$$.ptr) {
+            throwInstanceAlreadyDeleted(this);
+          }
+          if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
+            throwBindingError("Object already scheduled for deletion");
+          }
+          deletionQueue.push(this);
+          if (deletionQueue.length === 1 && delayFunction) {
+            delayFunction(flushPendingDeletes);
+          }
+          this.$$.deleteScheduled = true;
+          return this;
+        }
+      });
+    };
+    function ClassHandle() {}
+    var createNamedFunction = function createNamedFunction(name, body) {
+      return Object.defineProperty(body, "name", {
+        value: name
+      });
+    };
+    var ensureOverloadTable = function ensureOverloadTable(proto, methodName, humanName) {
+      if (undefined === proto[methodName].overloadTable) {
+        var prevFunc = proto[methodName];
+        proto[methodName] = function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) {
+            throwBindingError("Function '".concat(humanName, "' called with an invalid number of arguments (").concat(args.length, ") - expects one of (").concat(proto[methodName].overloadTable, ")!"));
+          }
+          return proto[methodName].overloadTable[args.length].apply(this, args);
+        };
+        proto[methodName].overloadTable = [];
+        proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
+      }
+    };
+    var exposePublicSymbol = 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 '".concat(name, "' twice"));
+        }
+        ensureOverloadTable(Module, name, name);
+        if (Module.hasOwnProperty(numArguments)) {
+          throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (".concat(numArguments, ")!"));
+        }
+        Module[name].overloadTable[numArguments] = value;
+      } else {
+        Module[name] = value;
+        if (undefined !== numArguments) {
+          Module[name].numArguments = numArguments;
+        }
+      }
+    };
+    var char_0 = 48;
+    var char_9 = 57;
+    var makeLegalFunctionName = 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 "_".concat(name);
+      }
+      return name;
+    };
+    function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) {
+      this.name = name;
+      this.constructor = constructor;
+      this.instancePrototype = instancePrototype;
+      this.rawDestructor = rawDestructor;
+      this.baseClass = baseClass;
+      this.getActualType = getActualType;
+      this.upcast = upcast;
+      this.downcast = downcast;
+      this.pureVirtualFunctions = [];
+    }
+    var upcastPointer = function upcastPointer(ptr, ptrClass, desiredClass) {
+      while (ptrClass !== desiredClass) {
+        if (!ptrClass.upcast) {
+          throwBindingError("Expected null or instance of ".concat(desiredClass.name, ", got an instance of ").concat(ptrClass.name));
+        }
+        ptr = ptrClass.upcast(ptr);
+        ptrClass = ptrClass.baseClass;
+      }
+      return ptr;
+    };
+    function constNoSmartPtrRawPointerToWireType(destructors, handle) {
+      if (handle === null) {
+        if (this.isReference) {
+          throwBindingError("null is not a valid ".concat(this.name));
+        }
+        return 0;
+      }
+      if (!handle.$$) {
+        throwBindingError("Cannot pass \"".concat(embindRepr(handle), "\" as a ").concat(this.name));
+      }
+      if (!handle.$$.ptr) {
+        throwBindingError("Cannot pass deleted object as a pointer of type ".concat(this.name));
+      }
+      var handleClass = handle.$$.ptrType.registeredClass;
+      var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+      return ptr;
+    }
+    function genericPointerToWireType(destructors, handle) {
+      var ptr;
+      if (handle === null) {
+        if (this.isReference) {
+          throwBindingError("null is not a valid ".concat(this.name));
+        }
+        if (this.isSmartPointer) {
+          ptr = this.rawConstructor();
+          if (destructors !== null) {
+            destructors.push(this.rawDestructor, ptr);
+          }
+          return ptr;
+        } else {
+          return 0;
+        }
+      }
+      if (!handle || !handle.$$) {
+        throwBindingError("Cannot pass \"".concat(embindRepr(handle), "\" as a ").concat(this.name));
+      }
+      if (!handle.$$.ptr) {
+        throwBindingError("Cannot pass deleted object as a pointer of type ".concat(this.name));
+      }
+      if (!this.isConst && handle.$$.ptrType.isConst) {
+        throwBindingError("Cannot convert argument of type ".concat(handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name, " to parameter type ").concat(this.name));
+      }
+      var handleClass = handle.$$.ptrType.registeredClass;
+      ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+      if (this.isSmartPointer) {
+        if (undefined === handle.$$.smartPtr) {
+          throwBindingError("Passing raw pointer to smart pointer is illegal");
+        }
+        switch (this.sharingPolicy) {
+          case 0:
+            if (handle.$$.smartPtrType === this) {
+              ptr = handle.$$.smartPtr;
+            } else {
+              throwBindingError("Cannot convert argument of type ".concat(handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name, " to parameter type ").concat(this.name));
+            }
+            break;
+          case 1:
+            ptr = handle.$$.smartPtr;
+            break;
+          case 2:
+            if (handle.$$.smartPtrType === this) {
+              ptr = handle.$$.smartPtr;
+            } else {
+              var clonedHandle = handle["clone"]();
+              ptr = this.rawShare(ptr, Emval.toHandle(function () {
+                return clonedHandle["delete"]();
+              }));
+              if (destructors !== null) {
+                destructors.push(this.rawDestructor, ptr);
+              }
+            }
+            break;
+          default:
+            throwBindingError("Unsupporting sharing policy");
+        }
+      }
+      return ptr;
+    }
+    function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
+      if (handle === null) {
+        if (this.isReference) {
+          throwBindingError("null is not a valid ".concat(this.name));
+        }
+        return 0;
+      }
+      if (!handle.$$) {
+        throwBindingError("Cannot pass \"".concat(embindRepr(handle), "\" as a ").concat(this.name));
+      }
+      if (!handle.$$.ptr) {
+        throwBindingError("Cannot pass deleted object as a pointer of type ".concat(this.name));
+      }
+      if (handle.$$.ptrType.isConst) {
+        throwBindingError("Cannot convert argument of type ".concat(handle.$$.ptrType.name, " to parameter type ").concat(this.name));
+      }
+      var handleClass = handle.$$.ptrType.registeredClass;
+      var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+      return ptr;
+    }
+    var init_RegisteredPointer = function init_RegisteredPointer() {
+      Object.assign(RegisteredPointer.prototype, {
+        getPointee: function getPointee(ptr) {
+          if (this.rawGetPointee) {
+            ptr = this.rawGetPointee(ptr);
+          }
+          return ptr;
+        },
+        destructor: function destructor(ptr) {
+          var _this$rawDestructor;
+          (_this$rawDestructor = this.rawDestructor) === null || _this$rawDestructor === void 0 || _this$rawDestructor.call(this, ptr);
+        },
+        "argPackAdvance": GenericWireTypeSize,
+        "readValueFromPointer": readPointer,
+        "fromWireType": RegisteredPointer_fromWireType
+      });
+    };
+    function RegisteredPointer(name, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) {
+      this.name = name;
+      this.registeredClass = registeredClass;
+      this.isReference = isReference;
+      this.isConst = isConst;
+      this.isSmartPointer = isSmartPointer;
+      this.pointeeType = pointeeType;
+      this.sharingPolicy = sharingPolicy;
+      this.rawGetPointee = rawGetPointee;
+      this.rawConstructor = rawConstructor;
+      this.rawShare = rawShare;
+      this.rawDestructor = rawDestructor;
+      if (!isSmartPointer && registeredClass.baseClass === undefined) {
+        if (isConst) {
+          this["toWireType"] = constNoSmartPtrRawPointerToWireType;
+          this.destructorFunction = null;
+        } else {
+          this["toWireType"] = nonConstNoSmartPtrRawPointerToWireType;
+          this.destructorFunction = null;
+        }
+      } else {
+        this["toWireType"] = genericPointerToWireType;
+      }
+    }
+    var replacePublicSymbol = function replacePublicSymbol(name, value, numArguments) {
+      if (!Module.hasOwnProperty(name)) {
+        throwInternalError("Replacing nonexistent public symbol");
+      }
+      if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
+        Module[name].overloadTable[numArguments] = value;
+      } else {
+        Module[name] = value;
+        Module[name].argCount = numArguments;
+      }
+    };
+    var wasmTableMirror = [];
+    var wasmTable;
+    var getWasmTableEntry = function getWasmTableEntry(funcPtr) {
+      var func = wasmTableMirror[funcPtr];
+      if (!func) {
+        if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
+        wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
+      }
+      return func;
+    };
+    var embind__requireFunction = function embind__requireFunction(signature, rawFunction) {
+      signature = readLatin1String(signature);
+      function makeDynCaller() {
+        return getWasmTableEntry(rawFunction);
+      }
+      var fp = makeDynCaller();
+      if (typeof fp != "function") {
+        throwBindingError("unknown function pointer with signature ".concat(signature, ": ").concat(rawFunction));
+      }
+      return fp;
+    };
+    var extendError = 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 "".concat(this.name, ": ").concat(this.message);
+        }
+      };
+      return errorClass;
+    };
+    var UnboundTypeError;
+    var getTypeName = function getTypeName(type) {
+      var ptr = _getTypeName(type);
+      var rv = readLatin1String(ptr);
+      _free(ptr);
+      return rv;
+    };
+    var throwUnboundTypeError = 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("".concat(message, ": ") + unboundTypes.map(getTypeName).join([", "]));
+    };
+    var __embind_register_class = function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) {
+      name = readLatin1String(name);
+      getActualType = embind__requireFunction(getActualTypeSignature, getActualType);
+      upcast && (upcast = embind__requireFunction(upcastSignature, upcast));
+      downcast && (downcast = embind__requireFunction(downcastSignature, downcast));
+      rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
+      var legalFunctionName = makeLegalFunctionName(name);
+      exposePublicSymbol(legalFunctionName, function () {
+        throwUnboundTypeError("Cannot construct ".concat(name, " due to unbound types"), [baseClassRawType]);
+      });
+      whenDependentTypesAreResolved([rawType, rawPointerType, rawConstPointerType], baseClassRawType ? [baseClassRawType] : [], function (base) {
+        base = base[0];
+        var baseClass;
+        var basePrototype;
+        if (baseClassRawType) {
+          baseClass = base.registeredClass;
+          basePrototype = baseClass.instancePrototype;
+        } else {
+          basePrototype = ClassHandle.prototype;
+        }
+        var constructor = createNamedFunction(name, function () {
+          if (Object.getPrototypeOf(this) !== instancePrototype) {
+            throw new BindingError("Use 'new' to construct " + name);
+          }
+          if (undefined === registeredClass.constructor_body) {
+            throw new BindingError(name + " has no accessible constructor");
+          }
+          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = arguments[_key2];
+          }
+          var body = registeredClass.constructor_body[args.length];
+          if (undefined === body) {
+            throw new BindingError("Tried to invoke ctor of ".concat(name, " with invalid number of parameters (").concat(args.length, ") - expected (").concat(Object.keys(registeredClass.constructor_body).toString(), ") parameters instead!"));
+          }
+          return body.apply(this, args);
+        });
+        var instancePrototype = Object.create(basePrototype, {
+          constructor: {
+            value: constructor
+          }
+        });
+        constructor.prototype = instancePrototype;
+        var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast);
+        if (registeredClass.baseClass) {
+          var _registeredClass$base, _registeredClass$base2;
+          (_registeredClass$base2 = (_registeredClass$base = registeredClass.baseClass).__derivedClasses) !== null && _registeredClass$base2 !== void 0 ? _registeredClass$base2 : _registeredClass$base.__derivedClasses = [];
+          registeredClass.baseClass.__derivedClasses.push(registeredClass);
+        }
+        var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false);
+        var pointerConverter = new RegisteredPointer(name + "*", registeredClass, false, false, false);
+        var constPointerConverter = new RegisteredPointer(name + " const*", registeredClass, false, true, false);
+        registeredPointers[rawType] = {
+          pointerType: pointerConverter,
+          constPointerType: constPointerConverter
+        };
+        replacePublicSymbol(legalFunctionName, constructor);
+        return [referenceConverter, pointerConverter, constPointerConverter];
+      });
+    };
+    function usesDestructorStack(argTypes) {
+      for (var i = 1; i < argTypes.length; ++i) {
+        if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function newFunc(constructor, argumentList) {
+      if (!(constructor instanceof Function)) {
+        throw new TypeError("new_ called with constructor type ".concat(_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 createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) {
+      var needsDestructorStack = usesDestructorStack(argTypes);
+      var argCount = argTypes.length;
+      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 = "\n        return function (".concat(argsList, ") {\n        if (arguments.length !== ").concat(argCount - 2, ") {\n          throwBindingError('function ' + humanName + ' called with ' + arguments.length + ' arguments, expected ").concat(argCount - 2, "');\n        }");
+      if (needsDestructorStack) {
+        invokerFnBody += "var destructors = [];\n";
+      }
+      var dtorStack = needsDestructorStack ? "destructors" : "null";
+      var args1 = ["humanName", "throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"];
+      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 + ");\n";
+        args1.push("argType" + i);
+      }
+      if (isClassMethodFunc) {
+        argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired;
+      }
+      invokerFnBody += (returns || isAsync ? "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 += "".concat(paramName, "_dtor(").concat(paramName, ");\n");
+            args1.push("".concat(paramName, "_dtor"));
+          }
+        }
+      }
+      if (returns) {
+        invokerFnBody += "var ret = retType['fromWireType'](rv);\n" + "return ret;\n";
+      }
+      invokerFnBody += "}\n";
+      return [args1, invokerFnBody];
+    }
+    function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, isAsync) {
+      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 = usesDestructorStack(argTypes);
+      var returns = argTypes[0].name !== "void";
+      var closureArgs = [humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];
+      for (var i = 0; i < argCount - 2; ++i) {
+        closureArgs.push(argTypes[i + 2]);
+      }
+      if (!needsDestructorStack) {
+        for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
+          if (argTypes[i].destructorFunction !== null) {
+            closureArgs.push(argTypes[i].destructorFunction);
+          }
+        }
+      }
+      var _createJsInvoker = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync),
+        _createJsInvoker2 = _slicedToArray(_createJsInvoker, 2),
+        args = _createJsInvoker2[0],
+        invokerFnBody = _createJsInvoker2[1];
+      args.push(invokerFnBody);
+      var invokerFn = newFunc(Function, args).apply(void 0, closureArgs);
+      return createNamedFunction(humanName, invokerFn);
+    }
+    var heap32VectorToArray = function heap32VectorToArray(count, firstElement) {
+      var array = [];
+      for (var i = 0; i < count; i++) {
+        array.push(HEAPU32[firstElement + i * 4 >> 2]);
+      }
+      return array;
+    };
+    var getFunctionName = function getFunctionName(signature) {
+      signature = signature.trim();
+      var argsIndex = signature.indexOf("(");
+      if (argsIndex !== -1) {
+        return signature.substr(0, argsIndex);
+      } else {
+        return signature;
+      }
+    };
+    var __embind_register_class_class_function = function __embind_register_class_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, fn, isAsync) {
+      var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+      methodName = readLatin1String(methodName);
+      methodName = getFunctionName(methodName);
+      rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
+      whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+        classType = classType[0];
+        var humanName = "".concat(classType.name, ".").concat(methodName);
+        function unboundTypesHandler() {
+          throwUnboundTypeError("Cannot call ".concat(humanName, " due to unbound types"), rawArgTypes);
+        }
+        if (methodName.startsWith("@@")) {
+          methodName = Symbol[methodName.substring(2)];
+        }
+        var proto = classType.registeredClass.constructor;
+        if (undefined === proto[methodName]) {
+          unboundTypesHandler.argCount = argCount - 1;
+          proto[methodName] = unboundTypesHandler;
+        } else {
+          ensureOverloadTable(proto, methodName, humanName);
+          proto[methodName].overloadTable[argCount - 1] = unboundTypesHandler;
+        }
+        whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+          var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1));
+          var func = craftInvokerFunction(humanName, invokerArgsArray, null, rawInvoker, fn, isAsync);
+          if (undefined === proto[methodName].overloadTable) {
+            func.argCount = argCount - 1;
+            proto[methodName] = func;
+          } else {
+            proto[methodName].overloadTable[argCount - 1] = func;
+          }
+          if (classType.registeredClass.__derivedClasses) {
+            var _iterator = _createForOfIteratorHelper(classType.registeredClass.__derivedClasses),
+              _step;
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var derivedClass = _step.value;
+                if (!derivedClass.constructor.hasOwnProperty(methodName)) {
+                  derivedClass.constructor[methodName] = func;
+                }
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+          }
+          return [];
+        });
+        return [];
+      });
+    };
+    var __embind_register_class_constructor = function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) {
+      var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+      invoker = embind__requireFunction(invokerSignature, invoker);
+      whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+        classType = classType[0];
+        var humanName = "constructor ".concat(classType.name);
+        if (undefined === classType.registeredClass.constructor_body) {
+          classType.registeredClass.constructor_body = [];
+        }
+        if (undefined !== classType.registeredClass.constructor_body[argCount - 1]) {
+          throw new BindingError("Cannot register multiple constructors with identical number of parameters (".concat(argCount - 1, ") for class '").concat(classType.name, "'! Overload resolution is currently only performed using the parameter count, not actual type info!"));
+        }
+        classType.registeredClass.constructor_body[argCount - 1] = function () {
+          throwUnboundTypeError("Cannot construct ".concat(classType.name, " due to unbound types"), rawArgTypes);
+        };
+        whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+          argTypes.splice(1, 0, null);
+          classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor);
+          return [];
+        });
+        return [];
+      });
+    };
+    var __embind_register_class_function = function __embind_register_class_function(rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, context, isPureVirtual, isAsync) {
+      var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+      methodName = readLatin1String(methodName);
+      methodName = getFunctionName(methodName);
+      rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
+      whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+        classType = classType[0];
+        var humanName = "".concat(classType.name, ".").concat(methodName);
+        if (methodName.startsWith("@@")) {
+          methodName = Symbol[methodName.substring(2)];
+        }
+        if (isPureVirtual) {
+          classType.registeredClass.pureVirtualFunctions.push(methodName);
+        }
+        function unboundTypesHandler() {
+          throwUnboundTypeError("Cannot call ".concat(humanName, " due to unbound types"), rawArgTypes);
+        }
+        var proto = classType.registeredClass.instancePrototype;
+        var method = proto[methodName];
+        if (undefined === method || undefined === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2) {
+          unboundTypesHandler.argCount = argCount - 2;
+          unboundTypesHandler.className = classType.name;
+          proto[methodName] = unboundTypesHandler;
+        } else {
+          ensureOverloadTable(proto, methodName, humanName);
+          proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;
+        }
+        whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+          var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context, isAsync);
+          if (undefined === proto[methodName].overloadTable) {
+            memberFunction.argCount = argCount - 2;
+            proto[methodName] = memberFunction;
+          } else {
+            proto[methodName].overloadTable[argCount - 2] = memberFunction;
+          }
+          return [];
+        });
+        return [];
+      });
+    };
+    var validateThis = function validateThis(this_, classType, humanName) {
+      if (!(this_ instanceof Object)) {
+        throwBindingError("".concat(humanName, " with invalid \"this\": ").concat(this_));
+      }
+      if (!(this_ instanceof classType.registeredClass.constructor)) {
+        throwBindingError("".concat(humanName, " incompatible with \"this\" of type ").concat(this_.constructor.name));
+      }
+      if (!this_.$$.ptr) {
+        throwBindingError("cannot call emscripten binding method ".concat(humanName, " on deleted object"));
+      }
+      return upcastPointer(this_.$$.ptr, this_.$$.ptrType.registeredClass, classType.registeredClass);
+    };
+    var __embind_register_class_property = function __embind_register_class_property(classType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
+      fieldName = readLatin1String(fieldName);
+      getter = embind__requireFunction(getterSignature, getter);
+      whenDependentTypesAreResolved([], [classType], function (classType) {
+        classType = classType[0];
+        var humanName = "".concat(classType.name, ".").concat(fieldName);
+        var desc = {
+          get: function get() {
+            throwUnboundTypeError("Cannot access ".concat(humanName, " due to unbound types"), [getterReturnType, setterArgumentType]);
+          },
+          enumerable: true,
+          configurable: true
+        };
+        if (setter) {
+          desc.set = function () {
+            return throwUnboundTypeError("Cannot access ".concat(humanName, " due to unbound types"), [getterReturnType, setterArgumentType]);
+          };
+        } else {
+          desc.set = function (v) {
+            return throwBindingError(humanName + " is a read-only property");
+          };
+        }
+        Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc);
+        whenDependentTypesAreResolved([], setter ? [getterReturnType, setterArgumentType] : [getterReturnType], function (types) {
+          var getterReturnType = types[0];
+          var desc = {
+            get: function get() {
+              var ptr = validateThis(this, classType, humanName + " getter");
+              return getterReturnType["fromWireType"](getter(getterContext, ptr));
+            },
+            enumerable: true
+          };
+          if (setter) {
+            setter = embind__requireFunction(setterSignature, setter);
+            var setterArgumentType = types[1];
+            desc.set = function (v) {
+              var ptr = validateThis(this, classType, humanName + " setter");
+              var destructors = [];
+              setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, v));
+              runDestructors(destructors);
+            };
+          }
+          Object.defineProperty(classType.registeredClass.instancePrototype, fieldName, desc);
+          return [];
+        });
+        return [];
+      });
+    };
+    var emval_freelist = [];
+    var emval_handles = [];
+    var __emval_decref = function __emval_decref(handle) {
+      if (handle > 9 && 0 === --emval_handles[handle + 1]) {
+        emval_handles[handle] = undefined;
+        emval_freelist.push(handle);
+      }
+    };
+    var count_emval_handles = function count_emval_handles() {
+      return emval_handles.length / 2 - 5 - emval_freelist.length;
+    };
+    var init_emval = function init_emval() {
+      emval_handles.push(0, 1, undefined, 1, null, 1, true, 1, false, 1);
+      Module["count_emval_handles"] = count_emval_handles;
+    };
+    var Emval = {
+      toValue: function toValue(handle) {
+        if (!handle) {
+          throwBindingError("Cannot use deleted val. handle = " + handle);
+        }
+        return emval_handles[handle];
+      },
+      toHandle: function toHandle(value) {
+        switch (value) {
+          case undefined:
+            return 2;
+          case null:
+            return 4;
+          case true:
+            return 6;
+          case false:
+            return 8;
+          default:
+            {
+              var handle = emval_freelist.pop() || emval_handles.length;
+              emval_handles[handle] = value;
+              emval_handles[handle + 1] = 1;
+              return handle;
+            }
+        }
+      }
+    };
+    var EmValType = {
+      name: "emscripten::val",
+      "fromWireType": function fromWireType(handle) {
+        var rv = Emval.toValue(handle);
+        __emval_decref(handle);
+        return rv;
+      },
+      "toWireType": function toWireType(destructors, value) {
+        return Emval.toHandle(value);
+      },
+      "argPackAdvance": GenericWireTypeSize,
+      "readValueFromPointer": readPointer,
+      destructorFunction: null
+    };
+    var __embind_register_emval = function __embind_register_emval(rawType) {
+      return registerType(rawType, EmValType);
+    };
+    var enumReadValueFromPointer = function enumReadValueFromPointer(name, width, signed) {
+      switch (width) {
+        case 1:
+          return signed ? function (pointer) {
+            return this["fromWireType"](HEAP8[pointer]);
+          } : function (pointer) {
+            return this["fromWireType"](HEAPU8[pointer]);
+          };
+        case 2:
+          return signed ? function (pointer) {
+            return this["fromWireType"](HEAP16[pointer >> 1]);
+          } : function (pointer) {
+            return this["fromWireType"](HEAPU16[pointer >> 1]);
+          };
+        case 4:
+          return signed ? function (pointer) {
+            return this["fromWireType"](HEAP32[pointer >> 2]);
+          } : function (pointer) {
+            return this["fromWireType"](HEAPU32[pointer >> 2]);
+          };
+        default:
+          throw new TypeError("invalid integer width (".concat(width, "): ").concat(name));
+      }
+    };
+    var __embind_register_enum = function __embind_register_enum(rawType, name, size, isSigned) {
+      name = readLatin1String(name);
+      function ctor() {}
+      ctor.values = {};
+      registerType(rawType, {
+        name: name,
+        constructor: ctor,
+        "fromWireType": function fromWireType(c) {
+          return this.constructor.values[c];
+        },
+        "toWireType": function toWireType(destructors, c) {
+          return c.value;
+        },
+        "argPackAdvance": GenericWireTypeSize,
+        "readValueFromPointer": enumReadValueFromPointer(name, size, isSigned),
+        destructorFunction: null
+      });
+      exposePublicSymbol(name, ctor);
+    };
+    var requireRegisteredType = function requireRegisteredType(rawType, humanName) {
+      var impl = registeredTypes[rawType];
+      if (undefined === impl) {
+        throwBindingError("".concat(humanName, " has unknown type ").concat(getTypeName(rawType)));
+      }
+      return impl;
+    };
+    var __embind_register_enum_value = function __embind_register_enum_value(rawEnumType, name, enumValue) {
+      var enumType = requireRegisteredType(rawEnumType, "enum");
+      name = readLatin1String(name);
+      var Enum = enumType.constructor;
+      var Value = Object.create(enumType.constructor.prototype, {
+        value: {
+          value: enumValue
+        },
+        constructor: {
+          value: createNamedFunction("".concat(enumType.name, "_").concat(name), function () {})
+        }
+      });
+      Enum.values[enumValue] = Value;
+      Enum[name] = Value;
+    };
+    var floatReadValueFromPointer = function floatReadValueFromPointer(name, width) {
+      switch (width) {
+        case 4:
+          return function (pointer) {
+            return this["fromWireType"](HEAPF32[pointer >> 2]);
+          };
+        case 8:
+          return function (pointer) {
+            return this["fromWireType"](HEAPF64[pointer >> 3]);
+          };
+        default:
+          throw new TypeError("invalid float width (".concat(width, "): ").concat(name));
+      }
+    };
+    var __embind_register_float = function __embind_register_float(rawType, name, size) {
+      name = readLatin1String(name);
+      registerType(rawType, {
+        name: name,
+        "fromWireType": function fromWireType(value) {
+          return value;
+        },
+        "toWireType": function toWireType(destructors, value) {
+          return value;
+        },
+        "argPackAdvance": GenericWireTypeSize,
+        "readValueFromPointer": floatReadValueFromPointer(name, size),
+        destructorFunction: null
+      });
+    };
+    var __embind_register_integer = function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
+      name = readLatin1String(name);
+      var fromWireType = function fromWireType(value) {
+        return value;
+      };
+      if (minRange === 0) {
+        var bitshift = 32 - 8 * size;
+        fromWireType = function fromWireType(value) {
+          return value << bitshift >>> bitshift;
+        };
+      }
+      var isUnsignedType = name.includes("unsigned");
+      var checkAssertions = function checkAssertions(value, toTypeName) {};
+      var toWireType;
+      if (isUnsignedType) {
+        toWireType = function toWireType(destructors, value) {
+          checkAssertions(value, this.name);
+          return value >>> 0;
+        };
+      } else {
+        toWireType = function toWireType(destructors, value) {
+          checkAssertions(value, this.name);
+          return value;
+        };
+      }
+      registerType(primitiveType, {
+        name: name,
+        "fromWireType": fromWireType,
+        "toWireType": toWireType,
+        "argPackAdvance": GenericWireTypeSize,
+        "readValueFromPointer": integerReadValueFromPointer(name, size, minRange !== 0),
+        destructorFunction: null
+      });
+    };
+    var __embind_register_memory_view = function __embind_register_memory_view(rawType, dataTypeIndex, name) {
+      var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array];
+      var TA = typeMapping[dataTypeIndex];
+      function decodeMemoryView(handle) {
+        var size = HEAPU32[handle >> 2];
+        var data = HEAPU32[handle + 4 >> 2];
+        return new TA(HEAP8.buffer, data, size);
+      }
+      name = readLatin1String(name);
+      registerType(rawType, {
+        name: name,
+        "fromWireType": decodeMemoryView,
+        "argPackAdvance": GenericWireTypeSize,
+        "readValueFromPointer": decodeMemoryView
+      }, {
+        ignoreDuplicateRegistrations: true
+      });
+    };
+    var __embind_register_optional = function __embind_register_optional(rawOptionalType, rawType) {
+      __embind_register_emval(rawOptionalType);
+    };
+    var __embind_register_smart_ptr = function __embind_register_smart_ptr(rawType, rawPointeeType, name, sharingPolicy, getPointeeSignature, rawGetPointee, constructorSignature, rawConstructor, shareSignature, rawShare, destructorSignature, rawDestructor) {
+      name = readLatin1String(name);
+      rawGetPointee = embind__requireFunction(getPointeeSignature, rawGetPointee);
+      rawConstructor = embind__requireFunction(constructorSignature, rawConstructor);
+      rawShare = embind__requireFunction(shareSignature, rawShare);
+      rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
+      whenDependentTypesAreResolved([rawType], [rawPointeeType], function (pointeeType) {
+        pointeeType = pointeeType[0];
+        var registeredPointer = new RegisteredPointer(name, pointeeType.registeredClass, false, false, true, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor);
+        return [registeredPointer];
+      });
+    };
+    var stringToUTF8Array = function stringToUTF8Array(str, heap, 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) {
+          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;
+    };
+    var stringToUTF8 = function stringToUTF8(str, outPtr, maxBytesToWrite) {
+      return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+    };
+    var lengthBytesUTF8 = 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;
+    };
+    var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
+    var UTF8ArrayToString = function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
+      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;
+    };
+    var UTF8ToString = function UTF8ToString(ptr, maxBytesToRead) {
+      return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+    };
+    var __embind_register_std_string = function __embind_register_std_string(rawType, name) {
+      name = readLatin1String(name);
+      var stdStringIsUTF8 = name === "std::string";
+      registerType(rawType, {
+        name: name,
+        "fromWireType": function fromWireType(value) {
+          var length = HEAPU32[value >> 2];
+          var payload = value + 4;
+          var str;
+          if (stdStringIsUTF8) {
+            var decodeStartPtr = payload;
+            for (var i = 0; i <= length; ++i) {
+              var currentBytePtr = payload + i;
+              if (i == length || HEAPU8[currentBytePtr] == 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]);
+            }
+            str = a.join("");
+          }
+          _free(value);
+          return str;
+        },
+        "toWireType": function toWireType(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(4 + length + 1);
+          var ptr = base + 4;
+          HEAPU32[base >> 2] = 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] = charCode;
+              }
+            } else {
+              for (var i = 0; i < length; ++i) {
+                HEAPU8[ptr + i] = value[i];
+              }
+            }
+          }
+          if (destructors !== null) {
+            destructors.push(_free, base);
+          }
+          return base;
+        },
+        "argPackAdvance": GenericWireTypeSize,
+        "readValueFromPointer": readPointer,
+        destructorFunction: function destructorFunction(ptr) {
+          _free(ptr);
+        }
+      });
+    };
+    var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined;
+    var UTF16ToString = function UTF16ToString(ptr, maxBytesToRead) {
+      var endPtr = ptr;
+      var idx = endPtr >> 1;
+      var maxIdx = idx + maxBytesToRead / 2;
+      while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;
+      endPtr = idx << 1;
+      if (endPtr - ptr > 32 && UTF16Decoder) return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
+      var str = "";
+      for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
+        var codeUnit = HEAP16[ptr + i * 2 >> 1];
+        if (codeUnit == 0) break;
+        str += String.fromCharCode(codeUnit);
+      }
+      return str;
+    };
+    var stringToUTF16 = function stringToUTF16(str, outPtr, maxBytesToWrite) {
+      var _maxBytesToWrite;
+      (_maxBytesToWrite = maxBytesToWrite) !== null && _maxBytesToWrite !== void 0 ? _maxBytesToWrite : 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 >> 1] = codeUnit;
+        outPtr += 2;
+      }
+      HEAP16[outPtr >> 1] = 0;
+      return outPtr - startPtr;
+    };
+    var lengthBytesUTF16 = function lengthBytesUTF16(str) {
+      return str.length * 2;
+    };
+    var UTF32ToString = function UTF32ToString(ptr, maxBytesToRead) {
+      var i = 0;
+      var str = "";
+      while (!(i >= maxBytesToRead / 4)) {
+        var utf32 = HEAP32[ptr + i * 4 >> 2];
+        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;
+    };
+    var stringToUTF32 = function stringToUTF32(str, outPtr, maxBytesToWrite) {
+      var _maxBytesToWrite2;
+      (_maxBytesToWrite2 = maxBytesToWrite) !== null && _maxBytesToWrite2 !== void 0 ? _maxBytesToWrite2 : 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] = codeUnit;
+        outPtr += 4;
+        if (outPtr + 4 > endPtr) break;
+      }
+      HEAP32[outPtr >> 2] = 0;
+      return outPtr - startPtr;
+    };
+    var lengthBytesUTF32 = 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;
+    };
+    var __embind_register_std_wstring = function __embind_register_std_wstring(rawType, charSize, name) {
+      name = readLatin1String(name);
+      var decodeString, encodeString, readCharAt, lengthBytesUTF;
+      if (charSize === 2) {
+        decodeString = UTF16ToString;
+        encodeString = stringToUTF16;
+        lengthBytesUTF = lengthBytesUTF16;
+        readCharAt = function readCharAt(pointer) {
+          return HEAPU16[pointer >> 1];
+        };
+      } else if (charSize === 4) {
+        decodeString = UTF32ToString;
+        encodeString = stringToUTF32;
+        lengthBytesUTF = lengthBytesUTF32;
+        readCharAt = function readCharAt(pointer) {
+          return HEAPU32[pointer >> 2];
+        };
+      }
+      registerType(rawType, {
+        name: name,
+        "fromWireType": function fromWireType(value) {
+          var length = HEAPU32[value >> 2];
+          var str;
+          var decodeStartPtr = value + 4;
+          for (var i = 0; i <= length; ++i) {
+            var currentBytePtr = value + 4 + i * charSize;
+            if (i == length || readCharAt(currentBytePtr) == 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 toWireType(destructors, value) {
+          if (!(typeof value == "string")) {
+            throwBindingError("Cannot pass non-string to C++ string type ".concat(name));
+          }
+          var length = lengthBytesUTF(value);
+          var ptr = _malloc(4 + length + charSize);
+          HEAPU32[ptr >> 2] = length / charSize;
+          encodeString(value, ptr + 4, length + charSize);
+          if (destructors !== null) {
+            destructors.push(_free, ptr);
+          }
+          return ptr;
+        },
+        "argPackAdvance": GenericWireTypeSize,
+        "readValueFromPointer": readPointer,
+        destructorFunction: function destructorFunction(ptr) {
+          _free(ptr);
+        }
+      });
+    };
+    var __embind_register_value_object = function __embind_register_value_object(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) {
+      structRegistrations[rawType] = {
+        name: readLatin1String(name),
+        rawConstructor: embind__requireFunction(constructorSignature, rawConstructor),
+        rawDestructor: embind__requireFunction(destructorSignature, rawDestructor),
+        fields: []
+      };
+    };
+    var __embind_register_value_object_field = 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: embind__requireFunction(getterSignature, getter),
+        getterContext: getterContext,
+        setterArgumentType: setterArgumentType,
+        setter: embind__requireFunction(setterSignature, setter),
+        setterContext: setterContext
+      });
+    };
+    var __embind_register_void = function __embind_register_void(rawType, name) {
+      name = readLatin1String(name);
+      registerType(rawType, {
+        isVoid: true,
+        name: name,
+        "argPackAdvance": 0,
+        "fromWireType": function fromWireType() {
+          return undefined;
+        },
+        "toWireType": function toWireType(destructors, o) {
+          return undefined;
+        }
+      });
+    };
+    var nowIsMonotonic = 1;
+    var __emscripten_get_now_is_monotonic = function __emscripten_get_now_is_monotonic() {
+      return nowIsMonotonic;
+    };
+    var __emscripten_throw_longjmp = function __emscripten_throw_longjmp() {
+      throw Infinity;
+    };
+    var emval_returnValue = function emval_returnValue(returnType, destructorsRef, handle) {
+      var destructors = [];
+      var result = returnType["toWireType"](destructors, handle);
+      if (destructors.length) {
+        HEAPU32[destructorsRef >> 2] = Emval.toHandle(destructors);
+      }
+      return result;
+    };
+    var __emval_as = function __emval_as(handle, returnType, destructorsRef) {
+      handle = Emval.toValue(handle);
+      returnType = requireRegisteredType(returnType, "emval::as");
+      return emval_returnValue(returnType, destructorsRef, handle);
+    };
+    var emval_methodCallers = [];
+    var __emval_call = function __emval_call(caller, handle, destructorsRef, args) {
+      caller = emval_methodCallers[caller];
+      handle = Emval.toValue(handle);
+      return caller(null, handle, destructorsRef, args);
+    };
+    var emval_symbols = {};
+    var getStringOrSymbol = function getStringOrSymbol(address) {
+      var symbol = emval_symbols[address];
+      if (symbol === undefined) {
+        return readLatin1String(address);
+      }
+      return symbol;
+    };
+    var __emval_call_method = function __emval_call_method(caller, objHandle, methodName, destructorsRef, args) {
+      caller = emval_methodCallers[caller];
+      objHandle = Emval.toValue(objHandle);
+      methodName = getStringOrSymbol(methodName);
+      return caller(objHandle, objHandle[methodName], destructorsRef, args);
+    };
+    var emval_get_global = function emval_get_global() {
+      if ((typeof globalThis === "undefined" ? "undefined" : _typeof(globalThis)) == "object") {
+        return globalThis;
+      }
+      return function () {
+        return Function;
+      }()("return this")();
+    };
+    var __emval_get_global = function __emval_get_global(name) {
+      if (name === 0) {
+        return Emval.toHandle(emval_get_global());
+      } else {
+        name = getStringOrSymbol(name);
+        return Emval.toHandle(emval_get_global()[name]);
+      }
+    };
+    var emval_addMethodCaller = function emval_addMethodCaller(caller) {
+      var id = emval_methodCallers.length;
+      emval_methodCallers.push(caller);
+      return id;
+    };
+    var emval_lookupTypes = function emval_lookupTypes(argCount, argTypes) {
+      var a = new Array(argCount);
+      for (var i = 0; i < argCount; ++i) {
+        a[i] = requireRegisteredType(HEAPU32[argTypes + i * 4 >> 2], "parameter " + i);
+      }
+      return a;
+    };
+    var __emval_get_method_caller = function __emval_get_method_caller(argCount, argTypes, kind) {
+      var types = emval_lookupTypes(argCount, argTypes);
+      var retType = types.shift();
+      argCount--;
+      var functionBody = "return function (obj, func, destructorsRef, args) {\n";
+      var offset = 0;
+      var argsList = [];
+      if (kind === 0) {
+        argsList.push("obj");
+      }
+      var params = ["retType"];
+      var args = [retType];
+      for (var i = 0; i < argCount; ++i) {
+        argsList.push("arg" + i);
+        params.push("argType" + i);
+        args.push(types[i]);
+        functionBody += "  var arg".concat(i, " = argType").concat(i, ".readValueFromPointer(args").concat(offset ? "+" + offset : "", ");\n");
+        offset += types[i]["argPackAdvance"];
+      }
+      var invoker = kind === 1 ? "new func" : "func.call";
+      functionBody += "  var rv = ".concat(invoker, "(").concat(argsList.join(", "), ");\n");
+      if (!retType.isVoid) {
+        params.push("emval_returnValue");
+        args.push(emval_returnValue);
+        functionBody += "  return emval_returnValue(retType, destructorsRef, rv);\n";
+      }
+      functionBody += "};\n";
+      params.push(functionBody);
+      var invokerFunction = newFunc(Function, params).apply(void 0, args);
+      var functionName = "methodCaller<(".concat(types.map(function (t) {
+        return t.name;
+      }).join(", "), ") => ").concat(retType.name, ">");
+      return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));
+    };
+    var __emval_get_module_property = function __emval_get_module_property(name) {
+      name = getStringOrSymbol(name);
+      return Emval.toHandle(Module[name]);
+    };
+    var __emval_get_property = function __emval_get_property(handle, key) {
+      handle = Emval.toValue(handle);
+      key = Emval.toValue(key);
+      return Emval.toHandle(handle[key]);
+    };
+    var __emval_incref = function __emval_incref(handle) {
+      if (handle > 9) {
+        emval_handles[handle + 1] += 1;
+      }
+    };
+    var __emval_new_array = function __emval_new_array() {
+      return Emval.toHandle([]);
+    };
+    var __emval_new_cstring = function __emval_new_cstring(v) {
+      return Emval.toHandle(getStringOrSymbol(v));
+    };
+    var __emval_run_destructors = function __emval_run_destructors(handle) {
+      var destructors = Emval.toValue(handle);
+      runDestructors(destructors);
+      __emval_decref(handle);
+    };
+    var __emval_take_value = function __emval_take_value(type, arg) {
+      type = requireRegisteredType(type, "_emval_take_value");
+      var v = type["readValueFromPointer"](arg);
+      return Emval.toHandle(v);
+    };
+    var MAX_INT53 = 9007199254740992;
+    var MIN_INT53 = -9007199254740992;
+    var bigintToI53Checked = function bigintToI53Checked(num) {
+      return num < MIN_INT53 || num > MAX_INT53 ? NaN : Number(num);
+    };
+    function __gmtime_js(time, tmPtr) {
+      time = bigintToI53Checked(time);
+      var date = new Date(time * 1e3);
+      HEAP32[tmPtr >> 2] = date.getUTCSeconds();
+      HEAP32[tmPtr + 4 >> 2] = date.getUTCMinutes();
+      HEAP32[tmPtr + 8 >> 2] = date.getUTCHours();
+      HEAP32[tmPtr + 12 >> 2] = date.getUTCDate();
+      HEAP32[tmPtr + 16 >> 2] = date.getUTCMonth();
+      HEAP32[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900;
+      HEAP32[tmPtr + 24 >> 2] = date.getUTCDay();
+      var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
+      var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0;
+      HEAP32[tmPtr + 28 >> 2] = yday;
+    }
+    var __tzset_js = function __tzset_js(timezone, daylight, std_name, dst_name) {
+      var currentYear = new Date().getFullYear();
+      var winter = new Date(currentYear, 0, 1);
+      var summer = new Date(currentYear, 6, 1);
+      var winterOffset = winter.getTimezoneOffset();
+      var summerOffset = summer.getTimezoneOffset();
+      var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
+      HEAPU32[timezone >> 2] = stdTimezoneOffset * 60;
+      HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
+      var extractZone = function extractZone(date) {
+        return date.toLocaleTimeString(undefined, {
+          hour12: false,
+          timeZoneName: "short"
+        }).split(" ")[1];
+      };
+      var winterName = extractZone(winter);
+      var summerName = extractZone(summer);
+      if (summerOffset < winterOffset) {
+        stringToUTF8(winterName, std_name, 17);
+        stringToUTF8(summerName, dst_name, 17);
+      } else {
+        stringToUTF8(winterName, dst_name, 17);
+        stringToUTF8(summerName, std_name, 17);
+      }
+    };
+    var _emscripten_cancel_animation_frame = function _emscripten_cancel_animation_frame(id) {
+      return cancelAnimationFrame(id);
+    };
+    var _emscripten_date_now = function _emscripten_date_now() {
+      return Date.now();
+    };
+    var _emscripten_get_now;
+    _emscripten_get_now = function _emscripten_get_now() {
+      return performance.now();
+    };
+    var _emscripten_request_animation_frame = function _emscripten_request_animation_frame(cb, userData) {
+      return requestAnimationFrame(function (timeStamp) {
+        return getWasmTableEntry(cb)(timeStamp, userData);
+      });
+    };
+    var getHeapMax = function getHeapMax() {
+      return 2147483648;
+    };
+    var growMemory = function growMemory(size) {
+      var b = wasmMemory.buffer;
+      var pages = (size - b.byteLength + 65535) / 65536;
+      try {
+        wasmMemory.grow(pages);
+        updateMemoryViews();
+        return 1;
+      } catch (e) {}
+    };
+    var _emscripten_resize_heap = function _emscripten_resize_heap(requestedSize) {
+      var oldSize = HEAPU8.length;
+      requestedSize >>>= 0;
+      var maxHeapSize = getHeapMax();
+      if (requestedSize > maxHeapSize) {
+        return false;
+      }
+      var alignUp = function alignUp(x, multiple) {
+        return x + (multiple - x % multiple) % multiple;
+      };
+      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+        var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+        var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
+        var replacement = growMemory(newSize);
+        if (replacement) {
+          return true;
+        }
+      }
+      return false;
+    };
+    var webgl_enable_ANGLE_instanced_arrays = function webgl_enable_ANGLE_instanced_arrays(ctx) {
+      var ext = ctx.getExtension("ANGLE_instanced_arrays");
+      if (ext) {
+        ctx["vertexAttribDivisor"] = function (index, divisor) {
+          return ext["vertexAttribDivisorANGLE"](index, divisor);
+        };
+        ctx["drawArraysInstanced"] = function (mode, first, count, primcount) {
+          return ext["drawArraysInstancedANGLE"](mode, first, count, primcount);
+        };
+        ctx["drawElementsInstanced"] = function (mode, count, type, indices, primcount) {
+          return ext["drawElementsInstancedANGLE"](mode, count, type, indices, primcount);
+        };
+        return 1;
+      }
+    };
+    var webgl_enable_OES_vertex_array_object = function webgl_enable_OES_vertex_array_object(ctx) {
+      var ext = ctx.getExtension("OES_vertex_array_object");
+      if (ext) {
+        ctx["createVertexArray"] = function () {
+          return ext["createVertexArrayOES"]();
+        };
+        ctx["deleteVertexArray"] = function (vao) {
+          return ext["deleteVertexArrayOES"](vao);
+        };
+        ctx["bindVertexArray"] = function (vao) {
+          return ext["bindVertexArrayOES"](vao);
+        };
+        ctx["isVertexArray"] = function (vao) {
+          return ext["isVertexArrayOES"](vao);
+        };
+        return 1;
+      }
+    };
+    var webgl_enable_WEBGL_draw_buffers = function webgl_enable_WEBGL_draw_buffers(ctx) {
+      var ext = ctx.getExtension("WEBGL_draw_buffers");
+      if (ext) {
+        ctx["drawBuffers"] = function (n, bufs) {
+          return ext["drawBuffersWEBGL"](n, bufs);
+        };
+        return 1;
+      }
+    };
+    var webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance = function webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(ctx) {
+      return !!(ctx.dibvbi = ctx.getExtension("WEBGL_draw_instanced_base_vertex_base_instance"));
+    };
+    var webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance = function webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(ctx) {
+      return !!(ctx.mdibvbi = ctx.getExtension("WEBGL_multi_draw_instanced_base_vertex_base_instance"));
+    };
+    var webgl_enable_WEBGL_multi_draw = function webgl_enable_WEBGL_multi_draw(ctx) {
+      return !!(ctx.multiDrawWebgl = ctx.getExtension("WEBGL_multi_draw"));
+    };
+    var getEmscriptenSupportedExtensions = function getEmscriptenSupportedExtensions(ctx) {
+      var supportedExtensions = ["ANGLE_instanced_arrays", "EXT_blend_minmax", "EXT_disjoint_timer_query", "EXT_frag_depth", "EXT_shader_texture_lod", "EXT_sRGB", "OES_element_index_uint", "OES_fbo_render_mipmap", "OES_standard_derivatives", "OES_texture_float", "OES_texture_half_float", "OES_texture_half_float_linear", "OES_vertex_array_object", "WEBGL_color_buffer_float", "WEBGL_depth_texture", "WEBGL_draw_buffers", "EXT_color_buffer_float", "EXT_conservative_depth", "EXT_disjoint_timer_query_webgl2", "EXT_texture_norm16", "NV_shader_noperspective_interpolation", "WEBGL_clip_cull_distance", "EXT_color_buffer_half_float", "EXT_depth_clamp", "EXT_float_blend", "EXT_texture_compression_bptc", "EXT_texture_compression_rgtc", "EXT_texture_filter_anisotropic", "KHR_parallel_shader_compile", "OES_texture_float_linear", "WEBGL_blend_func_extended", "WEBGL_compressed_texture_astc", "WEBGL_compressed_texture_etc", "WEBGL_compressed_texture_etc1", "WEBGL_compressed_texture_s3tc", "WEBGL_compressed_texture_s3tc_srgb", "WEBGL_debug_renderer_info", "WEBGL_debug_shaders", "WEBGL_lose_context", "WEBGL_multi_draw"];
+      return (ctx.getSupportedExtensions() || []).filter(function (ext) {
+        return supportedExtensions.includes(ext);
+      });
+    };
+    var GL = {
+      counter: 1,
+      buffers: [],
+      programs: [],
+      framebuffers: [],
+      renderbuffers: [],
+      textures: [],
+      shaders: [],
+      vaos: [],
+      contexts: [],
+      offscreenCanvases: {},
+      queries: [],
+      samplers: [],
+      transformFeedbacks: [],
+      syncs: [],
+      stringCache: {},
+      stringiCache: {},
+      unpackAlignment: 4,
+      recordError: function recordError(errorCode) {
+        if (!GL.lastError) {
+          GL.lastError = errorCode;
+        }
+      },
+      getNewId: function getNewId(table) {
+        var ret = GL.counter++;
+        for (var i = table.length; i < ret; i++) {
+          table[i] = null;
+        }
+        return ret;
+      },
+      genObject: function genObject(n, buffers, createFunction, objectTable) {
+        for (var i = 0; i < n; i++) {
+          var buffer = GLctx[createFunction]();
+          var id = buffer && GL.getNewId(objectTable);
+          if (buffer) {
+            buffer.name = id;
+            objectTable[id] = buffer;
+          } else {
+            GL.recordError(1282);
+          }
+          HEAP32[buffers + i * 4 >> 2] = id;
+        }
+      },
+      getSource: function getSource(shader, count, string, length) {
+        var source = "";
+        for (var i = 0; i < count; ++i) {
+          var len = length ? HEAPU32[length + i * 4 >> 2] : undefined;
+          source += UTF8ToString(HEAPU32[string + i * 4 >> 2], len);
+        }
+        return source;
+      },
+      createContext: function createContext(canvas, webGLContextAttributes) {
+        if (!canvas.getContextSafariWebGL2Fixed) {
+          var fixedGetContext = function fixedGetContext(ver, attrs) {
+            var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs);
+            return ver == "webgl" == gl instanceof WebGLRenderingContext ? gl : null;
+          };
+          canvas.getContextSafariWebGL2Fixed = canvas.getContext;
+          canvas.getContext = fixedGetContext;
+        }
+        var ctx = webGLContextAttributes.majorVersion > 1 ? canvas.getContext("webgl2", webGLContextAttributes) : canvas.getContext("webgl", webGLContextAttributes);
+        if (!ctx) return 0;
+        var handle = GL.registerContext(ctx, webGLContextAttributes);
+        return handle;
+      },
+      registerContext: function registerContext(ctx, webGLContextAttributes) {
+        var handle = GL.getNewId(GL.contexts);
+        var context = {
+          handle: handle,
+          attributes: webGLContextAttributes,
+          version: webGLContextAttributes.majorVersion,
+          GLctx: ctx
+        };
+        if (ctx.canvas) ctx.canvas.GLctxObject = context;
+        GL.contexts[handle] = context;
+        if (typeof webGLContextAttributes.enableExtensionsByDefault == "undefined" || webGLContextAttributes.enableExtensionsByDefault) {
+          GL.initExtensions(context);
+        }
+        return handle;
+      },
+      makeContextCurrent: function makeContextCurrent(contextHandle) {
+        var _GL$currentContext;
+        GL.currentContext = GL.contexts[contextHandle];
+        Module.ctx = GLctx = (_GL$currentContext = GL.currentContext) === null || _GL$currentContext === void 0 ? void 0 : _GL$currentContext.GLctx;
+        return !(contextHandle && !GLctx);
+      },
+      getContext: function getContext(contextHandle) {
+        return GL.contexts[contextHandle];
+      },
+      deleteContext: function deleteContext(contextHandle) {
+        if (GL.currentContext === GL.contexts[contextHandle]) {
+          GL.currentContext = null;
+        }
+        if ((typeof JSEvents === "undefined" ? "undefined" : _typeof(JSEvents)) == "object") {
+          JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas);
+        }
+        if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) {
+          GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined;
+        }
+        GL.contexts[contextHandle] = null;
+      },
+      initExtensions: function initExtensions(context) {
+        context || (context = GL.currentContext);
+        if (context.initExtensionsDone) return;
+        context.initExtensionsDone = true;
+        var GLctx = context.GLctx;
+        webgl_enable_ANGLE_instanced_arrays(GLctx);
+        webgl_enable_OES_vertex_array_object(GLctx);
+        webgl_enable_WEBGL_draw_buffers(GLctx);
+        webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx);
+        webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx);
+        if (context.version >= 2) {
+          GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query_webgl2");
+        }
+        if (context.version < 2 || !GLctx.disjointTimerQueryExt) {
+          GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query");
+        }
+        webgl_enable_WEBGL_multi_draw(GLctx);
+        getEmscriptenSupportedExtensions(GLctx).forEach(function (ext) {
+          if (!ext.includes("lose_context") && !ext.includes("debug")) {
+            GLctx.getExtension(ext);
+          }
+        });
+      }
+    };
+    var _emscripten_webgl_make_context_current = function _emscripten_webgl_make_context_current(contextHandle) {
+      var success = GL.makeContextCurrent(contextHandle);
+      return success ? 0 : -5;
+    };
+    var ENV = {};
+    var getExecutableName = function getExecutableName() {
+      return thisProgram ;
+    };
+    var _getEnvStrings = function getEnvStrings() {
+      if (!_getEnvStrings.strings) {
+        var lang = ((typeof navigator === "undefined" ? "undefined" : _typeof(navigator)) == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8";
+        var env = {
+          "USER": "web_user",
+          "LOGNAME": "web_user",
+          "PATH": "/",
+          "PWD": "/",
+          "HOME": "/home/web_user",
+          "LANG": lang,
+          "_": getExecutableName()
+        };
+        for (var x in ENV) {
+          if (ENV[x] === undefined) delete env[x];else env[x] = ENV[x];
+        }
+        var strings = [];
+        for (var x in env) {
+          strings.push("".concat(x, "=").concat(env[x]));
+        }
+        _getEnvStrings.strings = strings;
+      }
+      return _getEnvStrings.strings;
+    };
+    var stringToAscii = function stringToAscii(str, buffer) {
+      for (var i = 0; i < str.length; ++i) {
+        HEAP8[buffer++] = str.charCodeAt(i);
+      }
+      HEAP8[buffer] = 0;
+    };
+    var _environ_get = function _environ_get(__environ, environ_buf) {
+      var bufSize = 0;
+      _getEnvStrings().forEach(function (string, i) {
+        var ptr = environ_buf + bufSize;
+        HEAPU32[__environ + i * 4 >> 2] = ptr;
+        stringToAscii(string, ptr);
+        bufSize += string.length + 1;
+      });
+      return 0;
+    };
+    var _environ_sizes_get = function _environ_sizes_get(penviron_count, penviron_buf_size) {
+      var strings = _getEnvStrings();
+      HEAPU32[penviron_count >> 2] = strings.length;
+      var bufSize = 0;
+      strings.forEach(function (string) {
+        return bufSize += string.length + 1;
+      });
+      HEAPU32[penviron_buf_size >> 2] = bufSize;
+      return 0;
+    };
+    var runtimeKeepaliveCounter = 0;
+    var keepRuntimeAlive = function keepRuntimeAlive() {
+      return noExitRuntime || runtimeKeepaliveCounter > 0;
+    };
+    var _proc_exit = function _proc_exit(code) {
+      if (!keepRuntimeAlive()) {
+        ABORT = true;
+      }
+      quit_(code, new ExitStatus(code));
+    };
+    var exitJS = function exitJS(status, implicit) {
+      _proc_exit(status);
+    };
+    var _exit = exitJS;
+    var _fd_close = function _fd_close(fd) {
+      return 52;
+    };
+    function _fd_seek(fd, offset, whence, newOffset) {
+      return 70;
+    }
+    var printCharBuffers = [null, [], []];
+    var printChar = function printChar(stream, curr) {
+      var buffer = printCharBuffers[stream];
+      if (curr === 0 || curr === 10) {
+        (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
+        buffer.length = 0;
+      } else {
+        buffer.push(curr);
+      }
+    };
+    var _fd_write = function _fd_write(fd, iov, iovcnt, pnum) {
+      var num = 0;
+      for (var i = 0; i < iovcnt; i++) {
+        var ptr = HEAPU32[iov >> 2];
+        var len = HEAPU32[iov + 4 >> 2];
+        iov += 8;
+        for (var j = 0; j < len; j++) {
+          printChar(fd, HEAPU8[ptr + j]);
+        }
+        num += len;
+      }
+      HEAPU32[pnum >> 2] = num;
+      return 0;
+    };
+    var _glActiveTexture = function _glActiveTexture(x0) {
+      return GLctx.activeTexture(x0);
+    };
+    var _glAttachShader = function _glAttachShader(program, shader) {
+      GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
+    };
+    var _glBindAttribLocation = function _glBindAttribLocation(program, index, name) {
+      GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name));
+    };
+    var _glBindBuffer = function _glBindBuffer(target, buffer) {
+      if (target == 35051) {
+        GLctx.currentPixelPackBufferBinding = buffer;
+      } else if (target == 35052) {
+        GLctx.currentPixelUnpackBufferBinding = buffer;
+      }
+      GLctx.bindBuffer(target, GL.buffers[buffer]);
+    };
+    var _glBindFramebuffer = function _glBindFramebuffer(target, framebuffer) {
+      GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]);
+    };
+    var _glBindRenderbuffer = function _glBindRenderbuffer(target, renderbuffer) {
+      GLctx.bindRenderbuffer(target, GL.renderbuffers[renderbuffer]);
+    };
+    var _glBindSampler = function _glBindSampler(unit, sampler) {
+      GLctx.bindSampler(unit, GL.samplers[sampler]);
+    };
+    var _glBindTexture = function _glBindTexture(target, texture) {
+      GLctx.bindTexture(target, GL.textures[texture]);
+    };
+    var _glBindVertexArray = function _glBindVertexArray(vao) {
+      GLctx.bindVertexArray(GL.vaos[vao]);
+    };
+    var _glBindVertexArrayOES = _glBindVertexArray;
+    var _glBlendColor = function _glBlendColor(x0, x1, x2, x3) {
+      return GLctx.blendColor(x0, x1, x2, x3);
+    };
+    var _glBlendEquation = function _glBlendEquation(x0) {
+      return GLctx.blendEquation(x0);
+    };
+    var _glBlendFunc = function _glBlendFunc(x0, x1) {
+      return GLctx.blendFunc(x0, x1);
+    };
+    var _glBlitFramebuffer = function _glBlitFramebuffer(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) {
+      return GLctx.blitFramebuffer(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
+    };
+    var _glBufferData = function _glBufferData(target, size, data, usage) {
+      if (GL.currentContext.version >= 2) {
+        if (data && size) {
+          GLctx.bufferData(target, HEAPU8, usage, data, size);
+        } else {
+          GLctx.bufferData(target, size, usage);
+        }
+        return;
+      }
+      GLctx.bufferData(target, data ? HEAPU8.subarray(data, data + size) : size, usage);
+    };
+    var _glBufferSubData = function _glBufferSubData(target, offset, size, data) {
+      if (GL.currentContext.version >= 2) {
+        size && GLctx.bufferSubData(target, offset, HEAPU8, data, size);
+        return;
+      }
+      GLctx.bufferSubData(target, offset, HEAPU8.subarray(data, data + size));
+    };
+    var _glCheckFramebufferStatus = function _glCheckFramebufferStatus(x0) {
+      return GLctx.checkFramebufferStatus(x0);
+    };
+    var _glClear = function _glClear(x0) {
+      return GLctx.clear(x0);
+    };
+    var _glClearColor = function _glClearColor(x0, x1, x2, x3) {
+      return GLctx.clearColor(x0, x1, x2, x3);
+    };
+    var _glClearStencil = function _glClearStencil(x0) {
+      return GLctx.clearStencil(x0);
+    };
+    var _glClientWaitSync = function _glClientWaitSync(sync, flags, timeout) {
+      timeout = Number(timeout);
+      return GLctx.clientWaitSync(GL.syncs[sync], flags, timeout);
+    };
+    var _glColorMask = function _glColorMask(red, green, blue, alpha) {
+      GLctx.colorMask(!!red, !!green, !!blue, !!alpha);
+    };
+    var _glCompileShader = function _glCompileShader(shader) {
+      GLctx.compileShader(GL.shaders[shader]);
+    };
+    var _glCompressedTexImage2D = function _glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data) {
+      if (GL.currentContext.version >= 2) {
+        if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
+          GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data);
+          return;
+        }
+        GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, HEAPU8, data, imageSize);
+        return;
+      }
+      GLctx.compressedTexImage2D(target, level, internalFormat, width, height, border, data ? HEAPU8.subarray(data, data + imageSize) : null);
+    };
+    var _glCompressedTexSubImage2D = function _glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data) {
+      if (GL.currentContext.version >= 2) {
+        if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
+          GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+          return;
+        }
+        GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, HEAPU8, data, imageSize);
+        return;
+      }
+      GLctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, data ? HEAPU8.subarray(data, data + imageSize) : null);
+    };
+    var _glCopyBufferSubData = function _glCopyBufferSubData(x0, x1, x2, x3, x4) {
+      return GLctx.copyBufferSubData(x0, x1, x2, x3, x4);
+    };
+    var _glCopyTexSubImage2D = function _glCopyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7) {
+      return GLctx.copyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7);
+    };
+    var _glCreateProgram = function _glCreateProgram() {
+      var id = GL.getNewId(GL.programs);
+      var program = GLctx.createProgram();
+      program.name = id;
+      program.maxUniformLength = program.maxAttributeLength = program.maxUniformBlockNameLength = 0;
+      program.uniformIdCounter = 1;
+      GL.programs[id] = program;
+      return id;
+    };
+    var _glCreateShader = function _glCreateShader(shaderType) {
+      var id = GL.getNewId(GL.shaders);
+      GL.shaders[id] = GLctx.createShader(shaderType);
+      return id;
+    };
+    var _glCullFace = function _glCullFace(x0) {
+      return GLctx.cullFace(x0);
+    };
+    var _glDeleteBuffers = function _glDeleteBuffers(n, buffers) {
+      for (var i = 0; i < n; i++) {
+        var id = HEAP32[buffers + i * 4 >> 2];
+        var buffer = GL.buffers[id];
+        if (!buffer) continue;
+        GLctx.deleteBuffer(buffer);
+        buffer.name = 0;
+        GL.buffers[id] = null;
+        if (id == GLctx.currentPixelPackBufferBinding) GLctx.currentPixelPackBufferBinding = 0;
+        if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0;
+      }
+    };
+    var _glDeleteFramebuffers = function _glDeleteFramebuffers(n, framebuffers) {
+      for (var i = 0; i < n; ++i) {
+        var id = HEAP32[framebuffers + i * 4 >> 2];
+        var framebuffer = GL.framebuffers[id];
+        if (!framebuffer) continue;
+        GLctx.deleteFramebuffer(framebuffer);
+        framebuffer.name = 0;
+        GL.framebuffers[id] = null;
+      }
+    };
+    var _glDeleteProgram = function _glDeleteProgram(id) {
+      if (!id) return;
+      var program = GL.programs[id];
+      if (!program) {
+        GL.recordError(1281);
+        return;
+      }
+      GLctx.deleteProgram(program);
+      program.name = 0;
+      GL.programs[id] = null;
+    };
+    var _glDeleteRenderbuffers = function _glDeleteRenderbuffers(n, renderbuffers) {
+      for (var i = 0; i < n; i++) {
+        var id = HEAP32[renderbuffers + i * 4 >> 2];
+        var renderbuffer = GL.renderbuffers[id];
+        if (!renderbuffer) continue;
+        GLctx.deleteRenderbuffer(renderbuffer);
+        renderbuffer.name = 0;
+        GL.renderbuffers[id] = null;
+      }
+    };
+    var _glDeleteSamplers = function _glDeleteSamplers(n, samplers) {
+      for (var i = 0; i < n; i++) {
+        var id = HEAP32[samplers + i * 4 >> 2];
+        var sampler = GL.samplers[id];
+        if (!sampler) continue;
+        GLctx.deleteSampler(sampler);
+        sampler.name = 0;
+        GL.samplers[id] = null;
+      }
+    };
+    var _glDeleteShader = function _glDeleteShader(id) {
+      if (!id) return;
+      var shader = GL.shaders[id];
+      if (!shader) {
+        GL.recordError(1281);
+        return;
+      }
+      GLctx.deleteShader(shader);
+      GL.shaders[id] = null;
+    };
+    var _glDeleteSync = function _glDeleteSync(id) {
+      if (!id) return;
+      var sync = GL.syncs[id];
+      if (!sync) {
+        GL.recordError(1281);
+        return;
+      }
+      GLctx.deleteSync(sync);
+      sync.name = 0;
+      GL.syncs[id] = null;
+    };
+    var _glDeleteTextures = function _glDeleteTextures(n, textures) {
+      for (var i = 0; i < n; i++) {
+        var id = HEAP32[textures + i * 4 >> 2];
+        var texture = GL.textures[id];
+        if (!texture) continue;
+        GLctx.deleteTexture(texture);
+        texture.name = 0;
+        GL.textures[id] = null;
+      }
+    };
+    var _glDeleteVertexArrays = function _glDeleteVertexArrays(n, vaos) {
+      for (var i = 0; i < n; i++) {
+        var id = HEAP32[vaos + i * 4 >> 2];
+        GLctx.deleteVertexArray(GL.vaos[id]);
+        GL.vaos[id] = null;
+      }
+    };
+    var _glDeleteVertexArraysOES = _glDeleteVertexArrays;
+    var _glDepthMask = function _glDepthMask(flag) {
+      GLctx.depthMask(!!flag);
+    };
+    var _glDisable = function _glDisable(x0) {
+      return GLctx.disable(x0);
+    };
+    var _glDisableVertexAttribArray = function _glDisableVertexAttribArray(index) {
+      GLctx.disableVertexAttribArray(index);
+    };
+    var _glDrawArrays = function _glDrawArrays(mode, first, count) {
+      GLctx.drawArrays(mode, first, count);
+    };
+    var _glDrawArraysInstanced = function _glDrawArraysInstanced(mode, first, count, primcount) {
+      GLctx.drawArraysInstanced(mode, first, count, primcount);
+    };
+    var _glDrawArraysInstancedBaseInstanceWEBGL = function _glDrawArraysInstancedBaseInstanceWEBGL(mode, first, count, instanceCount, baseInstance) {
+      GLctx.dibvbi["drawArraysInstancedBaseInstanceWEBGL"](mode, first, count, instanceCount, baseInstance);
+    };
+    var tempFixedLengthArray = [];
+    var _glDrawBuffers = function _glDrawBuffers(n, bufs) {
+      var bufArray = tempFixedLengthArray[n];
+      for (var i = 0; i < n; i++) {
+        bufArray[i] = HEAP32[bufs + i * 4 >> 2];
+      }
+      GLctx.drawBuffers(bufArray);
+    };
+    var _glDrawElements = function _glDrawElements(mode, count, type, indices) {
+      GLctx.drawElements(mode, count, type, indices);
+    };
+    var _glDrawElementsInstanced = function _glDrawElementsInstanced(mode, count, type, indices, primcount) {
+      GLctx.drawElementsInstanced(mode, count, type, indices, primcount);
+    };
+    var _glDrawElementsInstancedBaseVertexBaseInstanceWEBGL = function _glDrawElementsInstancedBaseVertexBaseInstanceWEBGL(mode, count, type, offset, instanceCount, baseVertex, baseinstance) {
+      GLctx.dibvbi["drawElementsInstancedBaseVertexBaseInstanceWEBGL"](mode, count, type, offset, instanceCount, baseVertex, baseinstance);
+    };
+    var _glDrawRangeElements = function _glDrawRangeElements(mode, start, end, count, type, indices) {
+      _glDrawElements(mode, count, type, indices);
+    };
+    var _glEnable = function _glEnable(x0) {
+      return GLctx.enable(x0);
+    };
+    var _glEnableVertexAttribArray = function _glEnableVertexAttribArray(index) {
+      GLctx.enableVertexAttribArray(index);
+    };
+    var _glFenceSync = function _glFenceSync(condition, flags) {
+      var sync = GLctx.fenceSync(condition, flags);
+      if (sync) {
+        var id = GL.getNewId(GL.syncs);
+        sync.name = id;
+        GL.syncs[id] = sync;
+        return id;
+      }
+      return 0;
+    };
+    var _glFinish = function _glFinish() {
+      return GLctx.finish();
+    };
+    var _glFlush = function _glFlush() {
+      return GLctx.flush();
+    };
+    var _glFramebufferRenderbuffer = function _glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) {
+      GLctx.framebufferRenderbuffer(target, attachment, renderbuffertarget, GL.renderbuffers[renderbuffer]);
+    };
+    var _glFramebufferTexture2D = function _glFramebufferTexture2D(target, attachment, textarget, texture, level) {
+      GLctx.framebufferTexture2D(target, attachment, textarget, GL.textures[texture], level);
+    };
+    var _glFrontFace = function _glFrontFace(x0) {
+      return GLctx.frontFace(x0);
+    };
+    var _glGenBuffers = function _glGenBuffers(n, buffers) {
+      GL.genObject(n, buffers, "createBuffer", GL.buffers);
+    };
+    var _glGenFramebuffers = function _glGenFramebuffers(n, ids) {
+      GL.genObject(n, ids, "createFramebuffer", GL.framebuffers);
+    };
+    var _glGenRenderbuffers = function _glGenRenderbuffers(n, renderbuffers) {
+      GL.genObject(n, renderbuffers, "createRenderbuffer", GL.renderbuffers);
+    };
+    var _glGenSamplers = function _glGenSamplers(n, samplers) {
+      GL.genObject(n, samplers, "createSampler", GL.samplers);
+    };
+    var _glGenTextures = function _glGenTextures(n, textures) {
+      GL.genObject(n, textures, "createTexture", GL.textures);
+    };
+    var _glGenVertexArrays = function _glGenVertexArrays(n, arrays) {
+      GL.genObject(n, arrays, "createVertexArray", GL.vaos);
+    };
+    var _glGenVertexArraysOES = _glGenVertexArrays;
+    var _glGenerateMipmap = function _glGenerateMipmap(x0) {
+      return GLctx.generateMipmap(x0);
+    };
+    var _glGetBufferParameteriv = function _glGetBufferParameteriv(target, value, data) {
+      if (!data) {
+        GL.recordError(1281);
+        return;
+      }
+      HEAP32[data >> 2] = GLctx.getBufferParameter(target, value);
+    };
+    var _glGetError = function _glGetError() {
+      var error = GLctx.getError() || GL.lastError;
+      GL.lastError = 0;
+      return error;
+    };
+    var writeI53ToI64 = function writeI53ToI64(ptr, num) {
+      HEAPU32[ptr >> 2] = num;
+      var lower = HEAPU32[ptr >> 2];
+      HEAPU32[ptr + 4 >> 2] = (num - lower) / 4294967296;
+    };
+    var webglGetExtensions = function $webglGetExtensions() {
+      var exts = getEmscriptenSupportedExtensions(GLctx);
+      exts = exts.concat(exts.map(function (e) {
+        return "GL_" + e;
+      }));
+      return exts;
+    };
+    var emscriptenWebGLGet = function emscriptenWebGLGet(name_, p, type) {
+      if (!p) {
+        GL.recordError(1281);
+        return;
+      }
+      var ret = undefined;
+      switch (name_) {
+        case 36346:
+          ret = 1;
+          break;
+        case 36344:
+          if (type != 0 && type != 1) {
+            GL.recordError(1280);
+          }
+          return;
+        case 34814:
+        case 36345:
+          ret = 0;
+          break;
+        case 34466:
+          var formats = GLctx.getParameter(34467);
+          ret = formats ? formats.length : 0;
+          break;
+        case 33309:
+          if (GL.currentContext.version < 2) {
+            GL.recordError(1282);
+            return;
+          }
+          ret = webglGetExtensions().length;
+          break;
+        case 33307:
+        case 33308:
+          if (GL.currentContext.version < 2) {
+            GL.recordError(1280);
+            return;
+          }
+          ret = name_ == 33307 ? 3 : 0;
+          break;
+      }
+      if (ret === undefined) {
+        var result = GLctx.getParameter(name_);
+        switch (_typeof(result)) {
+          case "number":
+            ret = result;
+            break;
+          case "boolean":
+            ret = result ? 1 : 0;
+            break;
+          case "string":
+            GL.recordError(1280);
+            return;
+          case "object":
+            if (result === null) {
+              switch (name_) {
+                case 34964:
+                case 35725:
+                case 34965:
+                case 36006:
+                case 36007:
+                case 32873:
+                case 34229:
+                case 36662:
+                case 36663:
+                case 35053:
+                case 35055:
+                case 36010:
+                case 35097:
+                case 35869:
+                case 32874:
+                case 36389:
+                case 35983:
+                case 35368:
+                case 34068:
+                  {
+                    ret = 0;
+                    break;
+                  }
+                default:
+                  {
+                    GL.recordError(1280);
+                    return;
+                  }
+              }
+            } else if (result instanceof Float32Array || result instanceof Uint32Array || result instanceof Int32Array || result instanceof Array) {
+              for (var i = 0; i < result.length; ++i) {
+                switch (type) {
+                  case 0:
+                    HEAP32[p + i * 4 >> 2] = result[i];
+                    break;
+                  case 2:
+                    HEAPF32[p + i * 4 >> 2] = result[i];
+                    break;
+                  case 4:
+                    HEAP8[p + i] = result[i] ? 1 : 0;
+                    break;
+                }
+              }
+              return;
+            } else {
+              try {
+                ret = result.name | 0;
+              } catch (e) {
+                GL.recordError(1280);
+                err("GL_INVALID_ENUM in glGet".concat(type, "v: Unknown object returned from WebGL getParameter(").concat(name_, ")! (error: ").concat(e, ")"));
+                return;
+              }
+            }
+            break;
+          default:
+            GL.recordError(1280);
+            err("GL_INVALID_ENUM in glGet".concat(type, "v: Native code calling glGet").concat(type, "v(").concat(name_, ") and it returns ").concat(result, " of type ").concat(_typeof(result), "!"));
+            return;
+        }
+      }
+      switch (type) {
+        case 1:
+          writeI53ToI64(p, ret);
+          break;
+        case 0:
+          HEAP32[p >> 2] = ret;
+          break;
+        case 2:
+          HEAPF32[p >> 2] = ret;
+          break;
+        case 4:
+          HEAP8[p] = ret ? 1 : 0;
+          break;
+      }
+    };
+    var _glGetFloatv = function _glGetFloatv(name_, p) {
+      return emscriptenWebGLGet(name_, p, 2);
+    };
+    var _glGetFramebufferAttachmentParameteriv = function _glGetFramebufferAttachmentParameteriv(target, attachment, pname, params) {
+      var result = GLctx.getFramebufferAttachmentParameter(target, attachment, pname);
+      if (result instanceof WebGLRenderbuffer || result instanceof WebGLTexture) {
+        result = result.name | 0;
+      }
+      HEAP32[params >> 2] = result;
+    };
+    var _glGetIntegerv = function _glGetIntegerv(name_, p) {
+      return emscriptenWebGLGet(name_, p, 0);
+    };
+    var _glGetProgramInfoLog = function _glGetProgramInfoLog(program, maxLength, length, infoLog) {
+      var log = GLctx.getProgramInfoLog(GL.programs[program]);
+      if (log === null) log = "(unknown error)";
+      var numBytesWrittenExclNull = maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0;
+      if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
+    };
+    var _glGetProgramiv = function _glGetProgramiv(program, pname, p) {
+      if (!p) {
+        GL.recordError(1281);
+        return;
+      }
+      if (program >= GL.counter) {
+        GL.recordError(1281);
+        return;
+      }
+      program = GL.programs[program];
+      if (pname == 35716) {
+        var log = GLctx.getProgramInfoLog(program);
+        if (log === null) log = "(unknown error)";
+        HEAP32[p >> 2] = log.length + 1;
+      } else if (pname == 35719) {
+        if (!program.maxUniformLength) {
+          for (var i = 0; i < GLctx.getProgramParameter(program, 35718); ++i) {
+            program.maxUniformLength = Math.max(program.maxUniformLength, GLctx.getActiveUniform(program, i).name.length + 1);
+          }
+        }
+        HEAP32[p >> 2] = program.maxUniformLength;
+      } else if (pname == 35722) {
+        if (!program.maxAttributeLength) {
+          for (var i = 0; i < GLctx.getProgramParameter(program, 35721); ++i) {
+            program.maxAttributeLength = Math.max(program.maxAttributeLength, GLctx.getActiveAttrib(program, i).name.length + 1);
+          }
+        }
+        HEAP32[p >> 2] = program.maxAttributeLength;
+      } else if (pname == 35381) {
+        if (!program.maxUniformBlockNameLength) {
+          for (var i = 0; i < GLctx.getProgramParameter(program, 35382); ++i) {
+            program.maxUniformBlockNameLength = Math.max(program.maxUniformBlockNameLength, GLctx.getActiveUniformBlockName(program, i).length + 1);
+          }
+        }
+        HEAP32[p >> 2] = program.maxUniformBlockNameLength;
+      } else {
+        HEAP32[p >> 2] = GLctx.getProgramParameter(program, pname);
+      }
+    };
+    var _glGetRenderbufferParameteriv = function _glGetRenderbufferParameteriv(target, pname, params) {
+      if (!params) {
+        GL.recordError(1281);
+        return;
+      }
+      HEAP32[params >> 2] = GLctx.getRenderbufferParameter(target, pname);
+    };
+    var _glGetShaderInfoLog = function _glGetShaderInfoLog(shader, maxLength, length, infoLog) {
+      var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
+      if (log === null) log = "(unknown error)";
+      var numBytesWrittenExclNull = maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0;
+      if (length) HEAP32[length >> 2] = numBytesWrittenExclNull;
+    };
+    var _glGetShaderPrecisionFormat = function _glGetShaderPrecisionFormat(shaderType, precisionType, range, precision) {
+      var result = GLctx.getShaderPrecisionFormat(shaderType, precisionType);
+      HEAP32[range >> 2] = result.rangeMin;
+      HEAP32[range + 4 >> 2] = result.rangeMax;
+      HEAP32[precision >> 2] = result.precision;
+    };
+    var _glGetShaderiv = function _glGetShaderiv(shader, pname, p) {
+      if (!p) {
+        GL.recordError(1281);
+        return;
+      }
+      if (pname == 35716) {
+        var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
+        if (log === null) log = "(unknown error)";
+        var logLength = log ? log.length + 1 : 0;
+        HEAP32[p >> 2] = logLength;
+      } else if (pname == 35720) {
+        var source = GLctx.getShaderSource(GL.shaders[shader]);
+        var sourceLength = source ? source.length + 1 : 0;
+        HEAP32[p >> 2] = sourceLength;
+      } else {
+        HEAP32[p >> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname);
+      }
+    };
+    var stringToNewUTF8 = function stringToNewUTF8(str) {
+      var size = lengthBytesUTF8(str) + 1;
+      var ret = _malloc(size);
+      if (ret) stringToUTF8(str, ret, size);
+      return ret;
+    };
+    var _glGetString = function _glGetString(name_) {
+      var ret = GL.stringCache[name_];
+      if (!ret) {
+        switch (name_) {
+          case 7939:
+            ret = stringToNewUTF8(webglGetExtensions().join(" "));
+            break;
+          case 7936:
+          case 7937:
+          case 37445:
+          case 37446:
+            var s = GLctx.getParameter(name_);
+            if (!s) {
+              GL.recordError(1280);
+            }
+            ret = s ? stringToNewUTF8(s) : 0;
+            break;
+          case 7938:
+            var glVersion = GLctx.getParameter(7938);
+            if (GL.currentContext.version >= 2) glVersion = "OpenGL ES 3.0 (".concat(glVersion, ")");else {
+              glVersion = "OpenGL ES 2.0 (".concat(glVersion, ")");
+            }
+            ret = stringToNewUTF8(glVersion);
+            break;
+          case 35724:
+            var glslVersion = GLctx.getParameter(35724);
+            var ver_re = /^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/;
+            var ver_num = glslVersion.match(ver_re);
+            if (ver_num !== null) {
+              if (ver_num[1].length == 3) ver_num[1] = ver_num[1] + "0";
+              glslVersion = "OpenGL ES GLSL ES ".concat(ver_num[1], " (").concat(glslVersion, ")");
+            }
+            ret = stringToNewUTF8(glslVersion);
+            break;
+          default:
+            GL.recordError(1280);
+        }
+        GL.stringCache[name_] = ret;
+      }
+      return ret;
+    };
+    var _glGetStringi = function _glGetStringi(name, index) {
+      if (GL.currentContext.version < 2) {
+        GL.recordError(1282);
+        return 0;
+      }
+      var stringiCache = GL.stringiCache[name];
+      if (stringiCache) {
+        if (index < 0 || index >= stringiCache.length) {
+          GL.recordError(1281);
+          return 0;
+        }
+        return stringiCache[index];
+      }
+      switch (name) {
+        case 7939:
+          var exts = webglGetExtensions().map(stringToNewUTF8);
+          stringiCache = GL.stringiCache[name] = exts;
+          if (index < 0 || index >= stringiCache.length) {
+            GL.recordError(1281);
+            return 0;
+          }
+          return stringiCache[index];
+        default:
+          GL.recordError(1280);
+          return 0;
+      }
+    };
+    var jstoi_q = function jstoi_q(str) {
+      return parseInt(str);
+    };
+    var webglGetLeftBracePos = function webglGetLeftBracePos(name) {
+      return name.slice(-1) == "]" && name.lastIndexOf("[");
+    };
+    var webglPrepareUniformLocationsBeforeFirstUse = function webglPrepareUniformLocationsBeforeFirstUse(program) {
+      var uniformLocsById = program.uniformLocsById,
+        uniformSizeAndIdsByName = program.uniformSizeAndIdsByName,
+        i,
+        j;
+      if (!uniformLocsById) {
+        program.uniformLocsById = uniformLocsById = {};
+        program.uniformArrayNamesById = {};
+        for (i = 0; i < GLctx.getProgramParameter(program, 35718); ++i) {
+          var u = GLctx.getActiveUniform(program, i);
+          var nm = u.name;
+          var sz = u.size;
+          var lb = webglGetLeftBracePos(nm);
+          var arrayName = lb > 0 ? nm.slice(0, lb) : nm;
+          var id = program.uniformIdCounter;
+          program.uniformIdCounter += sz;
+          uniformSizeAndIdsByName[arrayName] = [sz, id];
+          for (j = 0; j < sz; ++j) {
+            uniformLocsById[id] = j;
+            program.uniformArrayNamesById[id++] = arrayName;
+          }
+        }
+      }
+    };
+    var _glGetUniformLocation = function _glGetUniformLocation(program, name) {
+      name = UTF8ToString(name);
+      if (program = GL.programs[program]) {
+        webglPrepareUniformLocationsBeforeFirstUse(program);
+        var uniformLocsById = program.uniformLocsById;
+        var arrayIndex = 0;
+        var uniformBaseName = name;
+        var leftBrace = webglGetLeftBracePos(name);
+        if (leftBrace > 0) {
+          arrayIndex = jstoi_q(name.slice(leftBrace + 1)) >>> 0;
+          uniformBaseName = name.slice(0, leftBrace);
+        }
+        var sizeAndId = program.uniformSizeAndIdsByName[uniformBaseName];
+        if (sizeAndId && arrayIndex < sizeAndId[0]) {
+          arrayIndex += sizeAndId[1];
+          if (uniformLocsById[arrayIndex] = uniformLocsById[arrayIndex] || GLctx.getUniformLocation(program, name)) {
+            return arrayIndex;
+          }
+        }
+      } else {
+        GL.recordError(1281);
+      }
+      return -1;
+    };
+    var _glInvalidateFramebuffer = function _glInvalidateFramebuffer(target, numAttachments, attachments) {
+      var list = tempFixedLengthArray[numAttachments];
+      for (var i = 0; i < numAttachments; i++) {
+        list[i] = HEAP32[attachments + i * 4 >> 2];
+      }
+      GLctx.invalidateFramebuffer(target, list);
+    };
+    var _glInvalidateSubFramebuffer = function _glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height) {
+      var list = tempFixedLengthArray[numAttachments];
+      for (var i = 0; i < numAttachments; i++) {
+        list[i] = HEAP32[attachments + i * 4 >> 2];
+      }
+      GLctx.invalidateSubFramebuffer(target, list, x, y, width, height);
+    };
+    var _glIsSync = function _glIsSync(sync) {
+      return GLctx.isSync(GL.syncs[sync]);
+    };
+    var _glIsTexture = function _glIsTexture(id) {
+      var texture = GL.textures[id];
+      if (!texture) return 0;
+      return GLctx.isTexture(texture);
+    };
+    var _glLineWidth = function _glLineWidth(x0) {
+      return GLctx.lineWidth(x0);
+    };
+    var _glLinkProgram = function _glLinkProgram(program) {
+      program = GL.programs[program];
+      GLctx.linkProgram(program);
+      program.uniformLocsById = 0;
+      program.uniformSizeAndIdsByName = {};
+    };
+    var _glMultiDrawArraysInstancedBaseInstanceWEBGL = function _glMultiDrawArraysInstancedBaseInstanceWEBGL(mode, firsts, counts, instanceCounts, baseInstances, drawCount) {
+      GLctx.mdibvbi["multiDrawArraysInstancedBaseInstanceWEBGL"](mode, HEAP32, firsts >> 2, HEAP32, counts >> 2, HEAP32, instanceCounts >> 2, HEAPU32, baseInstances >> 2, drawCount);
+    };
+    var _glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL = function _glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL(mode, counts, type, offsets, instanceCounts, baseVertices, baseInstances, drawCount) {
+      GLctx.mdibvbi["multiDrawElementsInstancedBaseVertexBaseInstanceWEBGL"](mode, HEAP32, counts >> 2, type, HEAP32, offsets >> 2, HEAP32, instanceCounts >> 2, HEAP32, baseVertices >> 2, HEAPU32, baseInstances >> 2, drawCount);
+    };
+    var _glPixelStorei = function _glPixelStorei(pname, param) {
+      if (pname == 3317) {
+        GL.unpackAlignment = param;
+      }
+      GLctx.pixelStorei(pname, param);
+    };
+    var _glReadBuffer = function _glReadBuffer(x0) {
+      return GLctx.readBuffer(x0);
+    };
+    var computeUnpackAlignedImageSize = function computeUnpackAlignedImageSize(width, height, sizePerPixel, alignment) {
+      function roundedToNextMultipleOf(x, y) {
+        return x + y - 1 & -y;
+      }
+      var plainRowSize = width * sizePerPixel;
+      var alignedRowSize = roundedToNextMultipleOf(plainRowSize, alignment);
+      return height * alignedRowSize;
+    };
+    var colorChannelsInGlTextureFormat = function colorChannelsInGlTextureFormat(format) {
+      var colorChannels = {
+        5: 3,
+        6: 4,
+        8: 2,
+        29502: 3,
+        29504: 4,
+        26917: 2,
+        26918: 2,
+        29846: 3,
+        29847: 4
+      };
+      return colorChannels[format - 6402] || 1;
+    };
+    var heapObjectForWebGLType = function heapObjectForWebGLType(type) {
+      type -= 5120;
+      if (type == 0) return HEAP8;
+      if (type == 1) return HEAPU8;
+      if (type == 2) return HEAP16;
+      if (type == 4) return HEAP32;
+      if (type == 6) return HEAPF32;
+      if (type == 5 || type == 28922 || type == 28520 || type == 30779 || type == 30782) return HEAPU32;
+      return HEAPU16;
+    };
+    var toTypedArrayIndex = function toTypedArrayIndex(pointer, heap) {
+      return pointer >>> 31 - Math.clz32(heap.BYTES_PER_ELEMENT);
+    };
+    var emscriptenWebGLGetTexPixelData = function emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) {
+      var heap = heapObjectForWebGLType(type);
+      var sizePerPixel = colorChannelsInGlTextureFormat(format) * heap.BYTES_PER_ELEMENT;
+      var bytes = computeUnpackAlignedImageSize(width, height, sizePerPixel, GL.unpackAlignment);
+      return heap.subarray(toTypedArrayIndex(pixels, heap), toTypedArrayIndex(pixels + bytes, heap));
+    };
+    var _glReadPixels = function _glReadPixels(x, y, width, height, format, type, pixels) {
+      if (GL.currentContext.version >= 2) {
+        if (GLctx.currentPixelPackBufferBinding) {
+          GLctx.readPixels(x, y, width, height, format, type, pixels);
+          return;
+        }
+        var heap = heapObjectForWebGLType(type);
+        var target = toTypedArrayIndex(pixels, heap);
+        GLctx.readPixels(x, y, width, height, format, type, heap, target);
+        return;
+      }
+      var pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels);
+      if (!pixelData) {
+        GL.recordError(1280);
+        return;
+      }
+      GLctx.readPixels(x, y, width, height, format, type, pixelData);
+    };
+    var _glRenderbufferStorage = function _glRenderbufferStorage(x0, x1, x2, x3) {
+      return GLctx.renderbufferStorage(x0, x1, x2, x3);
+    };
+    var _glRenderbufferStorageMultisample = function _glRenderbufferStorageMultisample(x0, x1, x2, x3, x4) {
+      return GLctx.renderbufferStorageMultisample(x0, x1, x2, x3, x4);
+    };
+    var _glSamplerParameterf = function _glSamplerParameterf(sampler, pname, param) {
+      GLctx.samplerParameterf(GL.samplers[sampler], pname, param);
+    };
+    var _glSamplerParameteri = function _glSamplerParameteri(sampler, pname, param) {
+      GLctx.samplerParameteri(GL.samplers[sampler], pname, param);
+    };
+    var _glSamplerParameteriv = function _glSamplerParameteriv(sampler, pname, params) {
+      var param = HEAP32[params >> 2];
+      GLctx.samplerParameteri(GL.samplers[sampler], pname, param);
+    };
+    var _glScissor = function _glScissor(x0, x1, x2, x3) {
+      return GLctx.scissor(x0, x1, x2, x3);
+    };
+    var _glShaderSource = function _glShaderSource(shader, count, string, length) {
+      var source = GL.getSource(shader, count, string, length);
+      GLctx.shaderSource(GL.shaders[shader], source);
+    };
+    var _glStencilFunc = function _glStencilFunc(x0, x1, x2) {
+      return GLctx.stencilFunc(x0, x1, x2);
+    };
+    var _glStencilFuncSeparate = function _glStencilFuncSeparate(x0, x1, x2, x3) {
+      return GLctx.stencilFuncSeparate(x0, x1, x2, x3);
+    };
+    var _glStencilMask = function _glStencilMask(x0) {
+      return GLctx.stencilMask(x0);
+    };
+    var _glStencilMaskSeparate = function _glStencilMaskSeparate(x0, x1) {
+      return GLctx.stencilMaskSeparate(x0, x1);
+    };
+    var _glStencilOp = function _glStencilOp(x0, x1, x2) {
+      return GLctx.stencilOp(x0, x1, x2);
+    };
+    var _glStencilOpSeparate = function _glStencilOpSeparate(x0, x1, x2, x3) {
+      return GLctx.stencilOpSeparate(x0, x1, x2, x3);
+    };
+    var _glTexImage2D = function _glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels) {
+      if (GL.currentContext.version >= 2) {
+        if (GLctx.currentPixelUnpackBufferBinding) {
+          GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
+          return;
+        }
+        if (pixels) {
+          var heap = heapObjectForWebGLType(type);
+          var index = toTypedArrayIndex(pixels, heap);
+          GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, heap, index);
+          return;
+        }
+      }
+      var pixelData = pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels) : null;
+      GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixelData);
+    };
+    var _glTexParameterf = function _glTexParameterf(x0, x1, x2) {
+      return GLctx.texParameterf(x0, x1, x2);
+    };
+    var _glTexParameterfv = function _glTexParameterfv(target, pname, params) {
+      var param = HEAPF32[params >> 2];
+      GLctx.texParameterf(target, pname, param);
+    };
+    var _glTexParameteri = function _glTexParameteri(x0, x1, x2) {
+      return GLctx.texParameteri(x0, x1, x2);
+    };
+    var _glTexParameteriv = function _glTexParameteriv(target, pname, params) {
+      var param = HEAP32[params >> 2];
+      GLctx.texParameteri(target, pname, param);
+    };
+    var _glTexStorage2D = function _glTexStorage2D(x0, x1, x2, x3, x4) {
+      return GLctx.texStorage2D(x0, x1, x2, x3, x4);
+    };
+    var _glTexSubImage2D = function _glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) {
+      if (GL.currentContext.version >= 2) {
+        if (GLctx.currentPixelUnpackBufferBinding) {
+          GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+          return;
+        }
+        if (pixels) {
+          var heap = heapObjectForWebGLType(type);
+          GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, heap, toTypedArrayIndex(pixels, heap));
+          return;
+        }
+      }
+      var pixelData = pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels) : null;
+      GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixelData);
+    };
+    var webglGetUniformLocation = function webglGetUniformLocation(location) {
+      var p = GLctx.currentProgram;
+      if (p) {
+        var webglLoc = p.uniformLocsById[location];
+        if (typeof webglLoc == "number") {
+          p.uniformLocsById[location] = webglLoc = GLctx.getUniformLocation(p, p.uniformArrayNamesById[location] + (webglLoc > 0 ? "[".concat(webglLoc, "]") : ""));
+        }
+        return webglLoc;
+      } else {
+        GL.recordError(1282);
+      }
+    };
+    var _glUniform1f = function _glUniform1f(location, v0) {
+      GLctx.uniform1f(webglGetUniformLocation(location), v0);
+    };
+    var miniTempWebGLFloatBuffers = [];
+    var _glUniform1fv = function _glUniform1fv(location, count, value) {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniform1fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count);
+        return;
+      }
+      if (count <= 288) {
+        var view = miniTempWebGLFloatBuffers[count];
+        for (var i = 0; i < count; ++i) {
+          view[i] = HEAPF32[value + 4 * i >> 2];
+        }
+      } else {
+        var view = HEAPF32.subarray(value >> 2, value + count * 4 >> 2);
+      }
+      GLctx.uniform1fv(webglGetUniformLocation(location), view);
+    };
+    var _glUniform1i = function _glUniform1i(location, v0) {
+      GLctx.uniform1i(webglGetUniformLocation(location), v0);
+    };
+    var miniTempWebGLIntBuffers = [];
+    var _glUniform1iv = function _glUniform1iv(location, count, value) {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniform1iv(webglGetUniformLocation(location), HEAP32, value >> 2, count);
+        return;
+      }
+      if (count <= 288) {
+        var view = miniTempWebGLIntBuffers[count];
+        for (var i = 0; i < count; ++i) {
+          view[i] = HEAP32[value + 4 * i >> 2];
+        }
+      } else {
+        var view = HEAP32.subarray(value >> 2, value + count * 4 >> 2);
+      }
+      GLctx.uniform1iv(webglGetUniformLocation(location), view);
+    };
+    var _glUniform2f = function _glUniform2f(location, v0, v1) {
+      GLctx.uniform2f(webglGetUniformLocation(location), v0, v1);
+    };
+    var _glUniform2fv = function _glUniform2fv(location, count, value) {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniform2fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 2);
+        return;
+      }
+      if (count <= 144) {
+        var view = miniTempWebGLFloatBuffers[2 * count];
+        for (var i = 0; i < 2 * count; i += 2) {
+          view[i] = HEAPF32[value + 4 * i >> 2];
+          view[i + 1] = HEAPF32[value + (4 * i + 4) >> 2];
+        }
+      } else {
+        var view = HEAPF32.subarray(value >> 2, value + count * 8 >> 2);
+      }
+      GLctx.uniform2fv(webglGetUniformLocation(location), view);
+    };
+    var _glUniform2i = function _glUniform2i(location, v0, v1) {
+      GLctx.uniform2i(webglGetUniformLocation(location), v0, v1);
+    };
+    var _glUniform2iv = function _glUniform2iv(location, count, value) {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniform2iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 2);
+        return;
+      }
+      if (count <= 144) {
+        var view = miniTempWebGLIntBuffers[2 * count];
+        for (var i = 0; i < 2 * count; i += 2) {
+          view[i] = HEAP32[value + 4 * i >> 2];
+          view[i + 1] = HEAP32[value + (4 * i + 4) >> 2];
+        }
+      } else {
+        var view = HEAP32.subarray(value >> 2, value + count * 8 >> 2);
+      }
+      GLctx.uniform2iv(webglGetUniformLocation(location), view);
+    };
+    var _glUniform3f = function _glUniform3f(location, v0, v1, v2) {
+      GLctx.uniform3f(webglGetUniformLocation(location), v0, v1, v2);
+    };
+    var _glUniform3fv = function _glUniform3fv(location, count, value) {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniform3fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 3);
+        return;
+      }
+      if (count <= 96) {
+        var view = miniTempWebGLFloatBuffers[3 * count];
+        for (var i = 0; i < 3 * count; i += 3) {
+          view[i] = HEAPF32[value + 4 * i >> 2];
+          view[i + 1] = HEAPF32[value + (4 * i + 4) >> 2];
+          view[i + 2] = HEAPF32[value + (4 * i + 8) >> 2];
+        }
+      } else {
+        var view = HEAPF32.subarray(value >> 2, value + count * 12 >> 2);
+      }
+      GLctx.uniform3fv(webglGetUniformLocation(location), view);
+    };
+    var _glUniform3i = function _glUniform3i(location, v0, v1, v2) {
+      GLctx.uniform3i(webglGetUniformLocation(location), v0, v1, v2);
+    };
+    var _glUniform3iv = function _glUniform3iv(location, count, value) {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniform3iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 3);
+        return;
+      }
+      if (count <= 96) {
+        var view = miniTempWebGLIntBuffers[3 * count];
+        for (var i = 0; i < 3 * count; i += 3) {
+          view[i] = HEAP32[value + 4 * i >> 2];
+          view[i + 1] = HEAP32[value + (4 * i + 4) >> 2];
+          view[i + 2] = HEAP32[value + (4 * i + 8) >> 2];
+        }
+      } else {
+        var view = HEAP32.subarray(value >> 2, value + count * 12 >> 2);
+      }
+      GLctx.uniform3iv(webglGetUniformLocation(location), view);
+    };
+    var _glUniform4f = function _glUniform4f(location, v0, v1, v2, v3) {
+      GLctx.uniform4f(webglGetUniformLocation(location), v0, v1, v2, v3);
+    };
+    var _glUniform4fv = function _glUniform4fv(location, count, value) {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniform4fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 4);
+        return;
+      }
+      if (count <= 72) {
+        var view = miniTempWebGLFloatBuffers[4 * count];
+        var heap = HEAPF32;
+        value = value >> 2;
+        for (var i = 0; i < 4 * count; i += 4) {
+          var dst = value + i;
+          view[i] = heap[dst];
+          view[i + 1] = heap[dst + 1];
+          view[i + 2] = heap[dst + 2];
+          view[i + 3] = heap[dst + 3];
+        }
+      } else {
+        var view = HEAPF32.subarray(value >> 2, value + count * 16 >> 2);
+      }
+      GLctx.uniform4fv(webglGetUniformLocation(location), view);
+    };
+    var _glUniform4i = function _glUniform4i(location, v0, v1, v2, v3) {
+      GLctx.uniform4i(webglGetUniformLocation(location), v0, v1, v2, v3);
+    };
+    var _glUniform4iv = function _glUniform4iv(location, count, value) {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniform4iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 4);
+        return;
+      }
+      if (count <= 72) {
+        var view = miniTempWebGLIntBuffers[4 * count];
+        for (var i = 0; i < 4 * count; i += 4) {
+          view[i] = HEAP32[value + 4 * i >> 2];
+          view[i + 1] = HEAP32[value + (4 * i + 4) >> 2];
+          view[i + 2] = HEAP32[value + (4 * i + 8) >> 2];
+          view[i + 3] = HEAP32[value + (4 * i + 12) >> 2];
+        }
+      } else {
+        var view = HEAP32.subarray(value >> 2, value + count * 16 >> 2);
+      }
+      GLctx.uniform4iv(webglGetUniformLocation(location), view);
+    };
+    var _glUniformMatrix2fv = function _glUniformMatrix2fv(location, count, transpose, value) {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 4);
+        return;
+      }
+      if (count <= 72) {
+        var view = miniTempWebGLFloatBuffers[4 * count];
+        for (var i = 0; i < 4 * count; i += 4) {
+          view[i] = HEAPF32[value + 4 * i >> 2];
+          view[i + 1] = HEAPF32[value + (4 * i + 4) >> 2];
+          view[i + 2] = HEAPF32[value + (4 * i + 8) >> 2];
+          view[i + 3] = HEAPF32[value + (4 * i + 12) >> 2];
+        }
+      } else {
+        var view = HEAPF32.subarray(value >> 2, value + count * 16 >> 2);
+      }
+      GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, view);
+    };
+    var _glUniformMatrix3fv = function _glUniformMatrix3fv(location, count, transpose, value) {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 9);
+        return;
+      }
+      if (count <= 32) {
+        var view = miniTempWebGLFloatBuffers[9 * count];
+        for (var i = 0; i < 9 * count; i += 9) {
+          view[i] = HEAPF32[value + 4 * i >> 2];
+          view[i + 1] = HEAPF32[value + (4 * i + 4) >> 2];
+          view[i + 2] = HEAPF32[value + (4 * i + 8) >> 2];
+          view[i + 3] = HEAPF32[value + (4 * i + 12) >> 2];
+          view[i + 4] = HEAPF32[value + (4 * i + 16) >> 2];
+          view[i + 5] = HEAPF32[value + (4 * i + 20) >> 2];
+          view[i + 6] = HEAPF32[value + (4 * i + 24) >> 2];
+          view[i + 7] = HEAPF32[value + (4 * i + 28) >> 2];
+          view[i + 8] = HEAPF32[value + (4 * i + 32) >> 2];
+        }
+      } else {
+        var view = HEAPF32.subarray(value >> 2, value + count * 36 >> 2);
+      }
+      GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, view);
+    };
+    var _glUniformMatrix4fv = function _glUniformMatrix4fv(location, count, transpose, value) {
+      if (GL.currentContext.version >= 2) {
+        count && GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 16);
+        return;
+      }
+      if (count <= 18) {
+        var view = miniTempWebGLFloatBuffers[16 * count];
+        var heap = HEAPF32;
+        value = value >> 2;
+        for (var i = 0; i < 16 * count; i += 16) {
+          var dst = value + i;
+          view[i] = heap[dst];
+          view[i + 1] = heap[dst + 1];
+          view[i + 2] = heap[dst + 2];
+          view[i + 3] = heap[dst + 3];
+          view[i + 4] = heap[dst + 4];
+          view[i + 5] = heap[dst + 5];
+          view[i + 6] = heap[dst + 6];
+          view[i + 7] = heap[dst + 7];
+          view[i + 8] = heap[dst + 8];
+          view[i + 9] = heap[dst + 9];
+          view[i + 10] = heap[dst + 10];
+          view[i + 11] = heap[dst + 11];
+          view[i + 12] = heap[dst + 12];
+          view[i + 13] = heap[dst + 13];
+          view[i + 14] = heap[dst + 14];
+          view[i + 15] = heap[dst + 15];
+        }
+      } else {
+        var view = HEAPF32.subarray(value >> 2, value + count * 64 >> 2);
+      }
+      GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, view);
+    };
+    var _glUseProgram = function _glUseProgram(program) {
+      program = GL.programs[program];
+      GLctx.useProgram(program);
+      GLctx.currentProgram = program;
+    };
+    var _glVertexAttrib1f = function _glVertexAttrib1f(x0, x1) {
+      return GLctx.vertexAttrib1f(x0, x1);
+    };
+    var _glVertexAttrib2fv = function _glVertexAttrib2fv(index, v) {
+      GLctx.vertexAttrib2f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2]);
+    };
+    var _glVertexAttrib3fv = function _glVertexAttrib3fv(index, v) {
+      GLctx.vertexAttrib3f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2], HEAPF32[v + 8 >> 2]);
+    };
+    var _glVertexAttrib4fv = function _glVertexAttrib4fv(index, v) {
+      GLctx.vertexAttrib4f(index, HEAPF32[v >> 2], HEAPF32[v + 4 >> 2], HEAPF32[v + 8 >> 2], HEAPF32[v + 12 >> 2]);
+    };
+    var _glVertexAttribDivisor = function _glVertexAttribDivisor(index, divisor) {
+      GLctx.vertexAttribDivisor(index, divisor);
+    };
+    var _glVertexAttribIPointer = function _glVertexAttribIPointer(index, size, type, stride, ptr) {
+      GLctx.vertexAttribIPointer(index, size, type, stride, ptr);
+    };
+    var _glVertexAttribPointer = function _glVertexAttribPointer(index, size, type, normalized, stride, ptr) {
+      GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
+    };
+    var _glViewport = function _glViewport(x0, x1, x2, x3) {
+      return GLctx.viewport(x0, x1, x2, x3);
+    };
+    var _glWaitSync = function _glWaitSync(sync, flags, timeout) {
+      timeout = Number(timeout);
+      GLctx.waitSync(GL.syncs[sync], flags, timeout);
+    };
+    var isLeapYear = function isLeapYear(year) {
+      return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    };
+    var arraySum = function arraySum(array, index) {
+      var sum = 0;
+      for (var i = 0; i <= index; sum += array[i++]) {}
+      return sum;
+    };
+    var MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    var MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    var addDays = function addDays(date, days) {
+      var newDate = new Date(date.getTime());
+      while (days > 0) {
+        var leap = isLeapYear(newDate.getFullYear());
+        var currentMonth = newDate.getMonth();
+        var daysInCurrentMonth = (leap ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR)[currentMonth];
+        if (days > daysInCurrentMonth - newDate.getDate()) {
+          days -= daysInCurrentMonth - newDate.getDate() + 1;
+          newDate.setDate(1);
+          if (currentMonth < 11) {
+            newDate.setMonth(currentMonth + 1);
+          } else {
+            newDate.setMonth(0);
+            newDate.setFullYear(newDate.getFullYear() + 1);
+          }
+        } else {
+          newDate.setDate(newDate.getDate() + days);
+          return newDate;
+        }
+      }
+      return newDate;
+    };
+    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;
+    }
+    var writeArrayToMemory = function writeArrayToMemory(array, buffer) {
+      HEAP8.set(array, buffer);
+    };
+    var _strftime = function _strftime(s, maxsize, format, tm) {
+      var tm_zone = HEAPU32[tm + 40 >> 2];
+      var date = {
+        tm_sec: HEAP32[tm >> 2],
+        tm_min: HEAP32[tm + 4 >> 2],
+        tm_hour: HEAP32[tm + 8 >> 2],
+        tm_mday: HEAP32[tm + 12 >> 2],
+        tm_mon: HEAP32[tm + 16 >> 2],
+        tm_year: HEAP32[tm + 20 >> 2],
+        tm_wday: HEAP32[tm + 24 >> 2],
+        tm_yday: HEAP32[tm + 28 >> 2],
+        tm_isdst: HEAP32[tm + 32 >> 2],
+        tm_gmtoff: HEAP32[tm + 36 >> 2],
+        tm_zone: tm_zone ? UTF8ToString(tm_zone) : ""
+      };
+      var pattern = UTF8ToString(format);
+      var EXPANSION_RULES_1 = {
+        "%c": "%a %b %d %H:%M:%S %Y",
+        "%D": "%m/%d/%y",
+        "%F": "%Y-%m-%d",
+        "%h": "%b",
+        "%r": "%I:%M:%S %p",
+        "%R": "%H:%M",
+        "%T": "%H:%M:%S",
+        "%x": "%m/%d/%y",
+        "%X": "%H:%M:%S",
+        "%Ec": "%c",
+        "%EC": "%C",
+        "%Ex": "%m/%d/%y",
+        "%EX": "%H:%M:%S",
+        "%Ey": "%y",
+        "%EY": "%Y",
+        "%Od": "%d",
+        "%Oe": "%e",
+        "%OH": "%H",
+        "%OI": "%I",
+        "%Om": "%m",
+        "%OM": "%M",
+        "%OS": "%S",
+        "%Ou": "%u",
+        "%OU": "%U",
+        "%OV": "%V",
+        "%Ow": "%w",
+        "%OW": "%W",
+        "%Oy": "%y"
+      };
+      for (var rule in EXPANSION_RULES_1) {
+        pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]);
+      }
+      var WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+      var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+      function leadingSomething(value, digits, character) {
+        var str = typeof value == "number" ? value.toString() : value || "";
+        while (str.length < digits) {
+          str = character[0] + str;
+        }
+        return str;
+      }
+      function leadingNulls(value, digits) {
+        return leadingSomething(value, digits, "0");
+      }
+      function compareByDay(date1, date2) {
+        function sgn(value) {
+          return value < 0 ? -1 : value > 0 ? 1 : 0;
+        }
+        var compare;
+        if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
+          if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
+            compare = sgn(date1.getDate() - date2.getDate());
+          }
+        }
+        return compare;
+      }
+      function getFirstWeekStartDate(janFourth) {
+        switch (janFourth.getDay()) {
+          case 0:
+            return new Date(janFourth.getFullYear() - 1, 11, 29);
+          case 1:
+            return janFourth;
+          case 2:
+            return new Date(janFourth.getFullYear(), 0, 3);
+          case 3:
+            return new Date(janFourth.getFullYear(), 0, 2);
+          case 4:
+            return new Date(janFourth.getFullYear(), 0, 1);
+          case 5:
+            return new Date(janFourth.getFullYear() - 1, 11, 31);
+          case 6:
+            return new Date(janFourth.getFullYear() - 1, 11, 30);
+        }
+      }
+      function getWeekBasedYear(date) {
+        var thisDate = addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
+        var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
+        var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
+        var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
+        var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
+        if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
+          if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
+            return thisDate.getFullYear() + 1;
+          }
+          return thisDate.getFullYear();
+        }
+        return thisDate.getFullYear() - 1;
+      }
+      var EXPANSION_RULES_2 = {
+        "%a": function a(date) {
+          return WEEKDAYS[date.tm_wday].substring(0, 3);
+        },
+        "%A": function A(date) {
+          return WEEKDAYS[date.tm_wday];
+        },
+        "%b": function b(date) {
+          return MONTHS[date.tm_mon].substring(0, 3);
+        },
+        "%B": function B(date) {
+          return MONTHS[date.tm_mon];
+        },
+        "%C": function C(date) {
+          var year = date.tm_year + 1900;
+          return leadingNulls(year / 100 | 0, 2);
+        },
+        "%d": function d(date) {
+          return leadingNulls(date.tm_mday, 2);
+        },
+        "%e": function e(date) {
+          return leadingSomething(date.tm_mday, 2, " ");
+        },
+        "%g": function g(date) {
+          return getWeekBasedYear(date).toString().substring(2);
+        },
+        "%G": getWeekBasedYear,
+        "%H": function H(date) {
+          return leadingNulls(date.tm_hour, 2);
+        },
+        "%I": function I(date) {
+          var twelveHour = date.tm_hour;
+          if (twelveHour == 0) twelveHour = 12;else if (twelveHour > 12) twelveHour -= 12;
+          return leadingNulls(twelveHour, 2);
+        },
+        "%j": function j(date) {
+          return leadingNulls(date.tm_mday + arraySum(isLeapYear(date.tm_year + 1900) ? MONTH_DAYS_LEAP : MONTH_DAYS_REGULAR, date.tm_mon - 1), 3);
+        },
+        "%m": function m(date) {
+          return leadingNulls(date.tm_mon + 1, 2);
+        },
+        "%M": function M(date) {
+          return leadingNulls(date.tm_min, 2);
+        },
+        "%n": function n() {
+          return "\n";
+        },
+        "%p": function p(date) {
+          if (date.tm_hour >= 0 && date.tm_hour < 12) {
+            return "AM";
+          }
+          return "PM";
+        },
+        "%S": function S(date) {
+          return leadingNulls(date.tm_sec, 2);
+        },
+        "%t": function t() {
+          return "\t";
+        },
+        "%u": function u(date) {
+          return date.tm_wday || 7;
+        },
+        "%U": function U(date) {
+          var days = date.tm_yday + 7 - date.tm_wday;
+          return leadingNulls(Math.floor(days / 7), 2);
+        },
+        "%V": function V(date) {
+          var val = Math.floor((date.tm_yday + 7 - (date.tm_wday + 6) % 7) / 7);
+          if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) {
+            val++;
+          }
+          if (!val) {
+            val = 52;
+            var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7;
+            if (dec31 == 4 || dec31 == 5 && isLeapYear(date.tm_year % 400 - 1)) {
+              val++;
+            }
+          } else if (val == 53) {
+            var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7;
+            if (jan1 != 4 && (jan1 != 3 || !isLeapYear(date.tm_year))) val = 1;
+          }
+          return leadingNulls(val, 2);
+        },
+        "%w": function w(date) {
+          return date.tm_wday;
+        },
+        "%W": function W(date) {
+          var days = date.tm_yday + 7 - (date.tm_wday + 6) % 7;
+          return leadingNulls(Math.floor(days / 7), 2);
+        },
+        "%y": function y(date) {
+          return (date.tm_year + 1900).toString().substring(2);
+        },
+        "%Y": function Y(date) {
+          return date.tm_year + 1900;
+        },
+        "%z": function z(date) {
+          var off = date.tm_gmtoff;
+          var ahead = off >= 0;
+          off = Math.abs(off) / 60;
+          off = off / 60 * 100 + off % 60;
+          return (ahead ? "+" : "-") + String("0000" + off).slice(-4);
+        },
+        "%Z": function Z(date) {
+          return date.tm_zone;
+        },
+        "%%": function _() {
+          return "%";
+        }
+      };
+      pattern = pattern.replace(/%%/g, "\0\0");
+      for (var rule in EXPANSION_RULES_2) {
+        if (pattern.includes(rule)) {
+          pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date));
+        }
+      }
+      pattern = pattern.replace(/\0\0/g, "%");
+      var bytes = intArrayFromString(pattern, false);
+      if (bytes.length > maxsize) {
+        return 0;
+      }
+      writeArrayToMemory(bytes, s);
+      return bytes.length - 1;
+    };
+    var _strftime_l = function _strftime_l(s, maxsize, format, tm, loc) {
+      return _strftime(s, maxsize, format, tm);
+    };
+    InternalError = Module["InternalError"] = /*#__PURE__*/function (_Error) {
+      function InternalError(message) {
+        var _this;
+        _classCallCheck(this, InternalError);
+        _this = _callSuper(this, InternalError, [message]);
+        _this.name = "InternalError";
+        return _this;
+      }
+      _inherits(InternalError, _Error);
+      return _createClass(InternalError);
+    }( /*#__PURE__*/_wrapNativeSuper(Error));
+    embind_init_charCodes();
+    BindingError = Module["BindingError"] = /*#__PURE__*/function (_Error2) {
+      function BindingError(message) {
+        var _this2;
+        _classCallCheck(this, BindingError);
+        _this2 = _callSuper(this, BindingError, [message]);
+        _this2.name = "BindingError";
+        return _this2;
+      }
+      _inherits(BindingError, _Error2);
+      return _createClass(BindingError);
+    }( /*#__PURE__*/_wrapNativeSuper(Error));
+    init_ClassHandle();
+    init_embind();
+    init_RegisteredPointer();
+    UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError");
+    init_emval();
+    var GLctx;
+    for (var i = 0; i < 32; ++i) tempFixedLengthArray.push(new Array(i));
+    var miniTempWebGLFloatBuffersStorage = new Float32Array(288);
+    for (var i = 0; i < 288; ++i) {
+      miniTempWebGLFloatBuffers[i] = miniTempWebGLFloatBuffersStorage.subarray(0, i);
+    }
+    var miniTempWebGLIntBuffersStorage = new Int32Array(288);
+    for (var i = 0; i < 288; ++i) {
+      miniTempWebGLIntBuffers[i] = miniTempWebGLIntBuffersStorage.subarray(0, i);
+    }
+    var wasmImports = {
+      nb: __abort_js,
+      o: __embind_finalize_value_object,
+      R: __embind_register_bigint,
+      ab: __embind_register_bool,
+      g: __embind_register_class,
+      da: __embind_register_class_class_function,
+      w: __embind_register_class_constructor,
+      a: __embind_register_class_function,
+      c: __embind_register_class_property,
+      $a: __embind_register_emval,
+      n: __embind_register_enum,
+      b: __embind_register_enum_value,
+      Q: __embind_register_float,
+      y: __embind_register_integer,
+      s: __embind_register_memory_view,
+      x: __embind_register_optional,
+      I: __embind_register_smart_ptr,
+      P: __embind_register_std_string,
+      G: __embind_register_std_wstring,
+      p: __embind_register_value_object,
+      e: __embind_register_value_object_field,
+      bb: __embind_register_void,
+      lb: __emscripten_get_now_is_monotonic,
+      db: __emscripten_throw_longjmp,
+      E: __emval_as,
+      B: __emval_call,
+      l: __emval_call_method,
+      d: __emval_decref,
+      S: __emval_get_global,
+      j: __emval_get_method_caller,
+      m: __emval_get_module_property,
+      H: __emval_get_property,
+      r: __emval_incref,
+      _a: __emval_new_array,
+      D: __emval_new_cstring,
+      h: __emval_run_destructors,
+      u: __emval_take_value,
+      gb: __gmtime_js,
+      fb: __tzset_js,
+      O: _emscripten_cancel_animation_frame,
+      U: _emscripten_date_now,
+      kb: _emscripten_get_now,
+      C: _emscripten_request_animation_frame,
+      eb: _emscripten_resize_heap,
+      Za: _emscripten_webgl_make_context_current,
+      ib: _environ_get,
+      jb: _environ_sizes_get,
+      ob: _exit,
+      mb: _fd_close,
+      hb: _fd_seek,
+      T: _fd_write,
+      Mc: _glActiveTexture,
+      Nc: _glAttachShader,
+      Oc: _glBindAttribLocation,
+      Pc: _glBindBuffer,
+      N: _glBindFramebuffer,
+      Qb: _glBindRenderbuffer,
+      yb: _glBindSampler,
+      Qc: _glBindTexture,
+      jc: _glBindVertexArray,
+      lc: _glBindVertexArrayOES,
+      Rc: _glBlendColor,
+      Sc: _glBlendEquation,
+      V: _glBlendFunc,
+      Kb: _glBlitFramebuffer,
+      W: _glBufferData,
+      X: _glBufferSubData,
+      Rb: _glCheckFramebufferStatus,
+      K: _glClear,
+      M: _glClearColor,
+      L: _glClearStencil,
+      Ib: _glClientWaitSync,
+      Y: _glColorMask,
+      Z: _glCompileShader,
+      _: _glCompressedTexImage2D,
+      $: _glCompressedTexSubImage2D,
+      Hb: _glCopyBufferSubData,
+      aa: _glCopyTexSubImage2D,
+      ba: _glCreateProgram,
+      ca: _glCreateShader,
+      ea: _glCullFace,
+      fa: _glDeleteBuffers,
+      Sb: _glDeleteFramebuffers,
+      ga: _glDeleteProgram,
+      Tb: _glDeleteRenderbuffers,
+      zb: _glDeleteSamplers,
+      ha: _glDeleteShader,
+      Jb: _glDeleteSync,
+      ia: _glDeleteTextures,
+      kc: _glDeleteVertexArrays,
+      mc: _glDeleteVertexArraysOES,
+      ja: _glDepthMask,
+      ka: _glDisable,
+      la: _glDisableVertexAttribArray,
+      ma: _glDrawArrays,
+      hc: _glDrawArraysInstanced,
+      ec: _glDrawArraysInstancedBaseInstanceWEBGL,
+      cc: _glDrawBuffers,
+      na: _glDrawElements,
+      ic: _glDrawElementsInstanced,
+      fc: _glDrawElementsInstancedBaseVertexBaseInstanceWEBGL,
+      Yb: _glDrawRangeElements,
+      oa: _glEnable,
+      pa: _glEnableVertexAttribArray,
+      Eb: _glFenceSync,
+      qa: _glFinish,
+      ra: _glFlush,
+      Ub: _glFramebufferRenderbuffer,
+      Vb: _glFramebufferTexture2D,
+      sa: _glFrontFace,
+      ta: _glGenBuffers,
+      Wb: _glGenFramebuffers,
+      Xb: _glGenRenderbuffers,
+      Ab: _glGenSamplers,
+      ua: _glGenTextures,
+      gc: _glGenVertexArrays,
+      nc: _glGenVertexArraysOES,
+      Mb: _glGenerateMipmap,
+      va: _glGetBufferParameteriv,
+      wa: _glGetError,
+      xa: _glGetFloatv,
+      Nb: _glGetFramebufferAttachmentParameteriv,
+      F: _glGetIntegerv,
+      ya: _glGetProgramInfoLog,
+      za: _glGetProgramiv,
+      Ob: _glGetRenderbufferParameteriv,
+      Aa: _glGetShaderInfoLog,
+      vb: _glGetShaderPrecisionFormat,
+      Ba: _glGetShaderiv,
+      J: _glGetString,
+      Ya: _glGetStringi,
+      Ca: _glGetUniformLocation,
+      wb: _glInvalidateFramebuffer,
+      xb: _glInvalidateSubFramebuffer,
+      Fb: _glIsSync,
+      Da: _glIsTexture,
+      Ea: _glLineWidth,
+      Fa: _glLinkProgram,
+      ac: _glMultiDrawArraysInstancedBaseInstanceWEBGL,
+      bc: _glMultiDrawElementsInstancedBaseVertexBaseInstanceWEBGL,
+      Ga: _glPixelStorei,
+      dc: _glReadBuffer,
+      Ha: _glReadPixels,
+      Pb: _glRenderbufferStorage,
+      Lb: _glRenderbufferStorageMultisample,
+      Bb: _glSamplerParameterf,
+      Cb: _glSamplerParameteri,
+      Db: _glSamplerParameteriv,
+      Ia: _glScissor,
+      Ja: _glShaderSource,
+      Ka: _glStencilFunc,
+      La: _glStencilFuncSeparate,
+      Ma: _glStencilMask,
+      Na: _glStencilMaskSeparate,
+      Oa: _glStencilOp,
+      Pa: _glStencilOpSeparate,
+      Qa: _glTexImage2D,
+      Ra: _glTexParameterf,
+      Sa: _glTexParameterfv,
+      Ta: _glTexParameteri,
+      Ua: _glTexParameteriv,
+      Zb: _glTexStorage2D,
+      Va: _glTexSubImage2D,
+      Wa: _glUniform1f,
+      Xa: _glUniform1fv,
+      Ic: _glUniform1i,
+      Jc: _glUniform1iv,
+      Kc: _glUniform2f,
+      Lc: _glUniform2fv,
+      Hc: _glUniform2i,
+      Gc: _glUniform2iv,
+      Fc: _glUniform3f,
+      Ec: _glUniform3fv,
+      Dc: _glUniform3i,
+      Cc: _glUniform3iv,
+      Bc: _glUniform4f,
+      Ac: _glUniform4fv,
+      oc: _glUniform4i,
+      pc: _glUniform4iv,
+      qc: _glUniformMatrix2fv,
+      rc: _glUniformMatrix3fv,
+      sc: _glUniformMatrix4fv,
+      tc: _glUseProgram,
+      uc: _glVertexAttrib1f,
+      vc: _glVertexAttrib2fv,
+      wc: _glVertexAttrib3fv,
+      xc: _glVertexAttrib4fv,
+      _b: _glVertexAttribDivisor,
+      $b: _glVertexAttribIPointer,
+      yc: _glVertexAttribPointer,
+      zc: _glViewport,
+      Gb: _glWaitSync,
+      f: invoke_ii,
+      t: invoke_iii,
+      i: invoke_iiii,
+      z: invoke_iiiii,
+      rb: invoke_iiiiii,
+      qb: invoke_iiiiiii,
+      tb: invoke_v,
+      k: invoke_vi,
+      A: invoke_vii,
+      v: invoke_viii,
+      q: invoke_viiii,
+      pb: invoke_viiiii,
+      sb: invoke_viiiiii,
+      ub: invoke_viiiiiiiii,
+      cb: _strftime_l
+    };
+    var wasmExports = createWasm();
+    var _getTypeName = function ___getTypeName(a0) {
+      return (_getTypeName = wasmExports["Vc"])(a0);
+    };
+    var _malloc = Module["_malloc"] = function (a0) {
+      return (_malloc = Module["_malloc"] = wasmExports["Wc"])(a0);
+    };
+    var _free = Module["_free"] = function (a0) {
+      return (_free = Module["_free"] = wasmExports["Yc"])(a0);
+    };
+    var _setThrew2 = function _setThrew(a0, a1) {
+      return (_setThrew2 = wasmExports["Zc"])(a0, a1);
+    };
+    var _emscripten_stack_restore = function __emscripten_stack_restore(a0) {
+      return (_emscripten_stack_restore = wasmExports["_c"])(a0);
+    };
+    var _emscripten_stack_get_current2 = function _emscripten_stack_get_current() {
+      return (_emscripten_stack_get_current2 = wasmExports["$c"])();
+    };
+    function invoke_ii(index, a1) {
+      var sp = stackSave();
+      try {
+        return getWasmTableEntry(index)(a1);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_iii(index, a1, a2) {
+      var sp = stackSave();
+      try {
+        return getWasmTableEntry(index)(a1, a2);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_viii(index, a1, a2, a3) {
+      var sp = stackSave();
+      try {
+        getWasmTableEntry(index)(a1, a2, a3);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_vii(index, a1, a2) {
+      var sp = stackSave();
+      try {
+        getWasmTableEntry(index)(a1, a2);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_iiiii(index, a1, a2, a3, a4) {
+      var sp = stackSave();
+      try {
+        return getWasmTableEntry(index)(a1, a2, a3, a4);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_iiii(index, a1, a2, a3) {
+      var sp = stackSave();
+      try {
+        return getWasmTableEntry(index)(a1, a2, a3);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_vi(index, a1) {
+      var sp = stackSave();
+      try {
+        getWasmTableEntry(index)(a1);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_viiii(index, a1, a2, a3, a4) {
+      var sp = stackSave();
+      try {
+        getWasmTableEntry(index)(a1, a2, a3, a4);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_viiiiiiiii(index, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+      var sp = stackSave();
+      try {
+        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_v(index) {
+      var sp = stackSave();
+      try {
+        getWasmTableEntry(index)();
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_viiiiii(index, a1, a2, a3, a4, a5, a6) {
+      var sp = stackSave();
+      try {
+        getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_iiiiii(index, a1, a2, a3, a4, a5) {
+      var sp = stackSave();
+      try {
+        return getWasmTableEntry(index)(a1, a2, a3, a4, a5);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_iiiiiii(index, a1, a2, a3, a4, a5, a6) {
+      var sp = stackSave();
+      try {
+        return getWasmTableEntry(index)(a1, a2, a3, a4, a5, a6);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    function invoke_viiiii(index, a1, a2, a3, a4, a5) {
+      var sp = stackSave();
+      try {
+        getWasmTableEntry(index)(a1, a2, a3, a4, a5);
+      } catch (e) {
+        stackRestore(sp);
+        if (e !== e + 0) throw e;
+        _setThrew2(1, 0);
+      }
+    }
+    Module["GL"] = GL;
+    var calledRun;
+    dependenciesFulfilled = function runCaller() {
+      if (!calledRun) run();
+      if (!calledRun) dependenciesFulfilled = runCaller;
+    };
+    function run() {
+      if (runDependencies > 0) {
+        return;
+      }
+      preRun();
+      if (runDependencies > 0) {
+        return;
+      }
+      function doRun() {
+        if (calledRun) return;
+        calledRun = true;
+        Module["calledRun"] = true;
+        if (ABORT) return;
+        initRuntime();
+        readyPromiseResolve(Module);
+        postRun();
+      }
+      {
+        doRun();
+      }
+    }
+    run();
+    moduleRtn = readyPromise;
+    return moduleRtn;
+  };
+}();
+
+export { WebRendererWasmFactory as default };