mxdraw 0.1.2 → 0.1.5

package/dist/lib/MxModule/loadCoreCode/mxcadassembly_es5.js

@@ -0,0 +1,1519 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function mxcadassemblyinit() {
+    var mxcadassembly = (function () {
+        var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
+        if (typeof __filename !== 'undefined')
+            _scriptDir = _scriptDir || __filename;
+        return (function (mxcadassembly) {
+            mxcadassembly = mxcadassembly || {};
+            var b;
+            b || (b = typeof mxcadassembly !== 'undefined' ? mxcadassembly : {});
+            var g, k;
+            b.ready = new Promise(function (a, c) { g = a; k = c; });
+            var l = Object.assign({}, b), m = "object" == typeof window, n = "function" == typeof importScripts, p = "object" == typeof process && "object" == typeof process.versions && "string" == typeof process.versions.node, q = "", r, t, u, fs, v, w;
+            if (p)
+                q = n ? require("path").dirname(q) + "/" : __dirname + "/", w = function () { v || (fs = require("fs"), v = require("path")); }, r = function (a, c) { var d = x(a); if (d)
+                    return c ? d : d.toString(); w(); a = v.normalize(a); return fs.readFileSync(a, c ? void 0 : "utf8"); }, u = function (a) { a = r(a, !0); a.buffer || (a = new Uint8Array(a)); return a; }, t = function (a, c, d) { var e = x(a); e && c(e); w(); a = v.normalize(a); fs.readFile(a, function (f, h) { f ? d(f) : c(h.buffer); }); }, 1 < process.argv.length && process.argv[1].replace(/\\/g, "/"), process.argv.slice(2), process.on("uncaughtException", function (a) {
+                    throw a;
+                }), process.on("unhandledRejection", function (a) { throw a; }), b.inspect = function () { return "[Emscripten Module object]"; };
+            else if (m || n)
+                n ? q = self.location.href : "undefined" != typeof document && document.currentScript && (q = document.currentScript.src), _scriptDir && (q = _scriptDir), q = 0 !== q.indexOf("blob:") ? q.substr(0, q.replace(/[?#].*/, "").lastIndexOf("/") + 1) : "", r = function (a) {
+                    try {
+                        var c = new XMLHttpRequest;
+                        c.open("GET", a, !1);
+                        c.send(null);
+                        return c.responseText;
+                    }
+                    catch (f) {
+                        if (a = x(a)) {
+                            c = [];
+                            for (var d = 0; d < a.length; d++) {
+                                var e = a[d];
+                                255 <
+                                    e && (aa && y("Character code " + e + " (" + String.fromCharCode(e) + ")  at offset " + d + " not in 0x00-0xFF."), e &= 255);
+                                c.push(String.fromCharCode(e));
+                            }
+                            return c.join("");
+                        }
+                        throw f;
+                    }
+                }, n && (u = function (a) { try {
+                    var c = new XMLHttpRequest;
+                    c.open("GET", a, !1);
+                    c.responseType = "arraybuffer";
+                    c.send(null);
+                    return new Uint8Array(c.response);
+                }
+                catch (d) {
+                    if (a = x(a))
+                        return a;
+                    throw d;
+                } }), t = function (a, c, d) {
+                    var e = new XMLHttpRequest;
+                    e.open("GET", a, !0);
+                    e.responseType = "arraybuffer";
+                    e.onload = function () {
+                        if (200 == e.status || 0 == e.status && e.response)
+                            c(e.response);
+                        else {
+                            var f = x(a);
+                            f ? c(f.buffer) : d();
+                        }
+                    };
+                    e.onerror = d;
+                    e.send(null);
+                };
+            b.print || console.log.bind(console);
+            var z = b.printErr || console.warn.bind(console);
+            Object.assign(b, l);
+            l = null;
+            var A;
+            b.wasmBinary && (A = b.wasmBinary);
+            var noExitRuntime = b.noExitRuntime || !0;
+            function ba() { this.buffer = new ArrayBuffer(B / 65536 * 65536); }
+            function da() {
+                this.exports = (
+                // EMSCRIPTEN_START_ASM
+                function instantiate(X) {
+                    function e(f) { f.grow = function (b) { var a = this.length; this.length = this.length + b; return a; }; f.set = function (c, d) { this[c] = d; }; f.get = function (c) { return this[c]; }; return f; }
+                    var g;
+                    var h = new Uint8Array(123);
+                    for (var c = 25; c >= 0; --c) {
+                        h[48 + c] = 52 + c;
+                        h[65 + c] = c;
+                        h[97 + c] = 26 + c;
+                    }
+                    h[43] = 62;
+                    h[47] = 63;
+                    function n(o, p, q) { var i, j, c = 0, k = p, l = q.length, m = p + (l * 3 >> 2) - (q[l - 2] == "=") - (q[l - 1] == "="); for (; c < l; c += 4) {
+                        i = h[q.charCodeAt(c + 1)];
+                        j = h[q.charCodeAt(c + 2)];
+                        o[k++] = h[q.charCodeAt(c)] << 2 | i >> 4;
+                        if (k < m)
+                            o[k++] = i << 4 | j >> 2;
+                        if (k < m)
+                            o[k++] = j << 6 | h[q.charCodeAt(c + 3)];
+                    } }
+                    function r(s) { n(g, 1024, "YAZQ"); }
+                    function V(W) {
+                        var t = W.a;
+                        var u = t.buffer;
+                        var v = new Int8Array(u);
+                        var w = new Int16Array(u);
+                        var x = new Int32Array(u);
+                        var y = new Uint8Array(u);
+                        var z = new Uint16Array(u);
+                        var A = new Uint32Array(u);
+                        var B = new Float32Array(u);
+                        var C = new Float64Array(u);
+                        var D = Math.imul;
+                        var E = Math.fround;
+                        var F = Math.abs;
+                        var G = Math.clz32;
+                        var H = Math.min;
+                        var I = Math.max;
+                        var J = Math.floor;
+                        var K = Math.ceil;
+                        var L = Math.trunc;
+                        var M = Math.sqrt;
+                        var N = W.abort;
+                        var O = NaN;
+                        var P = Infinity;
+                        var Q = W.b;
+                        var R = W.c;
+                        var S = 5244512;
+                        // EMSCRIPTEN_START_FUNCS
+                        function Z() { var a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0, i = 0, j = 0, k = 0; a: {
+                            while (1) {
+                                k = S - 16 | 0;
+                                S = k;
+                                e = x[283];
+                                a = e >>> 2 | 0;
+                                b: {
+                                    if (a & 3) {
+                                        c = ((a ^ -1) & 1) + 2 | 0;
+                                        f = c << 3;
+                                        b = x[f + 1180 >> 2];
+                                        a = b + 8 | 0;
+                                        d = x[b + 8 >> 2];
+                                        f = f + 1172 | 0;
+                                        c: {
+                                            if ((d | 0) == (f | 0)) {
+                                                x[283] = ea(c) & e;
+                                                break c;
+                                            }
+                                            x[d + 12 >> 2] = f;
+                                            x[f + 8 >> 2] = d;
+                                        }
+                                        c = c << 3;
+                                        x[b + 4 >> 2] = c | 3;
+                                        b = b + c | 0;
+                                        x[b + 4 >> 2] = x[b + 4 >> 2] | 1;
+                                        break b;
+                                    }
+                                    d: {
+                                        e: {
+                                            f: {
+                                                g: {
+                                                    h: {
+                                                        i: {
+                                                            j: {
+                                                                k: {
+                                                                    h = x[285];
+                                                                    if (h >>> 0 >= 16) {
+                                                                        break k;
+                                                                    }
+                                                                    if (a) {
+                                                                        a = a << 2 & -8;
+                                                                        a = (0 - a & a) - 1 | 0;
+                                                                        b = a >>> 12 & 16;
+                                                                        c = b;
+                                                                        a = a >>> b | 0;
+                                                                        b = a >>> 5 & 8;
+                                                                        c = c | b;
+                                                                        a = a >>> b | 0;
+                                                                        b = a >>> 2 & 4;
+                                                                        c = c | b;
+                                                                        a = a >>> b | 0;
+                                                                        b = a >>> 1 & 2;
+                                                                        c = c | b;
+                                                                        a = a >>> b | 0;
+                                                                        b = a >>> 1 & 1;
+                                                                        c = (c | b) + (a >>> b | 0) | 0;
+                                                                        d = c << 3;
+                                                                        b = x[d + 1180 >> 2];
+                                                                        a = x[b + 8 >> 2];
+                                                                        d = d + 1172 | 0;
+                                                                        l: {
+                                                                            if ((a | 0) == (d | 0)) {
+                                                                                e = ea(c) & e;
+                                                                                x[283] = e;
+                                                                                break l;
+                                                                            }
+                                                                            x[a + 12 >> 2] = d;
+                                                                            x[d + 8 >> 2] = a;
+                                                                        }
+                                                                        a = b + 8 | 0;
+                                                                        x[b + 4 >> 2] = 19;
+                                                                        g = b + 16 | 0;
+                                                                        c = c << 3;
+                                                                        f = c - 16 | 0;
+                                                                        x[g + 4 >> 2] = f | 1;
+                                                                        x[b + c >> 2] = f;
+                                                                        if (h) {
+                                                                            c = h >>> 3 | 0;
+                                                                            b = (c << 3) + 1172 | 0;
+                                                                            d = x[288];
+                                                                            c = 1 << c;
+                                                                            m: {
+                                                                                if (!(c & e)) {
+                                                                                    x[283] = c | e;
+                                                                                    c = b;
+                                                                                    break m;
+                                                                                }
+                                                                                c = x[b + 8 >> 2];
+                                                                            }
+                                                                            x[b + 8 >> 2] = d;
+                                                                            x[c + 12 >> 2] = d;
+                                                                            x[d + 12 >> 2] = b;
+                                                                            x[d + 8 >> 2] = c;
+                                                                        }
+                                                                        x[288] = g;
+                                                                        x[285] = f;
+                                                                        break b;
+                                                                    }
+                                                                    j = x[284];
+                                                                    if (!j) {
+                                                                        break k;
+                                                                    }
+                                                                    a = (j & 0 - j) - 1 | 0;
+                                                                    b = a >>> 12 & 16;
+                                                                    c = b;
+                                                                    a = a >>> b | 0;
+                                                                    b = a >>> 5 & 8;
+                                                                    c = c | b;
+                                                                    a = a >>> b | 0;
+                                                                    b = a >>> 2 & 4;
+                                                                    c = c | b;
+                                                                    a = a >>> b | 0;
+                                                                    b = a >>> 1 & 2;
+                                                                    c = c | b;
+                                                                    a = a >>> b | 0;
+                                                                    b = a >>> 1 & 1;
+                                                                    b = x[((c | b) + (a >>> b | 0) << 2) + 1436 >> 2];
+                                                                    f = (x[b + 4 >> 2] & -8) - 16 | 0;
+                                                                    c = b;
+                                                                    while (1) {
+                                                                        n: {
+                                                                            a = x[c + 16 >> 2];
+                                                                            if (!a) {
+                                                                                a = x[c + 20 >> 2];
+                                                                                if (!a) {
+                                                                                    break n;
+                                                                                }
+                                                                            }
+                                                                            d = (x[a + 4 >> 2] & -8) - 16 | 0;
+                                                                            c = d >>> 0 < f >>> 0;
+                                                                            f = c ? d : f;
+                                                                            b = c ? a : b;
+                                                                            c = a;
+                                                                            continue;
+                                                                        }
+                                                                        break;
+                                                                    }
+                                                                    i = x[b + 24 >> 2];
+                                                                    d = x[b + 12 >> 2];
+                                                                    if ((d | 0) != (b | 0)) {
+                                                                        a = x[b + 8 >> 2];
+                                                                        x[a + 12 >> 2] = d;
+                                                                        x[d + 8 >> 2] = a;
+                                                                        break d;
+                                                                    }
+                                                                    c = b + 20 | 0;
+                                                                    a = x[c >> 2];
+                                                                    if (!a) {
+                                                                        a = x[b + 16 >> 2];
+                                                                        if (!a) {
+                                                                            break j;
+                                                                        }
+                                                                        c = b + 16 | 0;
+                                                                    }
+                                                                    while (1) {
+                                                                        g = c;
+                                                                        d = a;
+                                                                        c = a + 20 | 0;
+                                                                        a = x[c >> 2];
+                                                                        if (a) {
+                                                                            continue;
+                                                                        }
+                                                                        c = d + 16 | 0;
+                                                                        a = x[d + 16 >> 2];
+                                                                        if (a) {
+                                                                            continue;
+                                                                        }
+                                                                        break;
+                                                                    }
+                                                                    x[g >> 2] = 0;
+                                                                    break d;
+                                                                }
+                                                                b = x[285];
+                                                                if (b >>> 0 >= 16) {
+                                                                    a = x[288];
+                                                                    c = b - 16 | 0;
+                                                                    o: {
+                                                                        if (c >>> 0 >= 16) {
+                                                                            x[285] = c;
+                                                                            x[288] = a + 16;
+                                                                            x[a + 20 >> 2] = c | 1;
+                                                                            x[a + b >> 2] = c;
+                                                                            x[a + 4 >> 2] = 19;
+                                                                            break o;
+                                                                        }
+                                                                        x[288] = 0;
+                                                                        x[285] = 0;
+                                                                        x[a + 4 >> 2] = b | 3;
+                                                                        b = a + b | 0;
+                                                                        x[b + 4 >> 2] = x[b + 4 >> 2] | 1;
+                                                                    }
+                                                                    a = a + 8 | 0;
+                                                                    break b;
+                                                                }
+                                                                e = x[286];
+                                                                if (e >>> 0 > 16) {
+                                                                    b = e - 16 | 0;
+                                                                    x[286] = b;
+                                                                    a = x[289];
+                                                                    x[289] = a + 16;
+                                                                    x[a + 20 >> 2] = b | 1;
+                                                                    x[a + 4 >> 2] = 19;
+                                                                    a = a + 8 | 0;
+                                                                    break b;
+                                                                }
+                                                                a = 0;
+                                                                if (x[401]) {
+                                                                    b = x[403];
+                                                                }
+                                                                else {
+                                                                    x[404] = -1;
+                                                                    x[405] = -1;
+                                                                    x[402] = 4096;
+                                                                    x[403] = 4096;
+                                                                    x[401] = k + 12 & -16 ^ 1431655768;
+                                                                    x[406] = 0;
+                                                                    x[394] = 0;
+                                                                    b = 4096;
+                                                                }
+                                                                d = b + 63 | 0;
+                                                                f = 0 - b | 0;
+                                                                c = d & f;
+                                                                if (c >>> 0 <= 16) {
+                                                                    break b;
+                                                                }
+                                                                g = x[393];
+                                                                if (g) {
+                                                                    h = x[391];
+                                                                    b = h + c | 0;
+                                                                    if (b >>> 0 <= h >>> 0 | b >>> 0 > g >>> 0) {
+                                                                        break b;
+                                                                    }
+                                                                }
+                                                                if (y[1576] & 4) {
+                                                                    break g;
+                                                                }
+                                                                p: {
+                                                                    q: {
+                                                                        b = x[289];
+                                                                        if (b) {
+                                                                            a = 1580;
+                                                                            while (1) {
+                                                                                g = x[a >> 2];
+                                                                                if (g >>> 0 <= b >>> 0 & b >>> 0 < g + x[a + 4 >> 2] >>> 0) {
+                                                                                    break q;
+                                                                                }
+                                                                                a = x[a + 8 >> 2];
+                                                                                if (a) {
+                                                                                    continue;
+                                                                                }
+                                                                                break;
+                                                                            }
+                                                                        }
+                                                                        b = Y(0);
+                                                                        if ((b | 0) == -1) {
+                                                                            break h;
+                                                                        }
+                                                                        e = c;
+                                                                        a = x[402];
+                                                                        d = a - 1 | 0;
+                                                                        if (d & b) {
+                                                                            e = (c - b | 0) + (b + d & 0 - a) | 0;
+                                                                        }
+                                                                        if (e >>> 0 <= 16 | e >>> 0 > 2147483646) {
+                                                                            break h;
+                                                                        }
+                                                                        d = x[393];
+                                                                        if (d) {
+                                                                            f = x[391];
+                                                                            a = f + e | 0;
+                                                                            if (a >>> 0 <= f >>> 0 | a >>> 0 > d >>> 0) {
+                                                                                break h;
+                                                                            }
+                                                                        }
+                                                                        a = Y(e);
+                                                                        if ((a | 0) != (b | 0)) {
+                                                                            break p;
+                                                                        }
+                                                                        break f;
+                                                                    }
+                                                                    e = f & d - e;
+                                                                    if (e >>> 0 > 2147483646) {
+                                                                        break h;
+                                                                    }
+                                                                    b = Y(e);
+                                                                    if ((b | 0) == (x[a >> 2] + x[a + 4 >> 2] | 0)) {
+                                                                        break i;
+                                                                    }
+                                                                    a = b;
+                                                                }
+                                                                if (!((a | 0) == -1 | e >>> 0 >= 64)) {
+                                                                    b = x[403];
+                                                                    b = b + (63 - e | 0) & 0 - b;
+                                                                    if (b >>> 0 > 2147483646) {
+                                                                        b = a;
+                                                                        break f;
+                                                                    }
+                                                                    if ((Y(b) | 0) != -1) {
+                                                                        e = b + e | 0;
+                                                                        b = a;
+                                                                        break f;
+                                                                    }
+                                                                    Y(0 - e | 0);
+                                                                    break h;
+                                                                }
+                                                                b = a;
+                                                                if ((a | 0) != -1) {
+                                                                    break f;
+                                                                }
+                                                                break h;
+                                                            }
+                                                            d = 0;
+                                                            break d;
+                                                        }
+                                                        if ((b | 0) != -1) {
+                                                            break f;
+                                                        }
+                                                    }
+                                                    x[394] = x[394] | 4;
+                                                }
+                                                if (c >>> 0 > 2147483646) {
+                                                    break e;
+                                                }
+                                                b = Y(c);
+                                                a = Y(0);
+                                                if ((b | 0) == -1 | (a | 0) == -1 | a >>> 0 <= b >>> 0) {
+                                                    break e;
+                                                }
+                                                e = a - b | 0;
+                                                if (e >>> 0 <= 56) {
+                                                    break e;
+                                                }
+                                            }
+                                            a = x[391] + e | 0;
+                                            x[391] = a;
+                                            if (a >>> 0 > A[392]) {
+                                                x[392] = a;
+                                            }
+                                            r: {
+                                                s: {
+                                                    t: {
+                                                        f = x[289];
+                                                        if (f) {
+                                                            a = 1580;
+                                                            while (1) {
+                                                                c = x[a >> 2];
+                                                                d = x[a + 4 >> 2];
+                                                                if ((c + d | 0) == (b | 0)) {
+                                                                    break t;
+                                                                }
+                                                                a = x[a + 8 >> 2];
+                                                                if (a) {
+                                                                    continue;
+                                                                }
+                                                                break;
+                                                            }
+                                                            break s;
+                                                        }
+                                                        a = x[287];
+                                                        if (!(a >>> 0 <= b >>> 0 ? a : 0)) {
+                                                            x[287] = b;
+                                                        }
+                                                        a = 0;
+                                                        x[396] = e;
+                                                        x[395] = b;
+                                                        x[291] = -1;
+                                                        x[292] = x[401];
+                                                        x[398] = 0;
+                                                        while (1) {
+                                                            c = a << 3;
+                                                            d = c + 1172 | 0;
+                                                            x[c + 1180 >> 2] = d;
+                                                            x[c + 1184 >> 2] = d;
+                                                            a = a + 1 | 0;
+                                                            if ((a | 0) != 32) {
+                                                                continue;
+                                                            }
+                                                            break;
+                                                        }
+                                                        a = e - 40 | 0;
+                                                        c = b + 8 & 7 ? -8 - b & 7 : 0;
+                                                        e = a - c | 0;
+                                                        x[286] = e;
+                                                        c = b + c | 0;
+                                                        x[289] = c;
+                                                        x[c + 4 >> 2] = e | 1;
+                                                        x[(a + b | 0) + 4 >> 2] = 40;
+                                                        x[290] = x[405];
+                                                        break r;
+                                                    }
+                                                    if (y[a + 12 | 0] & 8 | c >>> 0 > f >>> 0 | b >>> 0 <= f >>> 0) {
+                                                        break s;
+                                                    }
+                                                    x[a + 4 >> 2] = d + e;
+                                                    a = f + 8 & 7 ? -8 - f & 7 : 0;
+                                                    b = a + f | 0;
+                                                    x[289] = b;
+                                                    c = x[286] + e | 0;
+                                                    a = c - a | 0;
+                                                    x[286] = a;
+                                                    x[b + 4 >> 2] = a | 1;
+                                                    x[(c + f | 0) + 4 >> 2] = 40;
+                                                    x[290] = x[405];
+                                                    break r;
+                                                }
+                                                if (A[287] > b >>> 0) {
+                                                    x[287] = b;
+                                                }
+                                                c = b + e | 0;
+                                                a = 1580;
+                                                u: {
+                                                    v: {
+                                                        w: {
+                                                            x: {
+                                                                y: {
+                                                                    z: {
+                                                                        while (1) {
+                                                                            if ((c | 0) != x[a >> 2]) {
+                                                                                a = x[a + 8 >> 2];
+                                                                                if (a) {
+                                                                                    continue;
+                                                                                }
+                                                                                break z;
+                                                                            }
+                                                                            break;
+                                                                        }
+                                                                        if (!(y[a + 12 | 0] & 8)) {
+                                                                            break y;
+                                                                        }
+                                                                    }
+                                                                    a = 1580;
+                                                                    while (1) {
+                                                                        c = x[a >> 2];
+                                                                        if (c >>> 0 <= f >>> 0) {
+                                                                            d = c + x[a + 4 >> 2] | 0;
+                                                                            if (d >>> 0 > f >>> 0) {
+                                                                                break x;
+                                                                            }
+                                                                        }
+                                                                        a = x[a + 8 >> 2];
+                                                                        continue;
+                                                                    }
+                                                                }
+                                                                x[a >> 2] = b;
+                                                                x[a + 4 >> 2] = x[a + 4 >> 2] + e;
+                                                                i = (b + 8 & 7 ? -8 - b & 7 : 0) + b | 0;
+                                                                x[i + 4 >> 2] = 19;
+                                                                e = c + (c + 8 & 7 ? -8 - c & 7 : 0) | 0;
+                                                                g = i + 16 | 0;
+                                                                d = e - g | 0;
+                                                                if ((e | 0) == (f | 0)) {
+                                                                    x[289] = g;
+                                                                    a = x[286] + d | 0;
+                                                                    x[286] = a;
+                                                                    x[g + 4 >> 2] = a | 1;
+                                                                    break v;
+                                                                }
+                                                                if (x[288] == (e | 0)) {
+                                                                    x[288] = g;
+                                                                    a = x[285] + d | 0;
+                                                                    x[285] = a;
+                                                                    x[g + 4 >> 2] = a | 1;
+                                                                    x[a + g >> 2] = a;
+                                                                    break v;
+                                                                }
+                                                                a = x[e + 4 >> 2];
+                                                                if ((a & 3) == 1) {
+                                                                    j = a & -8;
+                                                                    A: {
+                                                                        if (a >>> 0 <= 255) {
+                                                                            c = a >>> 3 | 0;
+                                                                            a = x[e + 8 >> 2];
+                                                                            b = x[e + 12 >> 2];
+                                                                            if ((b | 0) == (a | 0)) {
+                                                                                x[283] = x[283] & ea(c);
+                                                                                break A;
+                                                                            }
+                                                                            x[a + 12 >> 2] = b;
+                                                                            x[b + 8 >> 2] = a;
+                                                                            break A;
+                                                                        }
+                                                                        h = x[e + 24 >> 2];
+                                                                        b = x[e + 12 >> 2];
+                                                                        B: {
+                                                                            if ((e | 0) != (b | 0)) {
+                                                                                a = x[e + 8 >> 2];
+                                                                                x[a + 12 >> 2] = b;
+                                                                                x[b + 8 >> 2] = a;
+                                                                                break B;
+                                                                            }
+                                                                            C: {
+                                                                                a = e + 20 | 0;
+                                                                                f = x[a >> 2];
+                                                                                if (f) {
+                                                                                    break C;
+                                                                                }
+                                                                                a = e + 16 | 0;
+                                                                                f = x[a >> 2];
+                                                                                if (f) {
+                                                                                    break C;
+                                                                                }
+                                                                                b = 0;
+                                                                                break B;
+                                                                            }
+                                                                            while (1) {
+                                                                                c = a;
+                                                                                b = f;
+                                                                                a = b + 20 | 0;
+                                                                                f = x[a >> 2];
+                                                                                if (f) {
+                                                                                    continue;
+                                                                                }
+                                                                                a = b + 16 | 0;
+                                                                                f = x[b + 16 >> 2];
+                                                                                if (f) {
+                                                                                    continue;
+                                                                                }
+                                                                                break;
+                                                                            }
+                                                                            x[c >> 2] = 0;
+                                                                        }
+                                                                        if (!h) {
+                                                                            break A;
+                                                                        }
+                                                                        a = x[e + 28 >> 2];
+                                                                        c = (a << 2) + 1436 | 0;
+                                                                        D: {
+                                                                            if (x[c >> 2] == (e | 0)) {
+                                                                                x[c >> 2] = b;
+                                                                                if (b) {
+                                                                                    break D;
+                                                                                }
+                                                                                x[284] = x[284] & ea(a);
+                                                                                break A;
+                                                                            }
+                                                                            x[h + (x[h + 16 >> 2] == (e | 0) ? 16 : 20) >> 2] = b;
+                                                                            if (!b) {
+                                                                                break A;
+                                                                            }
+                                                                        }
+                                                                        x[b + 24 >> 2] = h;
+                                                                        a = x[e + 16 >> 2];
+                                                                        if (a) {
+                                                                            x[b + 16 >> 2] = a;
+                                                                            x[a + 24 >> 2] = b;
+                                                                        }
+                                                                        a = x[e + 20 >> 2];
+                                                                        if (!a) {
+                                                                            break A;
+                                                                        }
+                                                                        x[b + 20 >> 2] = a;
+                                                                        x[a + 24 >> 2] = b;
+                                                                    }
+                                                                    d = d + j | 0;
+                                                                    e = e + j | 0;
+                                                                }
+                                                                x[e + 4 >> 2] = x[e + 4 >> 2] & -2;
+                                                                x[g + 4 >> 2] = d | 1;
+                                                                x[d + g >> 2] = d;
+                                                                if (d >>> 0 <= 255) {
+                                                                    b = d >>> 3 | 0;
+                                                                    a = (b << 3) + 1172 | 0;
+                                                                    c = x[283];
+                                                                    b = 1 << b;
+                                                                    E: {
+                                                                        if (!(c & b)) {
+                                                                            x[283] = b | c;
+                                                                            b = a;
+                                                                            break E;
+                                                                        }
+                                                                        b = x[a + 8 >> 2];
+                                                                    }
+                                                                    x[a + 8 >> 2] = g;
+                                                                    x[b + 12 >> 2] = g;
+                                                                    x[g + 12 >> 2] = a;
+                                                                    x[g + 8 >> 2] = b;
+                                                                    break v;
+                                                                }
+                                                                a = 31;
+                                                                if (d >>> 0 <= 16777215) {
+                                                                    b = d >>> 8 | 0;
+                                                                    a = b + 1048320 >>> 16 & 8;
+                                                                    c = b << a;
+                                                                    b = c + 520192 >>> 16 & 4;
+                                                                    e = c << b;
+                                                                    c = e + 245760 >>> 16 & 2;
+                                                                    a = (e << c >>> 15 | 0) - (c | (a | b)) | 0;
+                                                                    a = (a << 1 | d >>> a + 21 & 1) + 28 | 0;
+                                                                }
+                                                                x[g + 28 >> 2] = a;
+                                                                x[g + 16 >> 2] = 0;
+                                                                x[g + 20 >> 2] = 0;
+                                                                b = (a << 2) + 1436 | 0;
+                                                                c = x[284];
+                                                                e = 1 << a;
+                                                                F: {
+                                                                    if (!(c & e)) {
+                                                                        x[284] = c | e;
+                                                                        x[b >> 2] = g;
+                                                                        x[g + 24 >> 2] = b;
+                                                                        break F;
+                                                                    }
+                                                                    a = d << ((a | 0) == 31 ? 0 : 25 - (a >>> 1 | 0) | 0);
+                                                                    b = x[b >> 2];
+                                                                    while (1) {
+                                                                        c = b;
+                                                                        if ((x[b + 4 >> 2] & -8) == (d | 0)) {
+                                                                            break w;
+                                                                        }
+                                                                        b = a >>> 29 | 0;
+                                                                        a = a << 1;
+                                                                        e = c + (b & 4) | 0;
+                                                                        b = x[e + 16 >> 2];
+                                                                        if (b) {
+                                                                            continue;
+                                                                        }
+                                                                        break;
+                                                                    }
+                                                                    x[e + 16 >> 2] = g;
+                                                                    x[g + 24 >> 2] = c;
+                                                                }
+                                                                x[g + 12 >> 2] = g;
+                                                                x[g + 8 >> 2] = g;
+                                                                break v;
+                                                            }
+                                                            a = e - 40 | 0;
+                                                            c = b + 8 & 7 ? -8 - b & 7 : 0;
+                                                            g = a - c | 0;
+                                                            x[286] = g;
+                                                            c = b + c | 0;
+                                                            x[289] = c;
+                                                            x[c + 4 >> 2] = g | 1;
+                                                            x[(a + b | 0) + 4 >> 2] = 40;
+                                                            x[290] = x[405];
+                                                            a = (d + (d - 39 & 7 ? 39 - d & 7 : 0) | 0) - 47 | 0;
+                                                            c = a >>> 0 < f + 16 >>> 0 ? f : a;
+                                                            x[c + 4 >> 2] = 27;
+                                                            a = x[398];
+                                                            x[c + 16 >> 2] = x[397];
+                                                            x[c + 20 >> 2] = a;
+                                                            a = x[396];
+                                                            x[c + 8 >> 2] = x[395];
+                                                            x[c + 12 >> 2] = a;
+                                                            x[397] = c + 8;
+                                                            x[396] = e;
+                                                            x[395] = b;
+                                                            x[398] = 0;
+                                                            a = c + 24 | 0;
+                                                            while (1) {
+                                                                x[a + 4 >> 2] = 7;
+                                                                b = a + 8 | 0;
+                                                                a = a + 4 | 0;
+                                                                if (b >>> 0 < d >>> 0) {
+                                                                    continue;
+                                                                }
+                                                                break;
+                                                            }
+                                                            if ((c | 0) == (f | 0)) {
+                                                                break r;
+                                                            }
+                                                            x[c + 4 >> 2] = x[c + 4 >> 2] & -2;
+                                                            e = c - f | 0;
+                                                            x[f + 4 >> 2] = e | 1;
+                                                            x[c >> 2] = e;
+                                                            if (e >>> 0 <= 255) {
+                                                                b = e >>> 3 | 0;
+                                                                a = (b << 3) + 1172 | 0;
+                                                                c = x[283];
+                                                                b = 1 << b;
+                                                                G: {
+                                                                    if (!(c & b)) {
+                                                                        x[283] = b | c;
+                                                                        b = a;
+                                                                        break G;
+                                                                    }
+                                                                    b = x[a + 8 >> 2];
+                                                                }
+                                                                x[a + 8 >> 2] = f;
+                                                                x[b + 12 >> 2] = f;
+                                                                x[f + 12 >> 2] = a;
+                                                                x[f + 8 >> 2] = b;
+                                                                break r;
+                                                            }
+                                                            a = 31;
+                                                            x[f + 16 >> 2] = 0;
+                                                            x[f + 20 >> 2] = 0;
+                                                            if (e >>> 0 <= 16777215) {
+                                                                b = e >>> 8 | 0;
+                                                                a = b + 1048320 >>> 16 & 8;
+                                                                c = b << a;
+                                                                b = c + 520192 >>> 16 & 4;
+                                                                d = c << b;
+                                                                c = d + 245760 >>> 16 & 2;
+                                                                a = (d << c >>> 15 | 0) - (c | (a | b)) | 0;
+                                                                a = (a << 1 | e >>> a + 21 & 1) + 28 | 0;
+                                                            }
+                                                            x[f + 28 >> 2] = a;
+                                                            b = (a << 2) + 1436 | 0;
+                                                            c = x[284];
+                                                            d = 1 << a;
+                                                            H: {
+                                                                if (!(c & d)) {
+                                                                    x[284] = c | d;
+                                                                    x[b >> 2] = f;
+                                                                    x[f + 24 >> 2] = b;
+                                                                    break H;
+                                                                }
+                                                                a = e << ((a | 0) == 31 ? 0 : 25 - (a >>> 1 | 0) | 0);
+                                                                b = x[b >> 2];
+                                                                while (1) {
+                                                                    c = b;
+                                                                    if ((e | 0) == (x[b + 4 >> 2] & -8)) {
+                                                                        break u;
+                                                                    }
+                                                                    b = a >>> 29 | 0;
+                                                                    a = a << 1;
+                                                                    d = c + (b & 4) | 0;
+                                                                    b = x[d + 16 >> 2];
+                                                                    if (b) {
+                                                                        continue;
+                                                                    }
+                                                                    break;
+                                                                }
+                                                                x[d + 16 >> 2] = f;
+                                                                x[f + 24 >> 2] = c;
+                                                            }
+                                                            x[f + 12 >> 2] = f;
+                                                            x[f + 8 >> 2] = f;
+                                                            break r;
+                                                        }
+                                                        a = x[c + 8 >> 2];
+                                                        x[a + 12 >> 2] = g;
+                                                        x[c + 8 >> 2] = g;
+                                                        x[g + 24 >> 2] = 0;
+                                                        x[g + 12 >> 2] = c;
+                                                        x[g + 8 >> 2] = a;
+                                                    }
+                                                    a = i + 8 | 0;
+                                                    break b;
+                                                }
+                                                a = x[c + 8 >> 2];
+                                                x[a + 12 >> 2] = f;
+                                                x[c + 8 >> 2] = f;
+                                                x[f + 24 >> 2] = 0;
+                                                x[f + 12 >> 2] = c;
+                                                x[f + 8 >> 2] = a;
+                                            }
+                                            a = x[286];
+                                            if (a >>> 0 <= 16) {
+                                                break e;
+                                            }
+                                            b = a - 16 | 0;
+                                            x[286] = b;
+                                            a = x[289];
+                                            x[289] = a + 16;
+                                            x[a + 20 >> 2] = b | 1;
+                                            x[a + 4 >> 2] = 19;
+                                            a = a + 8 | 0;
+                                            break b;
+                                        }
+                                        x[282] = 48;
+                                        a = 0;
+                                        break b;
+                                    }
+                                    I: {
+                                        if (!i) {
+                                            break I;
+                                        }
+                                        a = x[b + 28 >> 2];
+                                        c = (a << 2) + 1436 | 0;
+                                        J: {
+                                            if (x[c >> 2] == (b | 0)) {
+                                                x[c >> 2] = d;
+                                                if (d) {
+                                                    break J;
+                                                }
+                                                x[284] = ea(a) & j;
+                                                break I;
+                                            }
+                                            x[i + (x[i + 16 >> 2] == (b | 0) ? 16 : 20) >> 2] = d;
+                                            if (!d) {
+                                                break I;
+                                            }
+                                        }
+                                        x[d + 24 >> 2] = i;
+                                        a = x[b + 16 >> 2];
+                                        if (a) {
+                                            x[d + 16 >> 2] = a;
+                                            x[a + 24 >> 2] = d;
+                                        }
+                                        a = x[b + 20 >> 2];
+                                        if (!a) {
+                                            break I;
+                                        }
+                                        x[d + 20 >> 2] = a;
+                                        x[a + 24 >> 2] = d;
+                                    }
+                                    K: {
+                                        if (f >>> 0 <= 15) {
+                                            a = f + 16 | 0;
+                                            x[b + 4 >> 2] = a | 3;
+                                            a = a + b | 0;
+                                            x[a + 4 >> 2] = x[a + 4 >> 2] | 1;
+                                            break K;
+                                        }
+                                        x[b + 4 >> 2] = 19;
+                                        g = b + 16 | 0;
+                                        x[g + 4 >> 2] = f | 1;
+                                        x[f + g >> 2] = f;
+                                        if (h) {
+                                            c = h >>> 3 | 0;
+                                            a = (c << 3) + 1172 | 0;
+                                            d = x[288];
+                                            c = 1 << c;
+                                            L: {
+                                                if (!(c & e)) {
+                                                    x[283] = c | e;
+                                                    c = a;
+                                                    break L;
+                                                }
+                                                c = x[a + 8 >> 2];
+                                            }
+                                            x[a + 8 >> 2] = d;
+                                            x[c + 12 >> 2] = d;
+                                            x[d + 12 >> 2] = a;
+                                            x[d + 8 >> 2] = c;
+                                        }
+                                        x[288] = g;
+                                        x[285] = f;
+                                    }
+                                    a = b + 8 | 0;
+                                }
+                                S = k + 16 | 0;
+                                if (a) {
+                                    break a;
+                                }
+                                a = x[407];
+                                if (a) {
+                                    T[a | 0]();
+                                    continue;
+                                }
+                                break;
+                            }
+                            R();
+                            N();
+                        } return a; }
+                        function _(a) { a = a | 0; var b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0; if (a) {
+                            a: {
+                                if (!a) {
+                                    break a;
+                                }
+                                c = a - 8 | 0;
+                                a = x[a - 4 >> 2];
+                                e = a & -8;
+                                f = c + e | 0;
+                                b: {
+                                    if (a & 1) {
+                                        break b;
+                                    }
+                                    if (!(a & 3)) {
+                                        break a;
+                                    }
+                                    a = x[c >> 2];
+                                    c = c - a | 0;
+                                    if (c >>> 0 < A[287]) {
+                                        break a;
+                                    }
+                                    e = a + e | 0;
+                                    if (x[288] != (c | 0)) {
+                                        if (a >>> 0 <= 255) {
+                                            d = a >>> 3 | 0;
+                                            a = x[c + 8 >> 2];
+                                            b = x[c + 12 >> 2];
+                                            if ((b | 0) == (a | 0)) {
+                                                x[283] = x[283] & ea(d);
+                                                break b;
+                                            }
+                                            x[a + 12 >> 2] = b;
+                                            x[b + 8 >> 2] = a;
+                                            break b;
+                                        }
+                                        h = x[c + 24 >> 2];
+                                        a = x[c + 12 >> 2];
+                                        c: {
+                                            if ((c | 0) != (a | 0)) {
+                                                b = x[c + 8 >> 2];
+                                                x[b + 12 >> 2] = a;
+                                                x[a + 8 >> 2] = b;
+                                                break c;
+                                            }
+                                            d: {
+                                                b = c + 20 | 0;
+                                                d = x[b >> 2];
+                                                if (d) {
+                                                    break d;
+                                                }
+                                                b = c + 16 | 0;
+                                                d = x[b >> 2];
+                                                if (d) {
+                                                    break d;
+                                                }
+                                                a = 0;
+                                                break c;
+                                            }
+                                            while (1) {
+                                                g = b;
+                                                a = d;
+                                                b = a + 20 | 0;
+                                                d = x[b >> 2];
+                                                if (d) {
+                                                    continue;
+                                                }
+                                                b = a + 16 | 0;
+                                                d = x[a + 16 >> 2];
+                                                if (d) {
+                                                    continue;
+                                                }
+                                                break;
+                                            }
+                                            x[g >> 2] = 0;
+                                        }
+                                        if (!h) {
+                                            break b;
+                                        }
+                                        b = x[c + 28 >> 2];
+                                        d = (b << 2) + 1436 | 0;
+                                        e: {
+                                            if (x[d >> 2] == (c | 0)) {
+                                                x[d >> 2] = a;
+                                                if (a) {
+                                                    break e;
+                                                }
+                                                x[284] = x[284] & ea(b);
+                                                break b;
+                                            }
+                                            x[h + (x[h + 16 >> 2] == (c | 0) ? 16 : 20) >> 2] = a;
+                                            if (!a) {
+                                                break b;
+                                            }
+                                        }
+                                        x[a + 24 >> 2] = h;
+                                        b = x[c + 16 >> 2];
+                                        if (b) {
+                                            x[a + 16 >> 2] = b;
+                                            x[b + 24 >> 2] = a;
+                                        }
+                                        b = x[c + 20 >> 2];
+                                        if (!b) {
+                                            break b;
+                                        }
+                                        x[a + 20 >> 2] = b;
+                                        x[b + 24 >> 2] = a;
+                                        break b;
+                                    }
+                                    a = x[f + 4 >> 2];
+                                    if ((a & 3) != 3) {
+                                        break b;
+                                    }
+                                    x[285] = e;
+                                    x[f + 4 >> 2] = a & -2;
+                                    x[c + 4 >> 2] = e | 1;
+                                    x[c + e >> 2] = e;
+                                    break a;
+                                }
+                                if (c >>> 0 >= f >>> 0) {
+                                    break a;
+                                }
+                                a = x[f + 4 >> 2];
+                                if (!(a & 1)) {
+                                    break a;
+                                }
+                                f: {
+                                    if (!(a & 2)) {
+                                        if (x[289] == (f | 0)) {
+                                            x[289] = c;
+                                            a = x[286] + e | 0;
+                                            x[286] = a;
+                                            x[c + 4 >> 2] = a | 1;
+                                            if (x[288] != (c | 0)) {
+                                                break a;
+                                            }
+                                            x[285] = 0;
+                                            x[288] = 0;
+                                            break a;
+                                        }
+                                        if (x[288] == (f | 0)) {
+                                            x[288] = c;
+                                            a = x[285] + e | 0;
+                                            x[285] = a;
+                                            x[c + 4 >> 2] = a | 1;
+                                            x[a + c >> 2] = a;
+                                            break a;
+                                        }
+                                        e = (a & -8) + e | 0;
+                                        g: {
+                                            if (a >>> 0 <= 255) {
+                                                d = a >>> 3 | 0;
+                                                a = x[f + 8 >> 2];
+                                                b = x[f + 12 >> 2];
+                                                if ((b | 0) == (a | 0)) {
+                                                    x[283] = x[283] & ea(d);
+                                                    break g;
+                                                }
+                                                x[a + 12 >> 2] = b;
+                                                x[b + 8 >> 2] = a;
+                                                break g;
+                                            }
+                                            h = x[f + 24 >> 2];
+                                            a = x[f + 12 >> 2];
+                                            h: {
+                                                if ((f | 0) != (a | 0)) {
+                                                    b = x[f + 8 >> 2];
+                                                    x[b + 12 >> 2] = a;
+                                                    x[a + 8 >> 2] = b;
+                                                    break h;
+                                                }
+                                                i: {
+                                                    b = f + 20 | 0;
+                                                    d = x[b >> 2];
+                                                    if (d) {
+                                                        break i;
+                                                    }
+                                                    b = f + 16 | 0;
+                                                    d = x[b >> 2];
+                                                    if (d) {
+                                                        break i;
+                                                    }
+                                                    a = 0;
+                                                    break h;
+                                                }
+                                                while (1) {
+                                                    g = b;
+                                                    a = d;
+                                                    b = a + 20 | 0;
+                                                    d = x[b >> 2];
+                                                    if (d) {
+                                                        continue;
+                                                    }
+                                                    b = a + 16 | 0;
+                                                    d = x[a + 16 >> 2];
+                                                    if (d) {
+                                                        continue;
+                                                    }
+                                                    break;
+                                                }
+                                                x[g >> 2] = 0;
+                                            }
+                                            if (!h) {
+                                                break g;
+                                            }
+                                            b = x[f + 28 >> 2];
+                                            d = (b << 2) + 1436 | 0;
+                                            j: {
+                                                if (x[d >> 2] == (f | 0)) {
+                                                    x[d >> 2] = a;
+                                                    if (a) {
+                                                        break j;
+                                                    }
+                                                    x[284] = x[284] & ea(b);
+                                                    break g;
+                                                }
+                                                x[h + (x[h + 16 >> 2] == (f | 0) ? 16 : 20) >> 2] = a;
+                                                if (!a) {
+                                                    break g;
+                                                }
+                                            }
+                                            x[a + 24 >> 2] = h;
+                                            b = x[f + 16 >> 2];
+                                            if (b) {
+                                                x[a + 16 >> 2] = b;
+                                                x[b + 24 >> 2] = a;
+                                            }
+                                            b = x[f + 20 >> 2];
+                                            if (!b) {
+                                                break g;
+                                            }
+                                            x[a + 20 >> 2] = b;
+                                            x[b + 24 >> 2] = a;
+                                        }
+                                        x[c + 4 >> 2] = e | 1;
+                                        x[c + e >> 2] = e;
+                                        if (x[288] != (c | 0)) {
+                                            break f;
+                                        }
+                                        x[285] = e;
+                                        break a;
+                                    }
+                                    x[f + 4 >> 2] = a & -2;
+                                    x[c + 4 >> 2] = e | 1;
+                                    x[c + e >> 2] = e;
+                                }
+                                if (e >>> 0 <= 255) {
+                                    b = e >>> 3 | 0;
+                                    a = (b << 3) + 1172 | 0;
+                                    d = x[283];
+                                    b = 1 << b;
+                                    k: {
+                                        if (!(d & b)) {
+                                            x[283] = b | d;
+                                            b = a;
+                                            break k;
+                                        }
+                                        b = x[a + 8 >> 2];
+                                    }
+                                    x[a + 8 >> 2] = c;
+                                    x[b + 12 >> 2] = c;
+                                    x[c + 12 >> 2] = a;
+                                    x[c + 8 >> 2] = b;
+                                    break a;
+                                }
+                                b = 31;
+                                x[c + 16 >> 2] = 0;
+                                x[c + 20 >> 2] = 0;
+                                if (e >>> 0 <= 16777215) {
+                                    b = e >>> 8 | 0;
+                                    a = b + 1048320 >>> 16 & 8;
+                                    d = b << a;
+                                    b = d + 520192 >>> 16 & 4;
+                                    g = d << b;
+                                    d = g + 245760 >>> 16 & 2;
+                                    a = (g << d >>> 15 | 0) - (d | (a | b)) | 0;
+                                    b = (a << 1 | e >>> a + 21 & 1) + 28 | 0;
+                                }
+                                x[c + 28 >> 2] = b;
+                                a = (b << 2) + 1436 | 0;
+                                l: {
+                                    m: {
+                                        d = x[284];
+                                        g = 1 << b;
+                                        n: {
+                                            if (!(d & g)) {
+                                                x[284] = d | g;
+                                                x[a >> 2] = c;
+                                                x[c + 24 >> 2] = a;
+                                                break n;
+                                            }
+                                            b = e << ((b | 0) == 31 ? 0 : 25 - (b >>> 1 | 0) | 0);
+                                            a = x[a >> 2];
+                                            while (1) {
+                                                d = a;
+                                                if ((x[a + 4 >> 2] & -8) == (e | 0)) {
+                                                    break m;
+                                                }
+                                                a = b >>> 29 | 0;
+                                                b = b << 1;
+                                                g = d + (a & 4) | 0;
+                                                a = x[g + 16 >> 2];
+                                                if (a) {
+                                                    continue;
+                                                }
+                                                break;
+                                            }
+                                            x[g + 16 >> 2] = c;
+                                            x[c + 24 >> 2] = d;
+                                        }
+                                        x[c + 12 >> 2] = c;
+                                        x[c + 8 >> 2] = c;
+                                        break l;
+                                    }
+                                    a = x[d + 8 >> 2];
+                                    x[a + 12 >> 2] = c;
+                                    x[d + 8 >> 2] = c;
+                                    x[c + 24 >> 2] = 0;
+                                    x[c + 12 >> 2] = d;
+                                    x[c + 8 >> 2] = a;
+                                }
+                                a = x[291] - 1 | 0;
+                                x[291] = a ? a : -1;
+                            }
+                        } }
+                        function Y(a) { var b = 0, c = 0; b = x[256]; c = a + 3 & -4; a = b + c | 0; a: {
+                            if (a >>> 0 <= b >>> 0 ? c : 0) {
+                                break a;
+                            }
+                            if (a >>> 0 > U() << 16 >>> 0) {
+                                if (!(Q(a | 0) | 0)) {
+                                    break a;
+                                }
+                            }
+                            x[256] = a;
+                            return b;
+                        } x[282] = 48; return -1; }
+                        function ea(a) { var b = 0; b = a & 31; a = 0 - a & 31; return (-1 >>> b & -2) << b | (-1 << a & -2) >>> a; }
+                        function ca(a, b, c) { a = E(a); b = E(b); c = E(c); return Z() | 0; }
+                        function ba(a, b) { a = a | 0; b = b | 0; return D(b, 4950) | 0; }
+                        function aa(a, b) { a = a | 0; b = b | 0; }
+                        function da() { return Z() | 0; }
+                        function $() { }
+                        // EMSCRIPTEN_END_FUNCS
+                        g = y;
+                        r(W);
+                        var T = e([]);
+                        function U() { return u.byteLength / 65536 | 0; }
+                        return { "d": $, "e": _, "f": da, "g": ca, "h": ba, "i": aa, "j": _, "k": T };
+                    }
+                    return V(X);
+                }
+                // EMSCRIPTEN_END_ASM
+                )(C);
+            }
+            function ea() { return { then: function (a) { a({ instance: new da }); } }; }
+            var fa = Error, WebAssembly = {};
+            A = [];
+            "object" != typeof WebAssembly && y("no native wasm support detected");
+            var D, E = !1, F, B = b.INITIAL_MEMORY || 16777216;
+            if (D = b.wasmMemory ? b.wasmMemory : new ba)
+                F = D.buffer;
+            B = F.byteLength;
+            var G = F;
+            F = G;
+            b.HEAP8 = new Int8Array(G);
+            b.HEAP16 = new Int16Array(G);
+            b.HEAP32 = new Int32Array(G);
+            b.HEAPU8 = new Uint8Array(G);
+            b.HEAPU16 = new Uint16Array(G);
+            b.HEAPU32 = new Uint32Array(G);
+            b.HEAPF32 = new Float32Array(G);
+            b.HEAPF64 = new Float64Array(G);
+            var H, I = [], J = [], K = [];
+            function ha() { var a = b.preRun.shift(); I.unshift(a); }
+            var L = 0, M = null, N = null;
+            b.preloadedImages = {};
+            b.preloadedAudios = {};
+            function y(a) { if (b.onAbort)
+                b.onAbort(a); a = "Aborted(" + a + ")"; z(a); E = !0; a = new fa(a + ". Build with -s ASSERTIONS=1 for more info."); k(a); throw a; }
+            var O = "data:application/octet-stream;base64,", P;
+            P = "mxcadassembly_min.wasm";
+            if (!P.startsWith(O)) {
+                var Q = P;
+                P = b.locateFile ? b.locateFile(Q, q) : q + Q;
+            }
+            function ia() { var a = P; try {
+                if (a == P && A)
+                    return new Uint8Array(A);
+                var c = x(a);
+                if (c)
+                    return c;
+                if (u)
+                    return u(a);
+                throw "both async and sync fetching of the wasm failed";
+            }
+            catch (d) {
+                y(d);
+            } }
+            function ja() { if (!A && (m || n)) {
+                if ("function" == typeof fetch && !P.startsWith("file://"))
+                    return fetch(P, { credentials: "same-origin" }).then(function (a) { if (!a.ok)
+                        throw "failed to load wasm binary file at '" + P + "'"; return a.arrayBuffer(); }).catch(function () { return ia(); });
+                if (t)
+                    return new Promise(function (a, c) { t(P, function (d) { a(new Uint8Array(d)); }, c); });
+            } return Promise.resolve().then(function () { return ia(); }); }
+            function R(a) { for (; 0 < a.length;) {
+                var c = a.shift();
+                if ("function" == typeof c)
+                    c(b);
+                else {
+                    var d = c.u;
+                    "number" == typeof d ? void 0 === c.s ? ka(d)() : ka(d)(c.s) : d(void 0 === c.s ? null : c.s);
+                }
+            } }
+            var S = [];
+            function ka(a) { var c = S[a]; c || (a >= S.length && (S.length = a + 1), S[a] = c = H.get(a)); return c; }
+            var aa = !1, la = "function" == typeof atob ? atob : function (a) {
+                var c = "", d = 0;
+                a = a.replace(/[^A-Za-z0-9\+\/=]/g, "");
+                do {
+                    var e = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(a.charAt(d++));
+                    var f = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(a.charAt(d++));
+                    var h = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(a.charAt(d++));
+                    var ca = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(a.charAt(d++));
+                    e = e <<
+                        2 | f >> 4;
+                    f = (f & 15) << 4 | h >> 2;
+                    var ra = (h & 3) << 6 | ca;
+                    c += String.fromCharCode(e);
+                    64 !== h && (c += String.fromCharCode(f));
+                    64 !== ca && (c += String.fromCharCode(ra));
+                } while (d < a.length);
+                return c;
+            };
+            function x(a) { if (a.startsWith(O)) {
+                a = a.slice(O.length);
+                if ("boolean" == typeof p && p) {
+                    var c = Buffer.from(a, "base64");
+                    c = new Uint8Array(c.buffer, c.byteOffset, c.byteLength);
+                }
+                else
+                    try {
+                        var d = la(a), e = new Uint8Array(d.length);
+                        for (a = 0; a < d.length; ++a)
+                            e[a] = d.charCodeAt(a);
+                        c = e;
+                    }
+                    catch (f) {
+                        throw Error("Converting base64 string to bytes failed.");
+                    }
+                return c;
+            } }
+            var C = { c: function () { y(""); }, b: function () { y("OOM"); }, a: D };
+            (function () {
+                function a(f) { b.asm = f.exports; H = b.asm.k; J.unshift(b.asm.d); L--; b.monitorRunDependencies && b.monitorRunDependencies(L); 0 == L && (null !== M && (clearInterval(M), M = null), N && (f = N, N = null, f())); }
+                function c(f) { a(f.instance); }
+                function d(f) { return ja().then(function () { return ea(); }).then(function (h) { return h; }).then(f, function (h) { z("failed to asynchronously prepare wasm: " + h); y(h); }); }
+                var e = { a: C };
+                L++;
+                b.monitorRunDependencies && b.monitorRunDependencies(L);
+                if (b.instantiateWasm)
+                    try {
+                        return b.instantiateWasm(e, a);
+                    }
+                    catch (f) {
+                        return z("Module.instantiateWasm callback failed with error: " +
+                            f), !1;
+                    }
+                (function () { return A || "function" != typeof WebAssembly.instantiateStreaming || P.startsWith(O) || P.startsWith("file://") || "function" != typeof fetch ? d(c) : fetch(P, { credentials: "same-origin" }).then(function (f) { return WebAssembly.instantiateStreaming(f, e).then(c, function (h) { z("wasm streaming compile failed: " + h); z("falling back to ArrayBuffer instantiation"); return d(c); }); }); })().catch(k);
+                return {};
+            })();
+            b.___wasm_call_ctors = function () { return (b.___wasm_call_ctors = b.asm.d).apply(null, arguments); };
+            var ma = b._emscripten_bind_VoidPtr___destroy___0 = function () { return (ma = b._emscripten_bind_VoidPtr___destroy___0 = b.asm.e).apply(null, arguments); }, na = b._emscripten_bind_McGeVector3d_McGeVector3d_0 = function () { return (na = b._emscripten_bind_McGeVector3d_McGeVector3d_0 = b.asm.f).apply(null, arguments); }, oa = b._emscripten_bind_McGeVector3d_McGeVector3d_3 = function () { return (oa = b._emscripten_bind_McGeVector3d_McGeVector3d_3 = b.asm.g).apply(null, arguments); }, pa = b._emscripten_bind_McGeVector3d_getVal_1 = function () {
+                return (pa =
+                    b._emscripten_bind_McGeVector3d_getVal_1 = b.asm.h).apply(null, arguments);
+            }, qa = b._emscripten_bind_McGeVector3d_setVal_1 = function () { return (qa = b._emscripten_bind_McGeVector3d_setVal_1 = b.asm.i).apply(null, arguments); }, sa = b._emscripten_bind_McGeVector3d___destroy___0 = function () { return (sa = b._emscripten_bind_McGeVector3d___destroy___0 = b.asm.j).apply(null, arguments); }, T;
+            N = function ta() { T || U(); T || (N = ta); };
+            function U() { function a() { if (!T && (T = !0, b.calledRun = !0, !E)) {
+                R(J);
+                g(b);
+                if (b.onRuntimeInitialized)
+                    b.onRuntimeInitialized();
+                if (b.postRun)
+                    for ("function" == typeof b.postRun && (b.postRun = [b.postRun]); b.postRun.length;) {
+                        var c = b.postRun.shift();
+                        K.unshift(c);
+                    }
+                R(K);
+            } } if (!(0 < L)) {
+                if (b.preRun)
+                    for ("function" == typeof b.preRun && (b.preRun = [b.preRun]); b.preRun.length;)
+                        ha();
+                R(I);
+                0 < L || (b.setStatus ? (b.setStatus("Running..."), setTimeout(function () { setTimeout(function () { b.setStatus(""); }, 1); a(); }, 1)) : a());
+            } }
+            b.run = U;
+            if (b.preInit)
+                for ("function" == typeof b.preInit && (b.preInit = [b.preInit]); 0 < b.preInit.length;)
+                    b.preInit.pop()();
+            U();
+            function V() { }
+            V.prototype = Object.create(V.prototype);
+            V.prototype.constructor = V;
+            V.prototype.m = V;
+            V.o = {};
+            b.WrapperObject = V;
+            function W(a) { return (a || V).o; }
+            b.getCache = W;
+            function X(a, c) { var d = W(c), e = d[a]; if (e)
+                return e; e = Object.create((c || V).prototype); e.l = a; return d[a] = e; }
+            b.wrapPointer = X;
+            b.castObject = function (a, c) { return X(a.l, c); };
+            b.NULL = X(0);
+            b.destroy = function (a) { if (!a.__destroy__)
+                throw "Error: Cannot destroy object. (Did you create it yourself?)"; a.__destroy__(); delete W(a.m)[a.l]; };
+            b.compare = function (a, c) { return a.l === c.l; };
+            b.getPointer = function (a) { return a.l; };
+            b.getClass = function (a) { return a.m; };
+            function Y() { throw "cannot construct a VoidPtr, no constructor in IDL"; }
+            Y.prototype = Object.create(V.prototype);
+            Y.prototype.constructor = Y;
+            Y.prototype.m = Y;
+            Y.o = {};
+            b.VoidPtr = Y;
+            Y.prototype.__destroy__ = function () { ma(this.l); };
+            function Z(a, c, d) { a && "object" === typeof a && (a = a.l); c && "object" === typeof c && (c = c.l); d && "object" === typeof d && (d = d.l); this.l = void 0 === a ? na() : void 0 === c ? _emscripten_bind_McGeVector3d_McGeVector3d_1(a) : void 0 === d ? _emscripten_bind_McGeVector3d_McGeVector3d_2(a, c) : oa(a, c, d); W(Z)[this.l] = this; }
+            Z.prototype = Object.create(V.prototype);
+            Z.prototype.constructor = Z;
+            Z.prototype.m = Z;
+            Z.o = {};
+            b.McGeVector3d = Z;
+            Z.prototype.getVal = function (a) { var c = this.l; a && "object" === typeof a && (a = a.l); return pa(c, a); };
+            Z.prototype.setVal = function (a) { var c = this.l; a && "object" === typeof a && (a = a.l); qa(c, a); };
+            Z.prototype.__destroy__ = function () { sa(this.l); };
+            return mxcadassembly.ready;
+        });
+    })();
+    if (typeof exports === 'object' && typeof module === 'object')
+        module.exports = mxcadassembly;
+    else if (typeof define === 'function' && define['amd'])
+        define([], function () { return mxcadassembly; });
+    else if (typeof exports === 'object')
+        exports["mxcadassembly"] = mxcadassembly;
+    return mxcadassembly();
+}
+exports.default = mxcadassemblyinit;