@threepipe/plugin-gaussian-splatting 0.1.0

package/dist/assets/worker-dK7pvmNj.js

@@ -0,0 +1,1569 @@
+(function() {
+  "use strict";
+  /**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: Apache-2.0
+   */
+  const proxyMarker = Symbol("Comlink.proxy");
+  const createEndpoint = Symbol("Comlink.endpoint");
+  const releaseProxy = Symbol("Comlink.releaseProxy");
+  const finalizer = Symbol("Comlink.finalizer");
+  const throwMarker = Symbol("Comlink.thrown");
+  const isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+  const proxyTransferHandler = {
+    canHandle: (val) => isObject(val) && val[proxyMarker],
+    serialize(obj) {
+      const { port1, port2 } = new MessageChannel();
+      expose(obj, port1);
+      return [port2, [port2]];
+    },
+    deserialize(port) {
+      port.start();
+      return wrap(port);
+    }
+  };
+  const throwTransferHandler = {
+    canHandle: (value) => isObject(value) && throwMarker in value,
+    serialize({ value }) {
+      let serialized;
+      if (value instanceof Error) {
+        serialized = {
+          isError: true,
+          value: {
+            message: value.message,
+            name: value.name,
+            stack: value.stack
+          }
+        };
+      } else {
+        serialized = { isError: false, value };
+      }
+      return [serialized, []];
+    },
+    deserialize(serialized) {
+      if (serialized.isError) {
+        throw Object.assign(new Error(serialized.value.message), serialized.value);
+      }
+      throw serialized.value;
+    }
+  };
+  const transferHandlers = /* @__PURE__ */ new Map([
+    ["proxy", proxyTransferHandler],
+    ["throw", throwTransferHandler]
+  ]);
+  function isAllowedOrigin(allowedOrigins, origin) {
+    for (const allowedOrigin of allowedOrigins) {
+      if (origin === allowedOrigin || allowedOrigin === "*") {
+        return true;
+      }
+      if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+    ep.addEventListener("message", function callback(ev) {
+      if (!ev || !ev.data) {
+        return;
+      }
+      if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+        console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+        return;
+      }
+      const { id, type, path } = Object.assign({ path: [] }, ev.data);
+      const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+      let returnValue;
+      try {
+        const parent = path.slice(0, -1).reduce((obj2, prop) => obj2[prop], obj);
+        const rawValue = path.reduce((obj2, prop) => obj2[prop], obj);
+        switch (type) {
+          case "GET":
+            {
+              returnValue = rawValue;
+            }
+            break;
+          case "SET":
+            {
+              parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+              returnValue = true;
+            }
+            break;
+          case "APPLY":
+            {
+              returnValue = rawValue.apply(parent, argumentList);
+            }
+            break;
+          case "CONSTRUCT":
+            {
+              const value = new rawValue(...argumentList);
+              returnValue = proxy(value);
+            }
+            break;
+          case "ENDPOINT":
+            {
+              const { port1, port2 } = new MessageChannel();
+              expose(obj, port2);
+              returnValue = transfer(port1, [port1]);
+            }
+            break;
+          case "RELEASE":
+            {
+              returnValue = void 0;
+            }
+            break;
+          default:
+            return;
+        }
+      } catch (value) {
+        returnValue = { value, [throwMarker]: 0 };
+      }
+      Promise.resolve(returnValue).catch((value) => {
+        return { value, [throwMarker]: 0 };
+      }).then((returnValue2) => {
+        const [wireValue, transferables] = toWireValue(returnValue2);
+        ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+        if (type === "RELEASE") {
+          ep.removeEventListener("message", callback);
+          closeEndPoint(ep);
+          if (finalizer in obj && typeof obj[finalizer] === "function") {
+            obj[finalizer]();
+          }
+        }
+      }).catch((error) => {
+        const [wireValue, transferables] = toWireValue({
+          value: new TypeError("Unserializable return value"),
+          [throwMarker]: 0
+        });
+        ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+      });
+    });
+    if (ep.start) {
+      ep.start();
+    }
+  }
+  function isMessagePort(endpoint) {
+    return endpoint.constructor.name === "MessagePort";
+  }
+  function closeEndPoint(endpoint) {
+    if (isMessagePort(endpoint))
+      endpoint.close();
+  }
+  function wrap(ep, target) {
+    return createProxy(ep, [], target);
+  }
+  function throwIfProxyReleased(isReleased) {
+    if (isReleased) {
+      throw new Error("Proxy has been released and is not useable");
+    }
+  }
+  function releaseEndpoint(ep) {
+    return requestResponseMessage(ep, {
+      type: "RELEASE"
+    }).then(() => {
+      closeEndPoint(ep);
+    });
+  }
+  const proxyCounter = /* @__PURE__ */ new WeakMap();
+  const proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+    const newCount = (proxyCounter.get(ep) || 0) - 1;
+    proxyCounter.set(ep, newCount);
+    if (newCount === 0) {
+      releaseEndpoint(ep);
+    }
+  });
+  function registerProxy(proxy2, ep) {
+    const newCount = (proxyCounter.get(ep) || 0) + 1;
+    proxyCounter.set(ep, newCount);
+    if (proxyFinalizers) {
+      proxyFinalizers.register(proxy2, ep, proxy2);
+    }
+  }
+  function unregisterProxy(proxy2) {
+    if (proxyFinalizers) {
+      proxyFinalizers.unregister(proxy2);
+    }
+  }
+  function createProxy(ep, path = [], target = function() {
+  }) {
+    let isProxyReleased = false;
+    const proxy2 = new Proxy(target, {
+      get(_target, prop) {
+        throwIfProxyReleased(isProxyReleased);
+        if (prop === releaseProxy) {
+          return () => {
+            unregisterProxy(proxy2);
+            releaseEndpoint(ep);
+            isProxyReleased = true;
+          };
+        }
+        if (prop === "then") {
+          if (path.length === 0) {
+            return { then: () => proxy2 };
+          }
+          const r = requestResponseMessage(ep, {
+            type: "GET",
+            path: path.map((p) => p.toString())
+          }).then(fromWireValue);
+          return r.then.bind(r);
+        }
+        return createProxy(ep, [...path, prop]);
+      },
+      set(_target, prop, rawValue) {
+        throwIfProxyReleased(isProxyReleased);
+        const [value, transferables] = toWireValue(rawValue);
+        return requestResponseMessage(ep, {
+          type: "SET",
+          path: [...path, prop].map((p) => p.toString()),
+          value
+        }, transferables).then(fromWireValue);
+      },
+      apply(_target, _thisArg, rawArgumentList) {
+        throwIfProxyReleased(isProxyReleased);
+        const last = path[path.length - 1];
+        if (last === createEndpoint) {
+          return requestResponseMessage(ep, {
+            type: "ENDPOINT"
+          }).then(fromWireValue);
+        }
+        if (last === "bind") {
+          return createProxy(ep, path.slice(0, -1));
+        }
+        const [argumentList, transferables] = processArguments(rawArgumentList);
+        return requestResponseMessage(ep, {
+          type: "APPLY",
+          path: path.map((p) => p.toString()),
+          argumentList
+        }, transferables).then(fromWireValue);
+      },
+      construct(_target, rawArgumentList) {
+        throwIfProxyReleased(isProxyReleased);
+        const [argumentList, transferables] = processArguments(rawArgumentList);
+        return requestResponseMessage(ep, {
+          type: "CONSTRUCT",
+          path: path.map((p) => p.toString()),
+          argumentList
+        }, transferables).then(fromWireValue);
+      }
+    });
+    registerProxy(proxy2, ep);
+    return proxy2;
+  }
+  function myFlat(arr) {
+    return Array.prototype.concat.apply([], arr);
+  }
+  function processArguments(argumentList) {
+    const processed = argumentList.map(toWireValue);
+    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+  }
+  const transferCache = /* @__PURE__ */ new WeakMap();
+  function transfer(obj, transfers) {
+    transferCache.set(obj, transfers);
+    return obj;
+  }
+  function proxy(obj) {
+    return Object.assign(obj, { [proxyMarker]: true });
+  }
+  function toWireValue(value) {
+    for (const [name, handler] of transferHandlers) {
+      if (handler.canHandle(value)) {
+        const [serializedValue, transferables] = handler.serialize(value);
+        return [
+          {
+            type: "HANDLER",
+            name,
+            value: serializedValue
+          },
+          transferables
+        ];
+      }
+    }
+    return [
+      {
+        type: "RAW",
+        value
+      },
+      transferCache.get(value) || []
+    ];
+  }
+  function fromWireValue(value) {
+    switch (value.type) {
+      case "HANDLER":
+        return transferHandlers.get(value.name).deserialize(value.value);
+      case "RAW":
+        return value.value;
+    }
+  }
+  function requestResponseMessage(ep, msg, transfers) {
+    return new Promise((resolve) => {
+      const id = generateUUID();
+      ep.addEventListener("message", function l(ev) {
+        if (!ev.data || !ev.data.id || ev.data.id !== id) {
+          return;
+        }
+        ep.removeEventListener("message", l);
+        resolve(ev.data);
+      });
+      if (ep.start) {
+        ep.start();
+      }
+      ep.postMessage(Object.assign({ id }, msg), transfers);
+    });
+  }
+  function generateUUID() {
+    return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+  }
+  var Module = (() => {
+    var _scriptDir = self.location.href;
+    return function(moduleArg = {}) {
+      var Module2 = moduleArg;
+      var readyPromiseResolve, readyPromiseReject;
+      Module2["ready"] = new Promise((resolve, reject) => {
+        readyPromiseResolve = resolve;
+        readyPromiseReject = reject;
+      });
+      var moduleOverrides = Object.assign({}, Module2);
+      var ENVIRONMENT_IS_WEB = typeof window == "object";
+      var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
+      typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
+      var scriptDirectory = "";
+      function locateFile(path) {
+        if (Module2["locateFile"]) {
+          return Module2["locateFile"](path, scriptDirectory);
+        }
+        return scriptDirectory + path;
+      }
+      var readBinary;
+      if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+        if (ENVIRONMENT_IS_WORKER) {
+          scriptDirectory = self.location.href;
+        } else if (typeof document != "undefined" && document.currentScript) {
+          scriptDirectory = document.currentScript.src;
+        }
+        if (_scriptDir) {
+          scriptDirectory = _scriptDir;
+        }
+        if (scriptDirectory.indexOf("blob:") !== 0) {
+          scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
+        } else {
+          scriptDirectory = "";
+        }
+        {
+          if (ENVIRONMENT_IS_WORKER) {
+            readBinary = (url) => {
+              var xhr = new XMLHttpRequest();
+              xhr.open("GET", url, false);
+              xhr.responseType = "arraybuffer";
+              xhr.send(null);
+              return new Uint8Array(xhr.response);
+            };
+          }
+        }
+      }
+      Module2["print"] || console.log.bind(console);
+      var err = Module2["printErr"] || console.error.bind(console);
+      Object.assign(Module2, moduleOverrides);
+      moduleOverrides = null;
+      if (Module2["arguments"])
+        Module2["arguments"];
+      if (Module2["thisProgram"])
+        Module2["thisProgram"];
+      if (Module2["quit"])
+        Module2["quit"];
+      var wasmBinary;
+      if (Module2["wasmBinary"])
+        wasmBinary = Module2["wasmBinary"];
+      if (typeof WebAssembly != "object") {
+        abort("no native wasm support detected");
+      }
+      var wasmMemory;
+      var ABORT = false;
+      var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+      function updateMemoryViews() {
+        var b = wasmMemory.buffer;
+        Module2["HEAP8"] = HEAP8 = new Int8Array(b);
+        Module2["HEAP16"] = HEAP16 = new Int16Array(b);
+        Module2["HEAPU8"] = HEAPU8 = new Uint8Array(b);
+        Module2["HEAPU16"] = HEAPU16 = new Uint16Array(b);
+        Module2["HEAP32"] = HEAP32 = new Int32Array(b);
+        Module2["HEAPU32"] = HEAPU32 = new Uint32Array(b);
+        Module2["HEAPF32"] = HEAPF32 = new Float32Array(b);
+        Module2["HEAPF64"] = HEAPF64 = new Float64Array(b);
+      }
+      var __ATPRERUN__ = [];
+      var __ATINIT__ = [];
+      var __ATPOSTRUN__ = [];
+      function preRun() {
+        if (Module2["preRun"]) {
+          if (typeof Module2["preRun"] == "function")
+            Module2["preRun"] = [Module2["preRun"]];
+          while (Module2["preRun"].length) {
+            addOnPreRun(Module2["preRun"].shift());
+          }
+        }
+        callRuntimeCallbacks(__ATPRERUN__);
+      }
+      function initRuntime() {
+        callRuntimeCallbacks(__ATINIT__);
+      }
+      function postRun() {
+        if (Module2["postRun"]) {
+          if (typeof Module2["postRun"] == "function")
+            Module2["postRun"] = [Module2["postRun"]];
+          while (Module2["postRun"].length) {
+            addOnPostRun(Module2["postRun"].shift());
+          }
+        }
+        callRuntimeCallbacks(__ATPOSTRUN__);
+      }
+      function addOnPreRun(cb) {
+        __ATPRERUN__.unshift(cb);
+      }
+      function addOnInit(cb) {
+        __ATINIT__.unshift(cb);
+      }
+      function addOnPostRun(cb) {
+        __ATPOSTRUN__.unshift(cb);
+      }
+      var runDependencies = 0;
+      var dependenciesFulfilled = null;
+      function addRunDependency(id) {
+        runDependencies++;
+        if (Module2["monitorRunDependencies"]) {
+          Module2["monitorRunDependencies"](runDependencies);
+        }
+      }
+      function removeRunDependency(id) {
+        runDependencies--;
+        if (Module2["monitorRunDependencies"]) {
+          Module2["monitorRunDependencies"](runDependencies);
+        }
+        if (runDependencies == 0) {
+          if (dependenciesFulfilled) {
+            var callback = dependenciesFulfilled;
+            dependenciesFulfilled = null;
+            callback();
+          }
+        }
+      }
+      function abort(what) {
+        if (Module2["onAbort"]) {
+          Module2["onAbort"](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 = (filename) => filename.startsWith(dataURIPrefix);
+      var wasmBinaryFile;
+      if (Module2["locateFile"]) {
+        wasmBinaryFile = "sort.wasm";
+        if (!isDataURI(wasmBinaryFile)) {
+          wasmBinaryFile = locateFile(wasmBinaryFile);
+        }
+      } else {
+        wasmBinaryFile = new URL("data:application/wasm;base64,AGFzbQEAAAABTgxgAX8Bf2AAAGAEf39/fwBgA39/fwBgBX9/f39/AGABfwBgBn9/f39/fwBgAn9/AGADf39/AX9gB39/f39/f38AYAJ/fwF/YAR/f35+AAJVDgFhAWEAAwFhAWIABAFhAWMAAwFhAWQAAwFhAWUABwFhAWYAAQFhAWcACQFhAWgABwFhAWkAAgFhAWoABwFhAWsACQFhAWwAAAFhAW0AAwFhAW4AAwMlJAgKBQAABQABCwUDAgoFAAEAAQUBAAAABgQCAgQGCAgBAQACBAQFAXABGxsFBwEBgAKAgAIGCAF/AUGgoAQLBx0HAW8CAAFwABUBcQAvAXIAEgFzAQABdAAQAXUAJAkgAQBBAQsaITEwHh0tHBMbGywXIhcTKyUmJxMqKSgcEyMK/l0kdAEBfyACRQRAIAAoAgQgASgCBEYPCyAAIAFGBEBBAQ8LIAEoAgQiAi0AACEBAkAgACgCBCIDLQAAIgBFDQAgACABRw0AA0AgAi0AASEBIAMtAAEiAEUNASACQQFqIQIgA0EBaiEDIAAgAUYNAAsLIAAgAUYL2AIBAn8CQCABRQ0AIABBADoAACAAIAFqIgJBAWtBADoAACABQQNJDQAgAEEAOgACIABBADoAASACQQNrQQA6AAAgAkECa0EAOgAAIAFBB0kNACAAQQA6AAMgAkEEa0EAOgAAIAFBCUkNACAAQQAgAGtBA3EiA2oiAkEANgIAIAIgASADa0F8cSIDaiIBQQRrQQA2AgAgA0EJSQ0AIAJBADYCCCACQQA2AgQgAUEIa0EANgIAIAFBDGtBADYCACADQRlJDQAgAkEANgIYIAJBADYCFCACQQA2AhAgAkEANgIMIAFBEGtBADYCACABQRRrQQA2AgAgAUEYa0EANgIAIAFBHGtBADYCACADIAJBBHFBGHIiA2siAUEgSQ0AIAIgA2ohAgNAIAJCADcDGCACQgA3AxAgAkIANwMIIAJCADcDACACQSBqIQIgAUEgayIBQR9LDQALCyAAC9ILAQd/AkAgAEUNACAAQQhrIgIgAEEEaygCACIBQXhxIgBqIQUCQCABQQFxDQAgAUEDcUUNASACIAIoAgAiAWsiAkGcHCgCAEkNASAAIAFqIQACQAJAQaAcKAIAIAJHBEAgAUH/AU0EQCABQQN2IQQgAigCDCIBIAIoAggiA0YEQEGMHEGMHCgCAEF+IAR3cTYCAAwFCyADIAE2AgwgASADNgIIDAQLIAIoAhghBiACIAIoAgwiAUcEQCACKAIIIgMgATYCDCABIAM2AggMAwsgAkEUaiIEKAIAIgNFBEAgAigCECIDRQ0CIAJBEGohBAsDQCAEIQcgAyIBQRRqIgQoAgAiAw0AIAFBEGohBCABKAIQIgMNAAsgB0EANgIADAILIAUoAgQiAUEDcUEDRw0CQZQcIAA2AgAgBSABQX5xNgIEIAIgAEEBcjYCBCAFIAA2AgAPC0EAIQELIAZFDQACQCACKAIcIgNBAnRBvB5qIgQoAgAgAkYEQCAEIAE2AgAgAQ0BQZAcQZAcKAIAQX4gA3dxNgIADAILIAZBEEEUIAYoAhAgAkYbaiABNgIAIAFFDQELIAEgBjYCGCACKAIQIgMEQCABIAM2AhAgAyABNgIYCyACKAIUIgNFDQAgASADNgIUIAMgATYCGAsgAiAFTw0AIAUoAgQiAUEBcUUNAAJAAkACQAJAIAFBAnFFBEBBpBwoAgAgBUYEQEGkHCACNgIAQZgcQZgcKAIAIABqIgA2AgAgAiAAQQFyNgIEIAJBoBwoAgBHDQZBlBxBADYCAEGgHEEANgIADwtBoBwoAgAgBUYEQEGgHCACNgIAQZQcQZQcKAIAIABqIgA2AgAgAiAAQQFyNgIEIAAgAmogADYCAA8LIAFBeHEgAGohACABQf8BTQRAIAFBA3YhBCAFKAIMIgEgBSgCCCIDRgRAQYwcQYwcKAIAQX4gBHdxNgIADAULIAMgATYCDCABIAM2AggMBAsgBSgCGCEGIAUgBSgCDCIBRwRAQZwcKAIAGiAFKAIIIgMgATYCDCABIAM2AggMAwsgBUEUaiIEKAIAIgNFBEAgBSgCECIDRQ0CIAVBEGohBAsDQCAEIQcgAyIBQRRqIgQoAgAiAw0AIAFBEGohBCABKAIQIgMNAAsgB0EANgIADAILIAUgAUF+cTYCBCACIABBAXI2AgQgACACaiAANgIADAMLQQAhAQsgBkUNAAJAIAUoAhwiA0ECdEG8HmoiBCgCACAFRgRAIAQgATYCACABDQFBkBxBkBwoAgBBfiADd3E2AgAMAgsgBkEQQRQgBigCECAFRhtqIAE2AgAgAUUNAQsgASAGNgIYIAUoAhAiAwRAIAEgAzYCECADIAE2AhgLIAUoAhQiA0UNACABIAM2AhQgAyABNgIYCyACIABBAXI2AgQgACACaiAANgIAIAJBoBwoAgBHDQBBlBwgADYCAA8LIABB/wFNBEAgAEF4cUG0HGohAQJ/QYwcKAIAIgNBASAAQQN2dCIAcUUEQEGMHCAAIANyNgIAIAEMAQsgASgCCAshACABIAI2AgggACACNgIMIAIgATYCDCACIAA2AggPC0EfIQMgAEH///8HTQRAIABBJiAAQQh2ZyIBa3ZBAXEgAUEBdGtBPmohAwsgAiADNgIcIAJCADcCECADQQJ0QbweaiEBAkACQAJAQZAcKAIAIgRBASADdCIHcUUEQEGQHCAEIAdyNgIAIAEgAjYCACACIAE2AhgMAQsgAEEZIANBAXZrQQAgA0EfRxt0IQMgASgCACEBA0AgASIEKAIEQXhxIABGDQIgA0EddiEBIANBAXQhAyAEIAFBBHFqIgdBEGooAgAiAQ0ACyAHIAI2AhAgAiAENgIYCyACIAI2AgwgAiACNgIIDAELIAQoAggiACACNgIMIAQgAjYCCCACQQA2AhggAiAENgIMIAIgADYCCAtBrBxBrBwoAgBBAWsiAEF/IAAbNgIACwtPAQJ/QYAcKAIAIgEgAEEHakF4cSICaiEAAkAgAkEAIAAgAU0bRQRAIAA/AEEQdE0NASAAEAsNAQtBiBxBMDYCAEF/DwtBgBwgADYCACABC84nAQx/IwBBEGsiCiQAAkACQAJAAkACQAJAAkACQAJAIABB9AFNBEBBjBwoAgAiBkEQIABBC2pBeHEgAEELSRsiBUEDdiIAdiIBQQNxBEACQCABQX9zQQFxIABqIgJBA3QiAUG0HGoiACABQbwcaigCACIBKAIIIgNGBEBBjBwgBkF+IAJ3cTYCAAwBCyADIAA2AgwgACADNgIICyABQQhqIQAgASACQQN0IgJBA3I2AgQgASACaiIBIAEoAgRBAXI2AgQMCgsgBUGUHCgCACIHTQ0BIAEEQAJAQQIgAHQiAkEAIAJrciABIAB0cWgiAUEDdCIAQbQcaiICIABBvBxqKAIAIgAoAggiA0YEQEGMHCAGQX4gAXdxIgY2AgAMAQsgAyACNgIMIAIgAzYCCAsgACAFQQNyNgIEIAAgBWoiBCABQQN0IgEgBWsiA0EBcjYCBCAAIAFqIAM2AgAgBwRAIAdBeHFBtBxqIQFBoBwoAgAhAgJ/IAZBASAHQQN2dCIFcUUEQEGMHCAFIAZyNgIAIAEMAQsgASgCCAshBSABIAI2AgggBSACNgIMIAIgATYCDCACIAU2AggLIABBCGohAEGgHCAENgIAQZQcIAM2AgAMCgtBkBwoAgAiC0UNASALaEECdEG8HmooAgAiAigCBEF4cSAFayEEIAIhAQNAAkAgASgCECIARQRAIAEoAhQiAEUNAQsgACgCBEF4cSAFayIBIAQgASAESSIBGyEEIAAgAiABGyECIAAhAQwBCwsgAigCGCEJIAIgAigCDCIDRwRAQZwcKAIAGiACKAIIIgAgAzYCDCADIAA2AggMCQsgAkEUaiIBKAIAIgBFBEAgAigCECIARQ0DIAJBEGohAQsDQCABIQggACIDQRRqIgEoAgAiAA0AIANBEGohASADKAIQIgANAAsgCEEANgIADAgLQX8hBSAAQb9/Sw0AIABBC2oiAEF4cSEFQZAcKAIAIghFDQBBACAFayEEAkACQAJAAn9BACAFQYACSQ0AGkEfIAVB////B0sNABogBUEmIABBCHZnIgBrdkEBcSAAQQF0a0E+agsiB0ECdEG8HmooAgAiAUUEQEEAIQAMAQtBACEAIAVBGSAHQQF2a0EAIAdBH0cbdCECA0ACQCABKAIEQXhxIAVrIgYgBE8NACABIQMgBiIEDQBBACEEIAEhAAwDCyAAIAEoAhQiBiAGIAEgAkEddkEEcWooAhAiAUYbIAAgBhshACACQQF0IQIgAQ0ACwsgACADckUEQEEAIQNBAiAHdCIAQQAgAGtyIAhxIgBFDQMgAGhBAnRBvB5qKAIAIQALIABFDQELA0AgACgCBEF4cSAFayICIARJIQEgAiAEIAEbIQQgACADIAEbIQMgACgCECIBBH8gAQUgACgCFAsiAA0ACwsgA0UNACAEQZQcKAIAIAVrTw0AIAMoAhghByADIAMoAgwiAkcEQEGcHCgCABogAygCCCIAIAI2AgwgAiAANgIIDAcLIANBFGoiASgCACIARQRAIAMoAhAiAEUNAyADQRBqIQELA0AgASEGIAAiAkEUaiIBKAIAIgANACACQRBqIQEgAigCECIADQALIAZBADYCAAwGCyAFQZQcKAIAIgNNBEBBoBwoAgAhAAJAIAMgBWsiAUEQTwRAIAAgBWoiAiABQQFyNgIEIAAgA2ogATYCACAAIAVBA3I2AgQMAQsgACADQQNyNgIEIAAgA2oiASABKAIEQQFyNgIEQQAhAkEAIQELQZQcIAE2AgBBoBwgAjYCACAAQQhqIQAMCAsgBUGYHCgCACICSQRAQZgcIAIgBWsiATYCAEGkHEGkHCgCACIAIAVqIgI2AgAgAiABQQFyNgIEIAAgBUEDcjYCBCAAQQhqIQAMCAtBACEAIAVBL2oiBAJ/QeQfKAIABEBB7B8oAgAMAQtB8B9CfzcCAEHoH0KAoICAgIAENwIAQeQfIApBDGpBcHFB2KrVqgVzNgIAQfgfQQA2AgBByB9BADYCAEGAIAsiAWoiBkEAIAFrIghxIgEgBU0NB0HEHygCACIDBEBBvB8oAgAiByABaiIJIAdNDQggAyAJSQ0ICwJAQcgfLQAAQQRxRQRAAkACQAJAAkBBpBwoAgAiAwRAQcwfIQADQCADIAAoAgAiB08EQCAHIAAoAgRqIANLDQMLIAAoAggiAA0ACwtBABARIgJBf0YNAyABIQZB6B8oAgAiAEEBayIDIAJxBEAgASACayACIANqQQAgAGtxaiEGCyAFIAZPDQNBxB8oAgAiAARAQbwfKAIAIgMgBmoiCCADTQ0EIAAgCEkNBAsgBhARIgAgAkcNAQwFCyAGIAJrIAhxIgYQESICIAAoAgAgACgCBGpGDQEgAiEACyAAQX9GDQEgBUEwaiAGTQRAIAAhAgwEC0HsHygCACICIAQgBmtqQQAgAmtxIgIQEUF/Rg0BIAIgBmohBiAAIQIMAwsgAkF/Rw0CC0HIH0HIHygCAEEEcjYCAAsgARARIQJBABARIQAgAkF/Rg0FIABBf0YNBSAAIAJNDQUgACACayIGIAVBKGpNDQULQbwfQbwfKAIAIAZqIgA2AgBBwB8oAgAgAEkEQEHAHyAANgIACwJAQaQcKAIAIgQEQEHMHyEAA0AgAiAAKAIAIgEgACgCBCIDakYNAiAAKAIIIgANAAsMBAtBnBwoAgAiAEEAIAAgAk0bRQRAQZwcIAI2AgALQQAhAEHQHyAGNgIAQcwfIAI2AgBBrBxBfzYCAEGwHEHkHygCADYCAEHYH0EANgIAA0AgAEEDdCIBQbwcaiABQbQcaiIDNgIAIAFBwBxqIAM2AgAgAEEBaiIAQSBHDQALQZgcIAZBKGsiAEF4IAJrQQdxIgFrIgM2AgBBpBwgASACaiIBNgIAIAEgA0EBcjYCBCAAIAJqQSg2AgRBqBxB9B8oAgA2AgAMBAsgAiAETQ0CIAEgBEsNAiAAKAIMQQhxDQIgACADIAZqNgIEQaQcIARBeCAEa0EHcSIAaiIBNgIAQZgcQZgcKAIAIAZqIgIgAGsiADYCACABIABBAXI2AgQgAiAEakEoNgIEQagcQfQfKAIANgIADAMLQQAhAwwFC0EAIQIMAwtBnBwoAgAgAksEQEGcHCACNgIACyACIAZqIQFBzB8hAAJAAkACQANAIAEgACgCAEcEQCAAKAIIIgANAQwCCwsgAC0ADEEIcUUNAQtBzB8hAANAAkAgBCAAKAIAIgFPBEAgASAAKAIEaiIDIARLDQELIAAoAgghAAwBCwtBmBwgBkEoayIAQXggAmtBB3EiAWsiCDYCAEGkHCABIAJqIgE2AgAgASAIQQFyNgIEIAAgAmpBKDYCBEGoHEH0HygCADYCACAEIANBJyADa0EHcWpBL2siACAAIARBEGpJGyIBQRs2AgQgAUHUHykCADcCECABQcwfKQIANwIIQdQfIAFBCGo2AgBB0B8gBjYCAEHMHyACNgIAQdgfQQA2AgAgAUEYaiEAA0AgAEEHNgIEIABBCGohDCAAQQRqIQAgDCADSQ0ACyABIARGDQIgASABKAIEQX5xNgIEIAQgASAEayICQQFyNgIEIAEgAjYCACACQf8BTQRAIAJBeHFBtBxqIQACf0GMHCgCACIBQQEgAkEDdnQiAnFFBEBBjBwgASACcjYCACAADAELIAAoAggLIQEgACAENgIIIAEgBDYCDCAEIAA2AgwgBCABNgIIDAMLQR8hACACQf///wdNBEAgAkEmIAJBCHZnIgBrdkEBcSAAQQF0a0E+aiEACyAEIAA2AhwgBEIANwIQIABBAnRBvB5qIQECQEGQHCgCACIDQQEgAHQiBnFFBEBBkBwgAyAGcjYCACABIAQ2AgAMAQsgAkEZIABBAXZrQQAgAEEfRxt0IQAgASgCACEDA0AgAyIBKAIEQXhxIAJGDQMgAEEddiEDIABBAXQhACABIANBBHFqIgYoAhAiAw0ACyAGIAQ2AhALIAQgATYCGCAEIAQ2AgwgBCAENgIIDAILIAAgAjYCACAAIAAoAgQgBmo2AgQgAkF4IAJrQQdxaiIHIAVBA3I2AgQgAUF4IAFrQQdxaiIEIAUgB2oiBWshBgJAQaQcKAIAIARGBEBBpBwgBTYCAEGYHEGYHCgCACAGaiIANgIAIAUgAEEBcjYCBAwBC0GgHCgCACAERgRAQaAcIAU2AgBBlBxBlBwoAgAgBmoiADYCACAFIABBAXI2AgQgACAFaiAANgIADAELIAQoAgQiAkEDcUEBRgRAIAJBeHEhCQJAIAJB/wFNBEAgBCgCDCIAIAQoAggiAUYEQEGMHEGMHCgCAEF+IAJBA3Z3cTYCAAwCCyABIAA2AgwgACABNgIIDAELIAQoAhghCAJAIAQgBCgCDCIARwRAQZwcKAIAGiAEKAIIIgEgADYCDCAAIAE2AggMAQsCQCAEQRRqIgEoAgAiAkUEQCAEKAIQIgJFDQEgBEEQaiEBCwNAIAEhAyACIgBBFGoiASgCACICDQAgAEEQaiEBIAAoAhAiAg0ACyADQQA2AgAMAQtBACEACyAIRQ0AAkAgBCgCHCIBQQJ0QbweaiICKAIAIARGBEAgAiAANgIAIAANAUGQHEGQHCgCAEF+IAF3cTYCAAwCCyAIQRBBFCAIKAIQIARGG2ogADYCACAARQ0BCyAAIAg2AhggBCgCECIBBEAgACABNgIQIAEgADYCGAsgBCgCFCIBRQ0AIAAgATYCFCABIAA2AhgLIAYgCWohBiAEIAlqIgQoAgQhAgsgBCACQX5xNgIEIAUgBkEBcjYCBCAFIAZqIAY2AgAgBkH/AU0EQCAGQXhxQbQcaiEAAn9BjBwoAgAiAUEBIAZBA3Z0IgJxRQRAQYwcIAEgAnI2AgAgAAwBCyAAKAIICyEBIAAgBTYCCCABIAU2AgwgBSAANgIMIAUgATYCCAwBC0EfIQIgBkH///8HTQRAIAZBJiAGQQh2ZyIAa3ZBAXEgAEEBdGtBPmohAgsgBSACNgIcIAVCADcCECACQQJ0QbweaiEBAkACQEGQHCgCACIAQQEgAnQiA3FFBEBBkBwgACADcjYCACABIAU2AgAMAQsgBkEZIAJBAXZrQQAgAkEfRxt0IQIgASgCACEAA0AgACIBKAIEQXhxIAZGDQIgAkEddiEAIAJBAXQhAiABIABBBHFqIgMoAhAiAA0ACyADIAU2AhALIAUgATYCGCAFIAU2AgwgBSAFNgIIDAELIAEoAggiACAFNgIMIAEgBTYCCCAFQQA2AhggBSABNgIMIAUgADYCCAsgB0EIaiEADAULIAEoAggiACAENgIMIAEgBDYCCCAEQQA2AhggBCABNgIMIAQgADYCCAtBmBwoAgAiACAFTQ0AQZgcIAAgBWsiATYCAEGkHEGkHCgCACIAIAVqIgI2AgAgAiABQQFyNgIEIAAgBUEDcjYCBCAAQQhqIQAMAwtBiBxBMDYCAEEAIQAMAgsCQCAHRQ0AAkAgAygCHCIAQQJ0QbweaiIBKAIAIANGBEAgASACNgIAIAINAUGQHCAIQX4gAHdxIgg2AgAMAgsgB0EQQRQgBygCECADRhtqIAI2AgAgAkUNAQsgAiAHNgIYIAMoAhAiAARAIAIgADYCECAAIAI2AhgLIAMoAhQiAEUNACACIAA2AhQgACACNgIYCwJAIARBD00EQCADIAQgBWoiAEEDcjYCBCAAIANqIgAgACgCBEEBcjYCBAwBCyADIAVBA3I2AgQgAyAFaiICIARBAXI2AgQgAiAEaiAENgIAIARB/wFNBEAgBEF4cUG0HGohAAJ/QYwcKAIAIgFBASAEQQN2dCIFcUUEQEGMHCABIAVyNgIAIAAMAQsgACgCCAshASAAIAI2AgggASACNgIMIAIgADYCDCACIAE2AggMAQtBHyEAIARB////B00EQCAEQSYgBEEIdmciAGt2QQFxIABBAXRrQT5qIQALIAIgADYCHCACQgA3AhAgAEECdEG8HmohAQJAAkAgCEEBIAB0IgVxRQRAQZAcIAUgCHI2AgAgASACNgIADAELIARBGSAAQQF2a0EAIABBH0cbdCEAIAEoAgAhBQNAIAUiASgCBEF4cSAERg0CIABBHXYhBSAAQQF0IQAgASAFQQRxaiIGKAIQIgUNAAsgBiACNgIQCyACIAE2AhggAiACNgIMIAIgAjYCCAwBCyABKAIIIgAgAjYCDCABIAI2AgggAkEANgIYIAIgATYCDCACIAA2AggLIANBCGohAAwBCwJAIAlFDQACQCACKAIcIgBBAnRBvB5qIgEoAgAgAkYEQCABIAM2AgAgAw0BQZAcIAtBfiAAd3E2AgAMAgsgCUEQQRQgCSgCECACRhtqIAM2AgAgA0UNAQsgAyAJNgIYIAIoAhAiAARAIAMgADYCECAAIAM2AhgLIAIoAhQiAEUNACADIAA2AhQgACADNgIYCwJAIARBD00EQCACIAQgBWoiAEEDcjYCBCAAIAJqIgAgACgCBEEBcjYCBAwBCyACIAVBA3I2AgQgAiAFaiIDIARBAXI2AgQgAyAEaiAENgIAIAcEQCAHQXhxQbQcaiEAQaAcKAIAIQECf0EBIAdBA3Z0IgUgBnFFBEBBjBwgBSAGcjYCACAADAELIAAoAggLIQUgACABNgIIIAUgATYCDCABIAA2AgwgASAFNgIIC0GgHCADNgIAQZQcIAQ2AgALIAJBCGohAAsgCkEQaiQAIAALBgAgABAQCzUBAX9BASAAIABBAU0bIQACQANAIAAQEiIBDQFBkCAoAgAiAQRAIAERAQAMAQsLEAUACyABC2EAQfwfQQE2AgBBgCBBADYCAEGPCEEFQeAOQfQOQQJBA0EAEAZBgCBBhCAoAgA2AgBBhCBB/B82AgBBiCBBBTYCAEGMIEEANgIAEB1BjCBBhCAoAgA2AgBBhCBBiCA2AgALHAAgACABQQggAqcgAkIgiKcgA6cgA0IgiKcQCgsIACAAEB4QEAtdAQF/IAAoAhAiA0UEQCAAQQE2AiQgACACNgIYIAAgATYCEA8LAkAgASADRgRAIAAoAhhBAkcNASAAIAI2AhgPCyAAQQE6ADYgAEECNgIYIAAgACgCJEEBajYCJAsLmgEAIABBAToANQJAIAAoAgQgAkcNACAAQQE6ADQCQCAAKAIQIgJFBEAgAEEBNgIkIAAgAzYCGCAAIAE2AhAgA0EBRw0CIAAoAjBBAUYNAQwCCyABIAJGBEAgACgCGCICQQJGBEAgACADNgIYIAMhAgsgACgCMEEBRw0CIAJBAUYNAQwCCyAAIAAoAiRBAWo2AiQLIABBAToANgsL/gIBA38jAEHwAGsiAiQAIAAoAgAiA0EEaygCACEEIANBCGsoAgAhAyACQgA3AkwgAkIANwJUIAJCADcCXCACQgA3AmQgAkEANgBrIAJCADcCRCACQbQWNgJAIAIgADYCPCACIAE2AjgCQCAEIAFBABAOBEBBACAAIAMbIQAMAQsgACAAIANqIgNOBEAgAkIANwIsIAJBADYAMyACQgA3AhQgAkIANwIcIAJCADcCJCACQgA3AgwgAiABNgIIIAIgADYCBCACIAQ2AgAgAkEBNgIwIAQgAiADIANBAUEAIAQoAgAoAhQRBgAgAigCGA0BC0EAIQAgBCACQThqIANBAUEAIAQoAgAoAhgRBAACQAJAIAIoAlwOAgABAgsgAigCTEEAIAIoAlhBAUYbQQAgAigCVEEBRhtBACACKAJgQQFGGyEADAELIAIoAlBBAUcEQCACKAJgDQEgAigCVEEBRw0BIAIoAlhBAUcNAQsgAigCSCEACyACQfAAaiQAIAALAgALBAAgAAvhAwBBpBhBuAkQCUGwGEHXCEEBQQAQCEG8GEHDCEEBQYB/Qf8AEAFB1BhBvAhBAUGAf0H/ABABQcgYQboIQQFBAEH/ARABQeAYQYkIQQJBgIB+Qf//ARABQewYQYAIQQJBAEH//wMQAUH4GEGgCEEEQYCAgIB4Qf////8HEAFBhBlBlwhBBEEAQX8QAUGQGUH1CEEEQYCAgIB4Qf////8HEAFBnBlB7AhBBEEAQX8QAUGoGUGrCEKAgICAgICAgIB/Qv///////////wAQFkG0GUGqCEIAQn8QFkHAGUGkCEEEEANBzBlBsQlBCBADQbwPQYcJEARBhBBBtQ0QBEHMEEEEQfoIEAJBmBFBAkGTCRACQeQRQQRBogkQAkGAEkHcCBAHQagSQQBB8AwQAEHQEkEAQdYNEABB+BJBAUGODRAAQaATQQJBvQkQAEHIE0EDQdwJEABB8BNBBEGEChAAQZgUQQVBoQoQAEHAFEEEQfsNEABB6BRBBUGZDhAAQdASQQBBhwsQAEH4EkEBQeYKEABBoBNBAkHJCxAAQcgTQQNBpwsQAEHwE0EEQc8MEABBmBRBBUGtDBAAQZAVQQhBjAwQAEG4FUEJQeoLEABB4BVBBkHHChAAQYgWQQdBwA4QAAsxAQJ/IABBoBo2AgAgACgCBEEMayIBIAEoAghBAWsiAjYCCCACQQBIBEAgARAQCyAAC2gBA39B2AAQEkHQAGoiAEH0GzYCACAAQaAaNgIAQRMQFCIBQQA2AgggAUKGgICA4AA3AgAgAUEMaiICQbYIKAAANgADIAFBswgoAAA2AAwgACACNgIEIABB0Bo2AgAgAEHwGkEEEA0AC8kKAQ5/IwBBgBBrIgMkAAJ/IAAoAgQiCiAAKAIAIgRGBEAgA0GACGpBgAgQDxpBAAwBCyAKIARrIgVBA3UiCEGAgICAAk8EQBAfAAsgBRAUIgcgBRAPIQEgA0GACGpBgAgQDxogBCECA0AgA0GACGogAigCACIJQR91IAlzQf8BcUECdGoiCSAJKAIAQQFqNgIAIAJBCGoiAiAKRw0ACyABIAhBA3RqIQggASAFagshBUEAIQEgA0EANgIAQQEhAgNAIAMgAkECdCIJaiILIAEgA0GACGogCWoiBkEEaygCAGoiATYCACADIAlBBGoiCWogBigCACABaiIBNgIAIAsgA0GACGogCWooAgAgAWoiATYCCCACQQNqIgJBgAJHDQALIAQgCkYiC0UEQCAEIQIDQCADIAIoAgAiAUEfdSABc0H/AXFBAnRqIgEgASgCACIBQQFqNgIAIAcgAUEDdGogAikCADcCACACQQhqIgIgCkcNAAsLIAAgBTYCBCAAIAc2AgAgACgCCCEJIAAgCDYCCEEAIQEgA0GACGpBgAgQDxogBSAHRiIMRQRAIAchAgNAIANBgAhqIAIoAgAiBkEfdSAGc0EGdkH8B3FqIgYgBigCAEEBajYCACACQQhqIgIgBUcNAAsLIANBADYCAEEBIQIDQCADIAJBAnQiBmoiDSABIANBgAhqIAZqIg5BBGsoAgBqIgE2AgAgAyAGQQRqIgZqIA4oAgAgAWoiATYCACANIANBgAhqIAZqKAIAIAFqIgE2AgggAkEDaiICQYACRw0ACyAMBH8gBwUDQCADIAcoAgAiAkEfdSACc0EGdkH8B3FqIgIgAigCACICQQFqNgIAIAQgAkEDdGogBykCADcCACAHQQhqIgcgBUcNAAsgACgCCCEIIAAoAgQhByAAKAIACyECIAAgCTYCCCAAIAo2AgQgACAENgIAQQAhASADQYAIakGACBAPGiALRQRAIAQhBQNAIANBgAhqIAUoAgAiBkEfdSAGc0EOdkH8B3FqIgYgBigCAEEBajYCACAFQQhqIgUgCkcNAAsLIANBADYCAEEBIQUDQCADIAVBAnQiBmoiDCABIANBgAhqIAZqIg1BBGsoAgBqIgE2AgAgAyAGQQRqIgZqIA0oAgAgAWoiATYCACAMIANBgAhqIAZqKAIAIAFqIgE2AgggBUEDaiIFQYACRw0ACyALBH8gCgUDQCADIAQoAgAiBUEfdSAFc0EOdkH8B3FqIgUgBSgCACIFQQFqNgIAIAIgBUEDdGogBCkCADcCACAEQQhqIgQgCkcNAAsgACgCCCEJIAAoAgQhCiAAKAIACyEFIAAgCDYCCCAAIAc2AgQgACACNgIAQQAhASADQYAIakGACBAPGiACIAdGIgtFBEAgAiEEA0AgA0GACGogBCgCACIIQR91QYCAgIB4ciAIc0EWdkH8B3FqIgggCCgCAEEBajYCACAEQQhqIgQgB0cNAAsLIANBADYCAEEBIQQDQCADIARBAnQiCGoiBiABIANBgAhqIAhqIgxBBGsoAgBqIgE2AgAgAyAIQQRqIghqIAwoAgAgAWoiATYCACAGIANBgAhqIAhqKAIAIAFqIgE2AgggBEEDaiIEQYACRw0ACyALRQRAA0AgAyACKAIAIgRBH3VBgICAgHhyIARzQRZ2QfwHcWoiBCAEKAIAIgRBAWo2AgAgBSAEQQN0aiACKQIANwIAIAJBCGoiAiAHRw0ACyAAKAIAIQcLIAAgCTYCCCAAIAo2AgQgACAFNgIAIAcEQCAHEBALIANBgBBqJAALFQBBjwhBBUHgDkH0DkECQQNBABAGCwcAIAAoAgQLBQBByAgLFQAgAEUEQEEADwsgAEHEFxAaQQBHCxoAIAAgASgCCCAFEA4EQCABIAIgAyAEEBkLC6cBACAAIAEoAgggBBAOBEACQCABKAIEIAJHDQAgASgCHEEBRg0AIAEgAzYCHAsPCwJAIAAgASgCACAEEA5FDQACQCACIAEoAhBHBEAgASgCFCACRw0BCyADQQFHDQEgAUEBNgIgDwsgASACNgIUIAEgAzYCICABIAEoAihBAWo2AigCQCABKAIkQQFHDQAgASgCGEECRw0AIAFBAToANgsgAUEENgIsCwsYACAAIAEoAghBABAOBEAgASACIAMQGAsLMQAgACABKAIIQQAQDgRAIAEgAiADEBgPCyAAKAIIIgAgASACIAMgACgCACgCHBECAAuIAgAgACABKAIIIAQQDgRAAkAgASgCBCACRw0AIAEoAhxBAUYNACABIAM2AhwLDwsCQCAAIAEoAgAgBBAOBEACQCACIAEoAhBHBEAgASgCFCACRw0BCyADQQFHDQIgAUEBNgIgDwsgASADNgIgAkAgASgCLEEERg0AIAFBADsBNCAAKAIIIgAgASACIAJBASAEIAAoAgAoAhQRBgAgAS0ANQRAIAFBAzYCLCABLQA0RQ0BDAMLIAFBBDYCLAsgASACNgIUIAEgASgCKEEBajYCKCABKAIkQQFHDQEgASgCGEECRw0BIAFBAToANg8LIAAoAggiACABIAIgAyAEIAAoAgAoAhgRBAALCzcAIAAgASgCCCAFEA4EQCABIAIgAyAEEBkPCyAAKAIIIgAgASACIAMgBCAFIAAoAgAoAhQRBgALmgEBAn8jAEFAaiIDJAACf0EBIAAgAUEAEA4NABpBACABRQ0AGkEAIAFB5BYQGiIBRQ0AGiADQQxqQTQQDxogA0EBNgI4IANBfzYCFCADIAA2AhAgAyABNgIIIAEgA0EIaiACKAIAQQEgASgCACgCHBECACADKAIgIgBBAUYEQCACIAMoAhg2AgALIABBAUYLIQQgA0FAayQAIAQLCgAgACABQQAQDgsFABAuAAsFABAFAAuQBQEFfwJ/AkACQCAAKAIEIgIiAUEDcUUNAEEAIAEtAABFDQIaA0AgAUEBaiIBQQNxRQ0BIAEtAAANAAsMAQsDQCABIgBBBGohASAAKAIAIgRBf3MgBEGBgoQIa3FBgIGChHhxRQ0ACwNAIAAiAUEBaiEAIAEtAAANAAsLIAEgAmsLQQFqIgEQEiIABH8CfyABQYAETwRAIAAgAiABEAwgAAwBCyAAIAFqIQMCQCAAIAJzQQNxRQRAAkAgAEEDcUUEQCAAIQEMAQsgAUUEQCAAIQEMAQsgACEBA0AgASACLQAAOgAAIAJBAWohAiABQQFqIgFBA3FFDQEgASADSQ0ACwsCQCADQXxxIgVBwABJDQAgASAFQUBqIgRLDQADQCABIAIoAgA2AgAgASACKAIENgIEIAEgAigCCDYCCCABIAIoAgw2AgwgASACKAIQNgIQIAEgAigCFDYCFCABIAIoAhg2AhggASACKAIcNgIcIAEgAigCIDYCICABIAIoAiQ2AiQgASACKAIoNgIoIAEgAigCLDYCLCABIAIoAjA2AjAgASACKAI0NgI0IAEgAigCODYCOCABIAIoAjw2AjwgAkFAayECIAFBQGsiASAETQ0ACwsgASAFTw0BA0AgASACKAIANgIAIAJBBGohAiABQQRqIgEgBUkNAAsMAQsgA0EESQRAIAAhAQwBCyAAIANBBGsiBEsEQCAAIQEMAQsgACEBA0AgASACLQAAOgAAIAEgAi0AAToAASABIAItAAI6AAIgASACLQADOgADIAJBBGohAiABQQRqIgEgBE0NAAsLIAEgA0kEQANAIAEgAi0AADoAACACQQFqIQIgAUEBaiIBIANHDQALCyAACwVBAAsLyAQCCX8GfSMAQRBrIgYkACAGQQA2AgwgBkIANwIEAkAgAkUEQCAGQQRqECAMAQsgAkGAgICAAkkEQCACQQpsIQsgAkEHbCEIIAJBAnQhCSAGIAJBA3QiBRAUIgc2AgQgBiAFIAdqIgo2AgwgByAFEA8hBSAGIAo2AgggACoCKCENIAAqAhghDiAAKgIIIQ8DQCABIARBBXRqIgAqAgghECAAKgIAIREgACoCBCESIAUgBEEDdGoiACAENgIEIABDAEAcRiANIBCUIA8gEZQgDiASlJKSkzgCACAEQQFqIgQgAkcNAAsgAyAJQQJ0aiEHIAMgCEECdGohCCAGQQRqECBBACEAIAYoAgQhCQNAIAMgAEEEdGoiBSABIAkgAEEDdGooAgRBBXRqIgQtABxBgAFrskMAAAA8lDgCACAFIAQtAB1BgAFrskMAAAA8lDgCBCAFIAQtAB5BgAFrskMAAAA8lDgCCCAFIAQtAB9BgAFrskMAAAA8lDgCDCAIIABBDGwiCmoiBSAEKgIAOAIAIAUgBCoCBDgCBCAFIAQqAgg4AgggAyAAQQJ0IAtqQQJ0IgxqIgUgBC0AGLNDAAB/Q5U4AgAgAyAMQQRyaiAELQAZs0MAAH9DlTgCACAFIAQtABqzQwAAf0OVOAIIIAUgBC0AG7NDAAB/Q5U4AgwgByAKaiIFIAQqAgw4AgAgBSAEKgIQOAIEIAUgBCoCFDgCCCAAQQFqIgAgAkcNAAsMAQsQHwALIAYoAgQiAARAIAAQEAsgBkEQaiQACw8AIAEgAiADIAQgABECAAsLkBQCAEGACAv9E3Vuc2lnbmVkIHNob3J0AHJ1blNvcnQAdW5zaWduZWQgaW50AGZsb2F0AHVpbnQ2NF90AHZlY3RvcgB1bnNpZ25lZCBjaGFyAHN0ZDo6ZXhjZXB0aW9uAGJvb2wAZW1zY3JpcHRlbjo6dmFsAHVuc2lnbmVkIGxvbmcAc3RkOjp3c3RyaW5nAHN0ZDo6c3RyaW5nAHN0ZDo6dTE2c3RyaW5nAHN0ZDo6dTMyc3RyaW5nAGRvdWJsZQB2b2lkAGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PHNob3J0PgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzx1bnNpZ25lZCBzaG9ydD4AZW1zY3JpcHRlbjo6bWVtb3J5X3ZpZXc8aW50PgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzx1bnNpZ25lZCBpbnQ+AGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PGZsb2F0PgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzx1aW50OF90PgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzxpbnQ4X3Q+AGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PHVpbnQxNl90PgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzxpbnQxNl90PgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzx1aW50NjRfdD4AZW1zY3JpcHRlbjo6bWVtb3J5X3ZpZXc8aW50NjRfdD4AZW1zY3JpcHRlbjo6bWVtb3J5X3ZpZXc8dWludDMyX3Q+AGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PGludDMyX3Q+AGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PGNoYXI+AGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PHVuc2lnbmVkIGNoYXI+AHN0ZDo6YmFzaWNfc3RyaW5nPHVuc2lnbmVkIGNoYXI+AGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PHNpZ25lZCBjaGFyPgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzxsb25nPgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzx1bnNpZ25lZCBsb25nPgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzxkb3VibGU+ACQMAAB4DAAAeAwAAHgMAAB4DAAAdmlpaWlpAE5TdDNfXzIxMmJhc2ljX3N0cmluZ0ljTlNfMTFjaGFyX3RyYWl0c0ljRUVOU185YWxsb2NhdG9ySWNFRUVFAAAAhA0AAHsHAABOU3QzX18yMTJiYXNpY19zdHJpbmdJaE5TXzExY2hhcl90cmFpdHNJaEVFTlNfOWFsbG9jYXRvckloRUVFRQAAhA0AAMQHAABOU3QzX18yMTJiYXNpY19zdHJpbmdJd05TXzExY2hhcl90cmFpdHNJd0VFTlNfOWFsbG9jYXRvckl3RUVFRQAAhA0AAAwIAABOU3QzX18yMTJiYXNpY19zdHJpbmdJRHNOU18xMWNoYXJfdHJhaXRzSURzRUVOU185YWxsb2NhdG9ySURzRUVFRQAAAIQNAABUCAAATlN0M19fMjEyYmFzaWNfc3RyaW5nSURpTlNfMTFjaGFyX3RyYWl0c0lEaUVFTlNfOWFsbG9jYXRvcklEaUVFRUUAAACEDQAAoAgAAE4xMGVtc2NyaXB0ZW4zdmFsRQAAhA0AAOwIAABOMTBlbXNjcmlwdGVuMTFtZW1vcnlfdmlld0ljRUUAAIQNAAAICQAATjEwZW1zY3JpcHRlbjExbWVtb3J5X3ZpZXdJYUVFAACEDQAAMAkAAE4xMGVtc2NyaXB0ZW4xMW1lbW9yeV92aWV3SWhFRQAAhA0AAFgJAABOMTBlbXNjcmlwdGVuMTFtZW1vcnlfdmlld0lzRUUAAIQNAACACQAATjEwZW1zY3JpcHRlbjExbWVtb3J5X3ZpZXdJdEVFAACEDQAAqAkAAE4xMGVtc2NyaXB0ZW4xMW1lbW9yeV92aWV3SWlFRQAAhA0AANAJAABOMTBlbXNjcmlwdGVuMTFtZW1vcnlfdmlld0lqRUUAAIQNAAD4CQAATjEwZW1zY3JpcHRlbjExbWVtb3J5X3ZpZXdJbEVFAACEDQAAIAoAAE4xMGVtc2NyaXB0ZW4xMW1lbW9yeV92aWV3SW1FRQAAhA0AAEgKAABOMTBlbXNjcmlwdGVuMTFtZW1vcnlfdmlld0l4RUUAAIQNAABwCgAATjEwZW1zY3JpcHRlbjExbWVtb3J5X3ZpZXdJeUVFAACEDQAAmAoAAE4xMGVtc2NyaXB0ZW4xMW1lbW9yeV92aWV3SWZFRQAAhA0AAMAKAABOMTBlbXNjcmlwdGVuMTFtZW1vcnlfdmlld0lkRUUAAIQNAADoCgAATjEwX19jeHhhYml2MTE2X19zaGltX3R5cGVfaW5mb0UAAAAAxA0AABALAAC0DQAATjEwX19jeHhhYml2MTE3X19jbGFzc190eXBlX2luZm9FAAAAxA0AAEALAAA0CwAATjEwX19jeHhhYml2MTE3X19wYmFzZV90eXBlX2luZm9FAAAAxA0AAHALAAA0CwAATjEwX19jeHhhYml2MTE5X19wb2ludGVyX3R5cGVfaW5mb0UAxA0AAKALAACUCwAAAAAAABQMAAAHAAAACAAAAAkAAAAKAAAACwAAAE4xMF9fY3h4YWJpdjEyM19fZnVuZGFtZW50YWxfdHlwZV9pbmZvRQDEDQAA7AsAADQLAAB2AAAA2AsAACAMAABiAAAA2AsAACwMAABjAAAA2AsAADgMAABoAAAA2AsAAEQMAABhAAAA2AsAAFAMAABzAAAA2AsAAFwMAAB0AAAA2AsAAGgMAABpAAAA2AsAAHQMAABqAAAA2AsAAIAMAABsAAAA2AsAAIwMAABtAAAA2AsAAJgMAAB4AAAA2AsAAKQMAAB5AAAA2AsAALAMAABmAAAA2AsAALwMAABkAAAA2AsAAMgMAABOMTBfX2N4eGFiaXYxMjBfX3NpX2NsYXNzX3R5cGVfaW5mb0UAAAAAxA0AANQMAABkCwAAU3Q5ZXhjZXB0aW9uAAAAAAAAAAA8DQAABAAAAAwAAAANAAAAU3QxMWxvZ2ljX2Vycm9yAMQNAAAsDQAA5A0AAAAAAABwDQAABAAAAA4AAAANAAAAU3QxMmxlbmd0aF9lcnJvcgAAAADEDQAAXA0AADwNAAAAAAAAZAsAAAcAAAAPAAAACQAAAAoAAAAQAAAAEQAAABIAAAATAAAAU3Q5dHlwZV9pbmZvAAAAAIQNAACkDQAAAAAAAPwMAAAHAAAAFAAAAAkAAAAKAAAAEAAAABUAAAAWAAAAFwAAAIQNAAAIDQAAAAAAAOQNAAAYAAAAGQAAABoAQYAcCwUgEAEABg==", self.location.href).href;
+      }
+      function getBinarySync(file) {
+        if (file == wasmBinaryFile && wasmBinary) {
+          return new Uint8Array(wasmBinary);
+        }
+        if (readBinary) {
+          return readBinary(file);
+        }
+        throw "both async and sync fetching of the wasm failed";
+      }
+      function getBinaryPromise(binaryFile) {
+        if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+          if (typeof fetch == "function") {
+            return fetch(binaryFile, { credentials: "same-origin" }).then((response) => {
+              if (!response["ok"]) {
+                throw "failed to load wasm binary file at '" + binaryFile + "'";
+              }
+              return response["arrayBuffer"]();
+            }).catch(() => getBinarySync(binaryFile));
+          }
+        }
+        return Promise.resolve().then(() => getBinarySync(binaryFile));
+      }
+      function instantiateArrayBuffer(binaryFile, imports, receiver) {
+        return getBinaryPromise(binaryFile).then((binary) => WebAssembly.instantiate(binary, imports)).then((instance) => instance).then(receiver, (reason) => {
+          err(`failed to asynchronously prepare wasm: ${reason}`);
+          abort(reason);
+        });
+      }
+      function instantiateAsync(binary, binaryFile, imports, callback) {
+        if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && typeof fetch == "function") {
+          return fetch(binaryFile, { credentials: "same-origin" }).then((response) => {
+            var result = WebAssembly.instantiateStreaming(response, imports);
+            return result.then(callback, function(reason) {
+              err(`wasm streaming compile failed: ${reason}`);
+              err("falling back to ArrayBuffer instantiation");
+              return instantiateArrayBuffer(binaryFile, imports, callback);
+            });
+          });
+        }
+        return instantiateArrayBuffer(binaryFile, imports, callback);
+      }
+      function createWasm() {
+        var info = { "a": wasmImports };
+        function receiveInstance(instance, module) {
+          wasmExports = instance.exports;
+          wasmMemory = wasmExports["o"];
+          updateMemoryViews();
+          wasmTable = wasmExports["s"];
+          addOnInit(wasmExports["p"]);
+          removeRunDependency();
+          return wasmExports;
+        }
+        addRunDependency();
+        function receiveInstantiationResult(result) {
+          receiveInstance(result["instance"]);
+        }
+        if (Module2["instantiateWasm"]) {
+          try {
+            return Module2["instantiateWasm"](info, receiveInstance);
+          } catch (e) {
+            err(`Module.instantiateWasm callback failed with error: ${e}`);
+            readyPromiseReject(e);
+          }
+        }
+        instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
+        return {};
+      }
+      var callRuntimeCallbacks = (callbacks) => {
+        while (callbacks.length > 0) {
+          callbacks.shift()(Module2);
+        }
+      };
+      Module2["noExitRuntime"] || true;
+      function ExceptionInfo(excPtr) {
+        this.excPtr = excPtr;
+        this.ptr = excPtr - 24;
+        this.set_type = function(type) {
+          HEAPU32[this.ptr + 4 >> 2] = type;
+        };
+        this.get_type = function() {
+          return HEAPU32[this.ptr + 4 >> 2];
+        };
+        this.set_destructor = function(destructor) {
+          HEAPU32[this.ptr + 8 >> 2] = destructor;
+        };
+        this.get_destructor = function() {
+          return HEAPU32[this.ptr + 8 >> 2];
+        };
+        this.set_caught = function(caught) {
+          caught = caught ? 1 : 0;
+          HEAP8[this.ptr + 12 >> 0] = caught;
+        };
+        this.get_caught = function() {
+          return HEAP8[this.ptr + 12 >> 0] != 0;
+        };
+        this.set_rethrown = function(rethrown) {
+          rethrown = rethrown ? 1 : 0;
+          HEAP8[this.ptr + 13 >> 0] = rethrown;
+        };
+        this.get_rethrown = function() {
+          return HEAP8[this.ptr + 13 >> 0] != 0;
+        };
+        this.init = function(type, destructor) {
+          this.set_adjusted_ptr(0);
+          this.set_type(type);
+          this.set_destructor(destructor);
+        };
+        this.set_adjusted_ptr = function(adjustedPtr) {
+          HEAPU32[this.ptr + 16 >> 2] = adjustedPtr;
+        };
+        this.get_adjusted_ptr = function() {
+          return HEAPU32[this.ptr + 16 >> 2];
+        };
+        this.get_exception_ptr = function() {
+          var isPointer = ___cxa_is_pointer_type(this.get_type());
+          if (isPointer) {
+            return HEAPU32[this.excPtr >> 2];
+          }
+          var adjusted = this.get_adjusted_ptr();
+          if (adjusted !== 0)
+            return adjusted;
+          return this.excPtr;
+        };
+      }
+      var exceptionLast = 0;
+      var ___cxa_throw = (ptr, type, destructor) => {
+        var info = new ExceptionInfo(ptr);
+        info.init(type, destructor);
+        exceptionLast = ptr;
+        throw exceptionLast;
+      };
+      var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {
+      };
+      var 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 = (ptr) => {
+        var ret = "";
+        var c = ptr;
+        while (HEAPU8[c]) {
+          ret += embind_charCodes[HEAPU8[c++]];
+        }
+        return ret;
+      };
+      var awaitingDependencies = {};
+      var registeredTypes = {};
+      var typeDependencies = {};
+      var BindingError;
+      var throwBindingError = (message) => {
+        throw new BindingError(message);
+      };
+      var InternalError;
+      var throwInternalError = (message) => {
+        throw new InternalError(message);
+      };
+      var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {
+        myTypes.forEach(function(type) {
+          typeDependencies[type] = dependentTypes;
+        });
+        function onComplete(typeConverters2) {
+          var myTypeConverters = getTypeConverters(typeConverters2);
+          if (myTypeConverters.length !== myTypes.length) {
+            throwInternalError("Mismatched type converter count");
+          }
+          for (var i = 0; i < myTypes.length; ++i) {
+            registerType(myTypes[i], myTypeConverters[i]);
+          }
+        }
+        var typeConverters = new Array(dependentTypes.length);
+        var unregisteredTypes = [];
+        var registered = 0;
+        dependentTypes.forEach((dt, i) => {
+          if (registeredTypes.hasOwnProperty(dt)) {
+            typeConverters[i] = registeredTypes[dt];
+          } else {
+            unregisteredTypes.push(dt);
+            if (!awaitingDependencies.hasOwnProperty(dt)) {
+              awaitingDependencies[dt] = [];
+            }
+            awaitingDependencies[dt].push(() => {
+              typeConverters[i] = registeredTypes[dt];
+              ++registered;
+              if (registered === unregisteredTypes.length) {
+                onComplete(typeConverters);
+              }
+            });
+          }
+        });
+        if (0 === unregisteredTypes.length) {
+          onComplete(typeConverters);
+        }
+      };
+      function sharedRegisterType(rawType, registeredInstance, options = {}) {
+        var name = registeredInstance.name;
+        if (!rawType) {
+          throwBindingError(`type "${name}" must have a positive integer typeid pointer`);
+        }
+        if (registeredTypes.hasOwnProperty(rawType)) {
+          if (options.ignoreDuplicateRegistrations) {
+            return;
+          } else {
+            throwBindingError(`Cannot register type '${name}' twice`);
+          }
+        }
+        registeredTypes[rawType] = registeredInstance;
+        delete typeDependencies[rawType];
+        if (awaitingDependencies.hasOwnProperty(rawType)) {
+          var callbacks = awaitingDependencies[rawType];
+          delete awaitingDependencies[rawType];
+          callbacks.forEach((cb) => cb());
+        }
+      }
+      function registerType(rawType, registeredInstance, options = {}) {
+        if (!("argPackAdvance" in registeredInstance)) {
+          throw new TypeError("registerType registeredInstance requires argPackAdvance");
+        }
+        return sharedRegisterType(rawType, registeredInstance, options);
+      }
+      var GenericWireTypeSize = 8;
+      var __embind_register_bool = (rawType, name, trueValue, falseValue) => {
+        name = readLatin1String(name);
+        registerType(rawType, { name, "fromWireType": function(wt) {
+          return !!wt;
+        }, "toWireType": function(destructors, o) {
+          return o ? trueValue : falseValue;
+        }, "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": function(pointer) {
+          return this["fromWireType"](HEAPU8[pointer]);
+        }, destructorFunction: null });
+      };
+      function handleAllocatorInit() {
+        Object.assign(HandleAllocator.prototype, { get(id) {
+          return this.allocated[id];
+        }, has(id) {
+          return this.allocated[id] !== void 0;
+        }, allocate(handle) {
+          var id = this.freelist.pop() || this.allocated.length;
+          this.allocated[id] = handle;
+          return id;
+        }, free(id) {
+          this.allocated[id] = void 0;
+          this.freelist.push(id);
+        } });
+      }
+      function HandleAllocator() {
+        this.allocated = [void 0];
+        this.freelist = [];
+      }
+      var emval_handles = new HandleAllocator();
+      var __emval_decref = (handle) => {
+        if (handle >= emval_handles.reserved && 0 === --emval_handles.get(handle).refcount) {
+          emval_handles.free(handle);
+        }
+      };
+      var count_emval_handles = () => {
+        var count = 0;
+        for (var i = emval_handles.reserved; i < emval_handles.allocated.length; ++i) {
+          if (emval_handles.allocated[i] !== void 0) {
+            ++count;
+          }
+        }
+        return count;
+      };
+      var init_emval = () => {
+        emval_handles.allocated.push({ value: void 0 }, { value: null }, { value: true }, { value: false });
+        emval_handles.reserved = emval_handles.allocated.length;
+        Module2["count_emval_handles"] = count_emval_handles;
+      };
+      var Emval = { toValue: (handle) => {
+        if (!handle) {
+          throwBindingError("Cannot use deleted val. handle = " + handle);
+        }
+        return emval_handles.get(handle).value;
+      }, toHandle: (value) => {
+        switch (value) {
+          case void 0:
+            return 1;
+          case null:
+            return 2;
+          case true:
+            return 3;
+          case false:
+            return 4;
+          default: {
+            return emval_handles.allocate({ refcount: 1, value });
+          }
+        }
+      } };
+      function simpleReadValueFromPointer(pointer) {
+        return this["fromWireType"](HEAP32[pointer >> 2]);
+      }
+      var __embind_register_emval = (rawType, name) => {
+        name = readLatin1String(name);
+        registerType(rawType, { name, "fromWireType": (handle) => {
+          var rv = Emval.toValue(handle);
+          __emval_decref(handle);
+          return rv;
+        }, "toWireType": (destructors, value) => Emval.toHandle(value), "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": simpleReadValueFromPointer, destructorFunction: null });
+      };
+      var 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 (${width}): ${name}`);
+        }
+      };
+      var __embind_register_float = (rawType, name, size) => {
+        name = readLatin1String(name);
+        registerType(rawType, { name, "fromWireType": (value) => value, "toWireType": (destructors, value) => value, "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": floatReadValueFromPointer(name, size), destructorFunction: null });
+      };
+      var createNamedFunction = (name, body) => Object.defineProperty(body, "name", { value: name });
+      var runDestructors = (destructors) => {
+        while (destructors.length) {
+          var ptr = destructors.pop();
+          var del = destructors.pop();
+          del(ptr);
+        }
+      };
+      function newFunc(constructor, argumentList) {
+        if (!(constructor instanceof Function)) {
+          throw new TypeError(`new_ called with constructor type ${typeof constructor} which is not a function`);
+        }
+        var dummy = createNamedFunction(constructor.name || "unknownFunctionName", function() {
+        });
+        dummy.prototype = constructor.prototype;
+        var obj = new dummy();
+        var r = constructor.apply(obj, argumentList);
+        return r instanceof Object ? r : obj;
+      }
+      function 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 = false;
+        for (var i = 1; i < argTypes.length; ++i) {
+          if (argTypes[i] !== null && argTypes[i].destructorFunction === void 0) {
+            needsDestructorStack = true;
+            break;
+          }
+        }
+        var returns = argTypes[0].name !== "void";
+        var argsList = "";
+        var argsListWired = "";
+        for (var i = 0; i < argCount - 2; ++i) {
+          argsList += (i !== 0 ? ", " : "") + "arg" + i;
+          argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired";
+        }
+        var invokerFnBody = `
+        return function (${argsList}) {
+        if (arguments.length !== ${argCount - 2}) {
+          throwBindingError('function ${humanName} called with ' + arguments.length + ' arguments, expected ${argCount - 2}');
+        }`;
+        if (needsDestructorStack) {
+          invokerFnBody += "var destructors = [];\n";
+        }
+        var dtorStack = needsDestructorStack ? "destructors" : "null";
+        var args1 = ["throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"];
+        var args2 = [throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];
+        if (isClassMethodFunc) {
+          invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n";
+        }
+        for (var i = 0; i < argCount - 2; ++i) {
+          invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n";
+          args1.push("argType" + i);
+          args2.push(argTypes[i + 2]);
+        }
+        if (isClassMethodFunc) {
+          argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired;
+        }
+        invokerFnBody += (returns || 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 += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n";
+              args1.push(paramName + "_dtor");
+              args2.push(argTypes[i].destructorFunction);
+            }
+          }
+        }
+        if (returns) {
+          invokerFnBody += "var ret = retType.fromWireType(rv);\nreturn ret;\n";
+        }
+        invokerFnBody += "}\n";
+        args1.push(invokerFnBody);
+        var invokerFn = newFunc(Function, args1).apply(null, args2);
+        return createNamedFunction(humanName, invokerFn);
+      }
+      var ensureOverloadTable = (proto, methodName, humanName) => {
+        if (void 0 === proto[methodName].overloadTable) {
+          var prevFunc = proto[methodName];
+          proto[methodName] = function() {
+            if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
+              throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${arguments.length}) - expects one of (${proto[methodName].overloadTable})!`);
+            }
+            return proto[methodName].overloadTable[arguments.length].apply(this, arguments);
+          };
+          proto[methodName].overloadTable = [];
+          proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
+        }
+      };
+      var exposePublicSymbol = (name, value, numArguments) => {
+        if (Module2.hasOwnProperty(name)) {
+          if (void 0 === numArguments || void 0 !== Module2[name].overloadTable && void 0 !== Module2[name].overloadTable[numArguments]) {
+            throwBindingError(`Cannot register public name '${name}' twice`);
+          }
+          ensureOverloadTable(Module2, name, name);
+          if (Module2.hasOwnProperty(numArguments)) {
+            throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`);
+          }
+          Module2[name].overloadTable[numArguments] = value;
+        } else {
+          Module2[name] = value;
+          if (void 0 !== numArguments) {
+            Module2[name].numArguments = numArguments;
+          }
+        }
+      };
+      var heap32VectorToArray = (count, firstElement) => {
+        var array = [];
+        for (var i = 0; i < count; i++) {
+          array.push(HEAPU32[firstElement + i * 4 >> 2]);
+        }
+        return array;
+      };
+      var replacePublicSymbol = (name, value, numArguments) => {
+        if (!Module2.hasOwnProperty(name)) {
+          throwInternalError("Replacing nonexistant public symbol");
+        }
+        if (void 0 !== Module2[name].overloadTable && void 0 !== numArguments) {
+          Module2[name].overloadTable[numArguments] = value;
+        } else {
+          Module2[name] = value;
+          Module2[name].argCount = numArguments;
+        }
+      };
+      var dynCallLegacy = (sig, ptr, args) => {
+        var f = Module2["dynCall_" + sig];
+        return args && args.length ? f.apply(null, [ptr].concat(args)) : f.call(null, ptr);
+      };
+      var wasmTableMirror = [];
+      var wasmTable;
+      var 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 dynCall = (sig, ptr, args) => {
+        if (sig.includes("j")) {
+          return dynCallLegacy(sig, ptr, args);
+        }
+        var rtn = getWasmTableEntry(ptr).apply(null, args);
+        return rtn;
+      };
+      var getDynCaller = (sig, ptr) => {
+        var argCache = [];
+        return function() {
+          argCache.length = 0;
+          Object.assign(argCache, arguments);
+          return dynCall(sig, ptr, argCache);
+        };
+      };
+      var embind__requireFunction = (signature, rawFunction) => {
+        signature = readLatin1String(signature);
+        function makeDynCaller() {
+          if (signature.includes("j")) {
+            return getDynCaller(signature, rawFunction);
+          }
+          return getWasmTableEntry(rawFunction);
+        }
+        var fp = makeDynCaller();
+        if (typeof fp != "function") {
+          throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`);
+        }
+        return fp;
+      };
+      var extendError = (baseErrorType, errorName) => {
+        var errorClass = createNamedFunction(errorName, function(message) {
+          this.name = errorName;
+          this.message = message;
+          var stack = new Error(message).stack;
+          if (stack !== void 0) {
+            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 === void 0) {
+            return this.name;
+          } else {
+            return `${this.name}: ${this.message}`;
+          }
+        };
+        return errorClass;
+      };
+      var UnboundTypeError;
+      var getTypeName = (type) => {
+        var ptr = ___getTypeName(type);
+        var rv = readLatin1String(ptr);
+        _free(ptr);
+        return rv;
+      };
+      var throwUnboundTypeError = (message, types) => {
+        var unboundTypes = [];
+        var seen = {};
+        function visit(type) {
+          if (seen[type]) {
+            return;
+          }
+          if (registeredTypes[type]) {
+            return;
+          }
+          if (typeDependencies[type]) {
+            typeDependencies[type].forEach(visit);
+            return;
+          }
+          unboundTypes.push(type);
+          seen[type] = true;
+        }
+        types.forEach(visit);
+        throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([", "]));
+      };
+      var getFunctionName = (signature) => {
+        signature = signature.trim();
+        const argsIndex = signature.indexOf("(");
+        if (argsIndex !== -1) {
+          return signature.substr(0, argsIndex);
+        } else {
+          return signature;
+        }
+      };
+      var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) => {
+        var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+        name = readLatin1String(name);
+        name = getFunctionName(name);
+        rawInvoker = embind__requireFunction(signature, rawInvoker);
+        exposePublicSymbol(name, function() {
+          throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes);
+        }, argCount - 1);
+        whenDependentTypesAreResolved([], argTypes, function(argTypes2) {
+          var invokerArgsArray = [argTypes2[0], null].concat(argTypes2.slice(1));
+          replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn, isAsync), argCount - 1);
+          return [];
+        });
+      };
+      var integerReadValueFromPointer = (name, width, signed) => {
+        switch (width) {
+          case 1:
+            return signed ? (pointer) => HEAP8[pointer >> 0] : (pointer) => HEAPU8[pointer >> 0];
+          case 2:
+            return signed ? (pointer) => HEAP16[pointer >> 1] : (pointer) => HEAPU16[pointer >> 1];
+          case 4:
+            return signed ? (pointer) => HEAP32[pointer >> 2] : (pointer) => HEAPU32[pointer >> 2];
+          default:
+            throw new TypeError(`invalid integer width (${width}): ${name}`);
+        }
+      };
+      var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => {
+        name = readLatin1String(name);
+        var fromWireType = (value) => value;
+        if (minRange === 0) {
+          var bitshift = 32 - 8 * size;
+          fromWireType = (value) => value << bitshift >>> bitshift;
+        }
+        var isUnsignedType = name.includes("unsigned");
+        var checkAssertions = (value, toTypeName) => {
+        };
+        var toWireType;
+        if (isUnsignedType) {
+          toWireType = function(destructors, value) {
+            checkAssertions(value, this.name);
+            return value >>> 0;
+          };
+        } else {
+          toWireType = function(destructors, value) {
+            checkAssertions(value, this.name);
+            return value;
+          };
+        }
+        registerType(primitiveType, { name, "fromWireType": fromWireType, "toWireType": toWireType, "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": integerReadValueFromPointer(name, size, minRange !== 0), destructorFunction: null });
+      };
+      var __embind_register_memory_view = (rawType, dataTypeIndex, name) => {
+        var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
+        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, "fromWireType": decodeMemoryView, "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": decodeMemoryView }, { ignoreDuplicateRegistrations: true });
+      };
+      function readPointer(pointer) {
+        return this["fromWireType"](HEAPU32[pointer >> 2]);
+      }
+      var 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 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+      var 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") : void 0;
+      var 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 = (ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+      var __embind_register_std_string = (rawType, name) => {
+        name = readLatin1String(name);
+        var stdStringIsUTF8 = name === "std::string";
+        registerType(rawType, { name, "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 === void 0) {
+                  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"(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(ptr) {
+          _free(ptr);
+        } });
+      };
+      var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : void 0;
+      var 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 = (str, outPtr, maxBytesToWrite) => {
+        if (maxBytesToWrite === void 0) {
+          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 = (str) => str.length * 2;
+      var 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 = (str, outPtr, maxBytesToWrite) => {
+        if (maxBytesToWrite === void 0) {
+          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 = (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 = (rawType, charSize, name) => {
+        name = readLatin1String(name);
+        var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
+        if (charSize === 2) {
+          decodeString = UTF16ToString;
+          encodeString = stringToUTF16;
+          lengthBytesUTF = lengthBytesUTF16;
+          getHeap = () => HEAPU16;
+          shift = 1;
+        } else if (charSize === 4) {
+          decodeString = UTF32ToString;
+          encodeString = stringToUTF32;
+          lengthBytesUTF = lengthBytesUTF32;
+          getHeap = () => HEAPU32;
+          shift = 2;
+        }
+        registerType(rawType, { name, "fromWireType": (value) => {
+          var length = HEAPU32[value >> 2];
+          var HEAP = getHeap();
+          var str;
+          var decodeStartPtr = value + 4;
+          for (var i = 0; i <= length; ++i) {
+            var currentBytePtr = value + 4 + i * charSize;
+            if (i == length || HEAP[currentBytePtr >> shift] == 0) {
+              var maxReadBytes = currentBytePtr - decodeStartPtr;
+              var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
+              if (str === void 0) {
+                str = stringSegment;
+              } else {
+                str += String.fromCharCode(0);
+                str += stringSegment;
+              }
+              decodeStartPtr = currentBytePtr + charSize;
+            }
+          }
+          _free(value);
+          return str;
+        }, "toWireType": (destructors, value) => {
+          if (!(typeof value == "string")) {
+            throwBindingError(`Cannot pass non-string to C++ string type ${name}`);
+          }
+          var length = lengthBytesUTF(value);
+          var ptr = _malloc(4 + length + charSize);
+          HEAPU32[ptr >> 2] = length >> shift;
+          encodeString(value, ptr + 4, length + charSize);
+          if (destructors !== null) {
+            destructors.push(_free, ptr);
+          }
+          return ptr;
+        }, "argPackAdvance": GenericWireTypeSize, "readValueFromPointer": simpleReadValueFromPointer, destructorFunction(ptr) {
+          _free(ptr);
+        } });
+      };
+      var __embind_register_void = (rawType, name) => {
+        name = readLatin1String(name);
+        registerType(rawType, { isVoid: true, name, "argPackAdvance": 0, "fromWireType": () => void 0, "toWireType": (destructors, o) => void 0 });
+      };
+      var _abort = () => {
+        abort("");
+      };
+      var _emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num);
+      var getHeapMax = () => 2147483648;
+      var 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 = (requestedSize) => {
+        var oldSize = HEAPU8.length;
+        requestedSize >>>= 0;
+        var maxHeapSize = getHeapMax();
+        if (requestedSize > maxHeapSize) {
+          return false;
+        }
+        var alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
+        for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+          var overGrownHeapSize = oldSize * (1 + 0.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;
+      };
+      embind_init_charCodes();
+      BindingError = Module2["BindingError"] = class BindingError extends Error {
+        constructor(message) {
+          super(message);
+          this.name = "BindingError";
+        }
+      };
+      InternalError = Module2["InternalError"] = class InternalError extends Error {
+        constructor(message) {
+          super(message);
+          this.name = "InternalError";
+        }
+      };
+      handleAllocatorInit();
+      init_emval();
+      UnboundTypeError = Module2["UnboundTypeError"] = extendError(Error, "UnboundTypeError");
+      var wasmImports = { n: ___cxa_throw, k: __embind_register_bigint, i: __embind_register_bool, h: __embind_register_emval, d: __embind_register_float, g: __embind_register_function, b: __embind_register_integer, a: __embind_register_memory_view, e: __embind_register_std_string, c: __embind_register_std_wstring, j: __embind_register_void, f: _abort, m: _emscripten_memcpy_js, l: _emscripten_resize_heap };
+      var wasmExports = createWasm();
+      var ___getTypeName = (a0) => (___getTypeName = wasmExports["q"])(a0);
+      var _malloc = Module2["_malloc"] = (a0) => (_malloc = Module2["_malloc"] = wasmExports["r"])(a0);
+      var _free = Module2["_free"] = (a0) => (_free = Module2["_free"] = wasmExports["t"])(a0);
+      var ___cxa_is_pointer_type = (a0) => (___cxa_is_pointer_type = wasmExports["u"])(a0);
+      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;
+          Module2["calledRun"] = true;
+          if (ABORT)
+            return;
+          initRuntime();
+          readyPromiseResolve(Module2);
+          if (Module2["onRuntimeInitialized"])
+            Module2["onRuntimeInitialized"]();
+          postRun();
+        }
+        if (Module2["setStatus"]) {
+          Module2["setStatus"]("Running...");
+          setTimeout(function() {
+            setTimeout(function() {
+              Module2["setStatus"]("");
+            }, 1);
+            doRun();
+          }, 1);
+        } else {
+          doRun();
+        }
+      }
+      if (Module2["preInit"]) {
+        if (typeof Module2["preInit"] == "function")
+          Module2["preInit"] = [Module2["preInit"]];
+        while (Module2["preInit"].length > 0) {
+          Module2["preInit"].pop()();
+        }
+      }
+      run();
+      return moduleArg.ready;
+    };
+  })();
+  class BufferPool {
+    constructor(bufferSize, initialPoolSize = 0) {
+      this.bufferSize = bufferSize;
+      this.pool = [];
+      this.initPool(initialPoolSize);
+    }
+    initPool(initialPoolSize) {
+      for (let i = 0; i < initialPoolSize; i++) {
+        this.pool.push(new ArrayBuffer(this.bufferSize));
+      }
+    }
+    getBuffer() {
+      if (this.pool.length > 0) {
+        return this.pool.pop();
+      } else {
+        return new ArrayBuffer(this.bufferSize);
+      }
+    }
+    returnBuffer(buffer) {
+      if (buffer.byteLength === this.bufferSize) {
+        this.pool.push(buffer);
+      }
+    }
+  }
+  class WasmSorter {
+    constructor(_vertexCount, _globalBuffer) {
+      this._vertexCount = _vertexCount;
+      this._globalBuffer = _globalBuffer;
+      const combinedLength = this._calculateCombinedLength();
+      this._bufferPool = new BufferPool(combinedLength, 2);
+    }
+    async load() {
+      this.module = await Module();
+      this._viewProjPtr = this.module._malloc(16 * Float32Array.BYTES_PER_ELEMENT);
+      this._globalBufferPtr = this.module._malloc(this._vertexCount * 32);
+      this._combinedPtr = this.module._malloc(this._calculateCombinedLength());
+      this.module.HEAPU8.set(this._globalBuffer, this._globalBufferPtr);
+    }
+    runSort(viewProj) {
+      this.module.HEAPF32.set(viewProj, this._viewProjPtr / Float32Array.BYTES_PER_ELEMENT);
+      this.module.runSort(this._viewProjPtr, this._globalBufferPtr, this._vertexCount, this._combinedPtr);
+      const byteStart = this._combinedPtr;
+      const byteLength = this._calculateCombinedLength();
+      const bufferToTransfer = this._bufferPool.getBuffer();
+      new Uint8Array(bufferToTransfer).set(new Uint8Array(this.module.HEAPU8.buffer, byteStart, byteLength));
+      return transfer(bufferToTransfer, [bufferToTransfer]);
+    }
+    returnBuffer(buffer) {
+      this._bufferPool.returnBuffer(buffer);
+    }
+    _calculateCombinedLength() {
+      return 4 * 4 * this._vertexCount + 3 * 4 * this._vertexCount + 3 * 4 * this._vertexCount + 4 * 4 * this._vertexCount * Float32Array.BYTES_PER_ELEMENT;
+    }
+    dispose() {
+      if (this.module) {
+        this.module._free(this._viewProjPtr);
+        this.module._free(this._globalBufferPtr);
+        this.module._free(this._combinedPtr);
+      }
+    }
+  }
+  expose(WasmSorter);
+})();
+//# sourceMappingURL=worker-dK7pvmNj.js.map