diff --git a/codecs/jxl/dec/jxl_dec.js b/codecs/jxl/dec/jxl_dec.js
index 954d9208..7101ead7 100644
--- a/codecs/jxl/dec/jxl_dec.js
+++ b/codecs/jxl/dec/jxl_dec.js
@@ -6,54 +6,2012 @@ var jxl_dec = (function() {
 function(jxl_dec) {
   jxl_dec = jxl_dec || {};
 
+var Module = typeof jxl_dec !== "undefined" ? jxl_dec : {};
 
-var d;d||(d=typeof jxl_dec !== 'undefined' ? jxl_dec : {});var aa,ba;d.ready=new Promise(function(a,b){aa=a;ba=b});var r={},t;for(t in d)d.hasOwnProperty(t)&&(r[t]=d[t]);var ca="./this.program",u=!1,v=!1,da=!1,ea=!1;u="object"===typeof window;v="function"===typeof importScripts;da="object"===typeof process&&"object"===typeof process.versions&&"string"===typeof process.versions.node;ea=!u&&!da&&!v;var w="",x,z,fa,ha;
-if(da)w=v?require("path").dirname(w)+"/":__dirname+"/",x=function(a,b){fa||(fa=require("fs"));ha||(ha=require("path"));a=ha.normalize(a);return fa.readFileSync(a,b?null:"utf8")},z=function(a){a=x(a,!0);a.buffer||(a=new Uint8Array(a));a.buffer||A("Assertion failed: undefined");return a},1<process.argv.length&&(ca=process.argv[1].replace(/\\/g,"/")),process.argv.slice(2),process.on("uncaughtException",function(a){throw a;}),process.on("unhandledRejection",A),d.inspect=function(){return"[Emscripten Module object]"};
-else if(ea)"undefined"!=typeof read&&(x=function(a){return read(a)}),z=function(a){if("function"===typeof readbuffer)return new Uint8Array(readbuffer(a));a=read(a,"binary");"object"===typeof a||A("Assertion failed: undefined");return a},"undefined"!==typeof print&&("undefined"===typeof console&&(console={}),console.log=print,console.warn=console.error="undefined"!==typeof printErr?printErr:print);else if(u||v)v?w=self.location.href:document.currentScript&&(w=document.currentScript.src),_scriptDir&&
-(w=_scriptDir),0!==w.indexOf("blob:")?w=w.substr(0,w.lastIndexOf("/")+1):w="",x=function(a){var b=new XMLHttpRequest;b.open("GET",a,!1);b.send(null);return b.responseText},v&&(z=function(a){var b=new XMLHttpRequest;b.open("GET",a,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)});var ia=d.print||console.log.bind(console),B=d.printErr||console.warn.bind(console);for(t in r)r.hasOwnProperty(t)&&(d[t]=r[t]);r=null;d.thisProgram&&(ca=d.thisProgram);var D;
-d.wasmBinary&&(D=d.wasmBinary);var noExitRuntime;d.noExitRuntime&&(noExitRuntime=d.noExitRuntime);"object"!==typeof WebAssembly&&A("no native wasm support detected");var E,ja=new WebAssembly.Table({initial:568,maximum:568,element:"anyfunc"}),ka=!1,la="undefined"!==typeof TextDecoder?new TextDecoder("utf8"):void 0;
-function ma(a,b,c){b>>>=0;var e=b+c;for(c=b;a[c>>>0]&&!(c>=e);)++c;if(16<c-b&&a.subarray&&la)return la.decode(a.subarray(b>>>0,c>>>0));for(e="";b<c;){var f=a[b++>>>0];if(f&128){var g=a[b++>>>0]&63;if(192==(f&224))e+=String.fromCharCode((f&31)<<6|g);else{var l=a[b++>>>0]&63;f=224==(f&240)?(f&15)<<12|g<<6|l:(f&7)<<18|g<<12|l<<6|a[b++>>>0]&63;65536>f?e+=String.fromCharCode(f):(f-=65536,e+=String.fromCharCode(55296|f>>10,56320|f&1023))}}else e+=String.fromCharCode(f)}return e}
-function na(a,b,c){var e=F;b>>>=0;if(0<c){c=b+c-1;for(var f=0;f<a.length;++f){var g=a.charCodeAt(f);if(55296<=g&&57343>=g){var l=a.charCodeAt(++f);g=65536+((g&1023)<<10)|l&1023}if(127>=g){if(b>=c)break;e[b++>>>0]=g}else{if(2047>=g){if(b+1>=c)break;e[b++>>>0]=192|g>>6}else{if(65535>=g){if(b+2>=c)break;e[b++>>>0]=224|g>>12}else{if(b+3>=c)break;e[b++>>>0]=240|g>>18;e[b++>>>0]=128|g>>12&63}e[b++>>>0]=128|g>>6&63}e[b++>>>0]=128|g&63}}e[b>>>0]=0}}
-var oa="undefined"!==typeof TextDecoder?new TextDecoder("utf-16le"):void 0;function pa(a,b){var c=a>>1;for(var e=c+b/2;!(c>=e)&&G[c>>>0];)++c;c<<=1;if(32<c-a&&oa)return oa.decode(F.subarray(a>>>0,c>>>0));c=0;for(e="";;){var f=H[a+2*c>>1>>>0];if(0==f||c==b/2)return e;++c;e+=String.fromCharCode(f)}}function qa(a,b,c){void 0===c&&(c=2147483647);if(2>c)return 0;c-=2;var e=b;c=c<2*a.length?c/2:a.length;for(var f=0;f<c;++f)H[b>>1>>>0]=a.charCodeAt(f),b+=2;H[b>>1>>>0]=0;return b-e}
-function ra(a){return 2*a.length}function sa(a,b){for(var c=0,e="";!(c>=b/4);){var f=I[a+4*c>>2>>>0];if(0==f)break;++c;65536<=f?(f-=65536,e+=String.fromCharCode(55296|f>>10,56320|f&1023)):e+=String.fromCharCode(f)}return e}function ta(a,b,c){b>>>=0;void 0===c&&(c=2147483647);if(4>c)return 0;var e=b;c=e+c-4;for(var f=0;f<a.length;++f){var g=a.charCodeAt(f);if(55296<=g&&57343>=g){var l=a.charCodeAt(++f);g=65536+((g&1023)<<10)|l&1023}I[b>>2>>>0]=g;b+=4;if(b+4>c)break}I[b>>2>>>0]=0;return b-e}
-function ua(a){for(var b=0,c=0;c<a.length;++c){var e=a.charCodeAt(c);55296<=e&&57343>=e&&++c;b+=4}return b}var J,L,F,H,G,I,M,va,wa;function xa(a){J=a;d.HEAP8=L=new Int8Array(a);d.HEAP16=H=new Int16Array(a);d.HEAP32=I=new Int32Array(a);d.HEAPU8=F=new Uint8Array(a);d.HEAPU16=G=new Uint16Array(a);d.HEAPU32=M=new Uint32Array(a);d.HEAPF32=va=new Float32Array(a);d.HEAPF64=wa=new Float64Array(a)}var ya=d.INITIAL_MEMORY||16777216;d.wasmMemory?E=d.wasmMemory:E=new WebAssembly.Memory({initial:ya/65536,maximum:65536});
-E&&(J=E.buffer);ya=J.byteLength;xa(J);I[58044]=5475216;function N(a){for(;0<a.length;){var b=a.shift();if("function"==typeof b)b(d);else{var c=b.da;"number"===typeof c?void 0===b.Z?d.dynCall_v(c):d.dynCall_vi(c,b.Z):c(void 0===b.Z?null:b.Z)}}}var za=[],Aa=[],Ba=[],Ca=[];function Da(){var a=d.preRun.shift();za.unshift(a)}var Ea=Math.ceil,Fa=Math.floor,O=0,Ga=null,Q=null;d.preloadedImages={};d.preloadedAudios={};
-function A(a){if(d.onAbort)d.onAbort(a);B(a);ka=!0;a=new WebAssembly.RuntimeError("abort("+a+"). Build with -s ASSERTIONS=1 for more info.");ba(a);throw a;}function Ha(a){var b=R;return String.prototype.startsWith?b.startsWith(a):0===b.indexOf(a)}function Ia(){return Ha("data:application/octet-stream;base64,")}var R="jxl_dec.wasm";if(!Ia()){var Ja=R;R=d.locateFile?d.locateFile(Ja,w):w+Ja}
-function Ka(){try{if(D)return new Uint8Array(D);if(z)return z(R);throw"both async and sync fetching of the wasm failed";}catch(a){A(a)}}function La(){return D||!u&&!v||"function"!==typeof fetch||Ha("file://")?new Promise(function(a){a(Ka())}):fetch(R,{credentials:"same-origin"}).then(function(a){if(!a.ok)throw"failed to load wasm binary file at '"+R+"'";return a.arrayBuffer()}).catch(function(){return Ka()})}Aa.push({da:function(){Ma()}});function S(){return 0<S.aa}
-function Na(a){switch(a){case 1:return 0;case 2:return 1;case 4:return 2;case 8:return 3;default:throw new TypeError("Unknown type size: "+a);}}var Oa=void 0;function T(a){for(var b="";F[a>>>0];)b+=Oa[F[a++>>>0]];return b}var U={},V={},Pa={};function Qa(a){if(void 0===a)return"_unknown";a=a.replace(/[^a-zA-Z0-9_]/g,"$");var b=a.charCodeAt(0);return 48<=b&&57>=b?"_"+a:a}
-function Ra(a,b){a=Qa(a);return(new Function("body","return function "+a+'() {\n    "use strict";    return body.apply(this, arguments);\n};\n'))(b)}function Sa(a){var b=Error,c=Ra(a,function(e){this.name=a;this.message=e;e=Error(e).stack;void 0!==e&&(this.stack=this.toString()+"\n"+e.replace(/^Error(:[^\n]*)?\n/,""))});c.prototype=Object.create(b.prototype);c.prototype.constructor=c;c.prototype.toString=function(){return void 0===this.message?this.name:this.name+": "+this.message};return c}
-var Ta=void 0;function W(a){throw new Ta(a);}var Ua=void 0;function Va(a,b){function c(h){h=b(h);if(h.length!==e.length)throw new Ua("Mismatched type converter count");for(var k=0;k<e.length;++k)X(e[k],h[k])}var e=[];e.forEach(function(h){Pa[h]=a});var f=Array(a.length),g=[],l=0;a.forEach(function(h,k){V.hasOwnProperty(h)?f[k]=V[h]:(g.push(h),U.hasOwnProperty(h)||(U[h]=[]),U[h].push(function(){f[k]=V[h];++l;l===g.length&&c(f)}))});0===g.length&&c(f)}
-function X(a,b,c){c=c||{};if(!("argPackAdvance"in b))throw new TypeError("registerType registeredInstance requires argPackAdvance");var e=b.name;a||W('type "'+e+'" must have a positive integer typeid pointer');if(V.hasOwnProperty(a)){if(c.ea)return;W("Cannot register type '"+e+"' twice")}V[a]=b;delete Pa[a];U.hasOwnProperty(a)&&(b=U[a],delete U[a],b.forEach(function(f){f()}))}var Wa=[],Y=[{},{value:void 0},{value:null},{value:!0},{value:!1}];
-function Xa(a){4<a&&0===--Y[a].$&&(Y[a]=void 0,Wa.push(a))}function Ya(a){switch(a){case void 0:return 1;case null:return 2;case !0:return 3;case !1:return 4;default:var b=Wa.length?Wa.pop():Y.length;Y[b]={$:1,value:a};return b}}function Za(a){return this.fromWireType(M[a>>>2])}function $a(a){if(null===a)return"null";var b=typeof a;return"object"===b||"array"===b||"function"===b?a.toString():""+a}
-function cb(a,b){switch(b){case 2:return function(c){return this.fromWireType(va[c>>>2])};case 3:return function(c){return this.fromWireType(wa[c>>>3])};default:throw new TypeError("Unknown float type: "+a);}}function db(a){var b=Function;if(!(b instanceof Function))throw new TypeError("new_ called with constructor type "+typeof b+" which is not a function");var c=Ra(b.name||"unknownFunctionName",function(){});c.prototype=b.prototype;c=new c;a=b.apply(c,a);return a instanceof Object?a:c}
-function eb(a){for(;a.length;){var b=a.pop();a.pop()(b)}}function fb(a,b){var c=d;if(void 0===c[a].X){var e=c[a];c[a]=function(){c[a].X.hasOwnProperty(arguments.length)||W("Function '"+b+"' called with an invalid number of arguments ("+arguments.length+") - expects one of ("+c[a].X+")!");return c[a].X[arguments.length].apply(this,arguments)};c[a].X=[];c[a].X[e.ba]=e}}
-function gb(a,b,c){d.hasOwnProperty(a)?((void 0===c||void 0!==d[a].X&&void 0!==d[a].X[c])&&W("Cannot register public name '"+a+"' twice"),fb(a,a),d.hasOwnProperty(c)&&W("Cannot register multiple overloads of a function with the same number of arguments ("+c+")!"),d[a].X[c]=b):(d[a]=b,void 0!==c&&(d[a].ga=c))}function hb(a,b){for(var c=[],e=0;e<a;e++)c.push(I[(b>>2)+e>>>0]);return c}
-function ib(a,b){a=T(a);var c=d["dynCall_"+a];for(var e=[],f=1;f<a.length;++f)e.push("a"+f);f="return function dynCall_"+(a+"_"+b)+"("+e.join(", ")+") {\n";f+="    return dynCall(rawFunction"+(e.length?", ":"")+e.join(", ")+");\n";c=(new Function("dynCall","rawFunction",f+"};\n"))(c,b);"function"!==typeof c&&W("unknown function pointer with signature "+a+": "+b);return c}var jb=void 0;function kb(a){a=lb(a);var b=T(a);Z(a);return b}
-function mb(a,b){function c(g){f[g]||V[g]||(Pa[g]?Pa[g].forEach(c):(e.push(g),f[g]=!0))}var e=[],f={};b.forEach(c);throw new jb(a+": "+e.map(kb).join([", "]));}function nb(a,b,c){switch(b){case 0:return c?function(e){return L[e>>>0]}:function(e){return F[e>>>0]};case 1:return c?function(e){return H[e>>>1]}:function(e){return G[e>>>1]};case 2:return c?function(e){return I[e>>>2]}:function(e){return M[e>>>2]};default:throw new TypeError("Unknown integer type: "+a);}}var ob={};
-function pb(){return"object"===typeof globalThis?globalThis:Function("return this")()}function qb(a,b){var c=V[a];void 0===c&&W(b+" has unknown type "+kb(a));return c}var rb={},sb={};function tb(){if(!ub){var a={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"===typeof navigator&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",_:ca||"./this.program"},b;for(b in sb)a[b]=sb[b];var c=[];for(b in a)c.push(b+"="+a[b]);ub=c}return ub}
-for(var ub,vb=[null,[],[]],wb=Array(256),xb=0;256>xb;++xb)wb[xb]=String.fromCharCode(xb);Oa=wb;Ta=d.BindingError=Sa("BindingError");Ua=d.InternalError=Sa("InternalError");d.count_emval_handles=function(){for(var a=0,b=5;b<Y.length;++b)void 0!==Y[b]&&++a;return a};d.get_first_emval=function(){for(var a=5;a<Y.length;++a)if(void 0!==Y[a])return Y[a];return null};jb=d.UnboundTypeError=Sa("UnboundTypeError");
-var zb={q:function(a){return yb(a)},l:function(){},p:function(a){"uncaught_exception"in S?S.aa++:S.aa=1;throw a;},z:function(a,b,c,e,f){var g=Na(c);b=T(b);X(a,{name:b,fromWireType:function(l){return!!l},toWireType:function(l,h){return h?e:f},argPackAdvance:8,readValueFromPointer:function(l){if(1===c)var h=L;else if(2===c)h=H;else if(4===c)h=I;else throw new TypeError("Unknown boolean type size: "+b);return this.fromWireType(h[l>>>g])},Y:null})},y:function(a,b){b=T(b);X(a,{name:b,fromWireType:function(c){var e=
-Y[c].value;Xa(c);return e},toWireType:function(c,e){return Ya(e)},argPackAdvance:8,readValueFromPointer:Za,Y:null})},j:function(a,b,c){c=Na(c);b=T(b);X(a,{name:b,fromWireType:function(e){return e},toWireType:function(e,f){if("number"!==typeof f&&"boolean"!==typeof f)throw new TypeError('Cannot convert "'+$a(f)+'" to '+this.name);return f},argPackAdvance:8,readValueFromPointer:cb(b,c),Y:null})},n:function(a,b,c,e,f,g){var l=hb(b,c);a=T(a);f=ib(e,f);gb(a,function(){mb("Cannot call "+a+" due to unbound types",
-l)},b-1);Va(l,function(h){var k=[h[0],null].concat(h.slice(1)),m=h=a,p=f,q=k.length;2>q&&W("argTypes array size mismatch! Must at least get return value and 'this' types!");for(var y=null!==k[1]&&!1,C=!1,n=1;n<k.length;++n)if(null!==k[n]&&void 0===k[n].Y){C=!0;break}var ab="void"!==k[0].name,K="",P="";for(n=0;n<q-2;++n)K+=(0!==n?", ":"")+"arg"+n,P+=(0!==n?", ":"")+"arg"+n+"Wired";m="return function "+Qa(m)+"("+K+") {\nif (arguments.length !== "+(q-2)+") {\nthrowBindingError('function "+m+" called with ' + arguments.length + ' arguments, expected "+
-(q-2)+" args!');\n}\n";C&&(m+="var destructors = [];\n");var bb=C?"destructors":"null";K="throwBindingError invoker fn runDestructors retType classParam".split(" ");p=[W,p,g,eb,k[0],k[1]];y&&(m+="var thisWired = classParam.toWireType("+bb+", this);\n");for(n=0;n<q-2;++n)m+="var arg"+n+"Wired = argType"+n+".toWireType("+bb+", arg"+n+"); // "+k[n+2].name+"\n",K.push("argType"+n),p.push(k[n+2]);y&&(P="thisWired"+(0<P.length?", ":"")+P);m+=(ab?"var rv = ":"")+"invoker(fn"+(0<P.length?", ":"")+P+");\n";
-if(C)m+="runDestructors(destructors);\n";else for(n=y?1:2;n<k.length;++n)q=1===n?"thisWired":"arg"+(n-2)+"Wired",null!==k[n].Y&&(m+=q+"_dtor("+q+"); // "+k[n].name+"\n",K.push(q+"_dtor"),p.push(k[n].Y));ab&&(m+="var ret = retType.fromWireType(rv);\nreturn ret;\n");K.push(m+"}\n");k=db(K).apply(null,p);n=b-1;if(!d.hasOwnProperty(h))throw new Ua("Replacing nonexistant public symbol");void 0!==d[h].X&&void 0!==n?d[h].X[n]=k:(d[h]=k,d[h].ba=n);return[]})},b:function(a,b,c,e,f){function g(m){return m}
-b=T(b);-1===f&&(f=4294967295);var l=Na(c);if(0===e){var h=32-8*c;g=function(m){return m<<h>>>h}}var k=-1!=b.indexOf("unsigned");X(a,{name:b,fromWireType:g,toWireType:function(m,p){if("number"!==typeof p&&"boolean"!==typeof p)throw new TypeError('Cannot convert "'+$a(p)+'" to '+this.name);if(p<e||p>f)throw new TypeError('Passing a number "'+$a(p)+'" from JS side to C/C++ side to an argument of type "'+b+'", which is outside the valid range ['+e+", "+f+"]!");return k?p>>>0:p|0},argPackAdvance:8,readValueFromPointer:nb(b,
-l,0!==e),Y:null})},a:function(a,b,c){function e(g){g>>=2;var l=M;return new f(J,l[g+1>>>0],l[g>>>0])}var f=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array][b];c=T(c);X(a,{name:c,fromWireType:e,argPackAdvance:8,readValueFromPointer:e},{ea:!0})},k:function(a,b){b=T(b);var c="std::string"===b;X(a,{name:b,fromWireType:function(e){var f=M[e>>>2];if(c)for(var g=e+4,l=0;l<=f;++l){var h=e+4+l;if(l==f||0==F[h>>>0]){var k=g;g=(k>>>=0)?ma(F,k,h-g):"";if(void 0===
-m)var m=g;else m+=String.fromCharCode(0),m+=g;g=h+1}}else{m=Array(f);for(l=0;l<f;++l)m[l]=String.fromCharCode(F[e+4+l>>>0]);m=m.join("")}Z(e);return m},toWireType:function(e,f){f instanceof ArrayBuffer&&(f=new Uint8Array(f));var g="string"===typeof f;g||f instanceof Uint8Array||f instanceof Uint8ClampedArray||f instanceof Int8Array||W("Cannot pass non-string to std::string");var l=(c&&g?function(){for(var m=0,p=0;p<f.length;++p){var q=f.charCodeAt(p);55296<=q&&57343>=q&&(q=65536+((q&1023)<<10)|f.charCodeAt(++p)&
-1023);127>=q?++m:m=2047>=q?m+2:65535>=q?m+3:m+4}return m}:function(){return f.length})(),h=yb(4+l+1);h>>>=0;M[h>>>2]=l;if(c&&g)na(f,h+4,l+1);else if(g)for(g=0;g<l;++g){var k=f.charCodeAt(g);255<k&&(Z(h),W("String has UTF-16 code units that do not fit in 8 bits"));F[h+4+g>>>0]=k}else for(g=0;g<l;++g)F[h+4+g>>>0]=f[g];null!==e&&e.push(Z,h);return h},argPackAdvance:8,readValueFromPointer:Za,Y:function(e){Z(e)}})},d:function(a,b,c){c=T(c);if(2===b){var e=pa;var f=qa;var g=ra;var l=function(){return G};
-var h=1}else 4===b&&(e=sa,f=ta,g=ua,l=function(){return M},h=2);X(a,{name:c,fromWireType:function(k){for(var m=M[k>>>2],p=l(),q,y=k+4,C=0;C<=m;++C){var n=k+4+C*b;if(C==m||0==p[n>>>h])y=e(y,n-y),void 0===q?q=y:(q+=String.fromCharCode(0),q+=y),y=n+b}Z(k);return q},toWireType:function(k,m){"string"!==typeof m&&W("Cannot pass non-string to C++ string type "+c);var p=g(m),q=yb(4+p+b);q>>>=0;M[q>>>2]=p>>h;f(m,q+4,p+b);null!==k&&k.push(Z,q);return q},argPackAdvance:8,readValueFromPointer:Za,Y:function(k){Z(k)}})},
-m:function(a,b){b=T(b);X(a,{fa:!0,name:b,argPackAdvance:0,fromWireType:function(){},toWireType:function(){}})},w:Xa,A:function(a){if(0===a)return Ya(pb());var b=ob[a];a=void 0===b?T(a):b;return Ya(pb()[a])},o:function(a){4<a&&(Y[a].$+=1)},f:function(a,b,c,e){a||W("Cannot use deleted val. handle = "+a);a=Y[a].value;var f=rb[b];if(!f){f="";for(var g=0;g<b;++g)f+=(0!==g?", ":"")+"arg"+g;var l="return function emval_allocator_"+b+"(constructor, argTypes, args) {\n";for(g=0;g<b;++g)l+="var argType"+g+
-" = requireRegisteredType(Module['HEAP32'][(argTypes >>> 2) + "+g+'], "parameter '+g+'");\nvar arg'+g+" = argType"+g+".readValueFromPointer(args);\nargs += argType"+g+"['argPackAdvance'];\n";f=(new Function("requireRegisteredType","Module","__emval_register",l+("var obj = new constructor("+f+");\nreturn __emval_register(obj);\n}\n")))(qb,d,Ya);rb[b]=f}return f(a,c,e)},e:function(){A()},t:function(a,b,c){F.copyWithin(a>>>0,b>>>0,b+c>>>0)},c:function(a){a>>>=0;var b=F.length;if(4294967296<a)return!1;
-for(var c=1;4>=c;c*=2){var e=b*(1+.2/c);e=Math.min(e,a+100663296);e=Math.max(16777216,a,e);0<e%65536&&(e+=65536-e%65536);a:{try{E.grow(Math.min(4294967296,e)-J.byteLength+65535>>>16);xa(E.buffer);var f=1;break a}catch(g){}f=void 0}if(f)return!0}return!1},u:function(a,b){var c=0;tb().forEach(function(e,f){var g=b+c;f=I[a+4*f>>2>>>0]=g;for(g=0;g<e.length;++g)L[f++>>0>>>0]=e.charCodeAt(g);L[f>>0>>>0]=0;c+=e.length+1});return 0},v:function(a,b){var c=tb();I[a>>2>>>0]=c.length;var e=0;c.forEach(function(f){e+=
-f.length+1});I[b>>2>>>0]=e;return 0},x:function(){return 0},r:function(){},i:function(a,b,c,e){for(var f=0,g=0;g<c;g++){for(var l=I[b+8*g>>2>>>0],h=I[b+(8*g+4)>>2>>>0],k=0;k<h;k++){var m=F[l+k>>>0],p=vb[a];0===m||10===m?((1===a?ia:B)(ma(p,0)),p.length=0):p.push(m)}f+=h}I[e>>2>>>0]=f;return 0},memory:E,g:function(a){a=+a;return 0<=a?+Fa(a+.5):+Ea(a-.5)},h:function(a){a=+a;return 0<=a?+Fa(a+.5):+Ea(a-.5)},s:function(){},table:ja};
-(function(){function a(f){d.asm=f.exports;O--;d.monitorRunDependencies&&d.monitorRunDependencies(O);0==O&&(null!==Ga&&(clearInterval(Ga),Ga=null),Q&&(f=Q,Q=null,f()))}function b(f){a(f.instance)}function c(f){return La().then(function(g){return WebAssembly.instantiate(g,e)}).then(f,function(g){B("failed to asynchronously prepare wasm: "+g);A(g)})}var e={a:zb};O++;d.monitorRunDependencies&&d.monitorRunDependencies(O);if(d.instantiateWasm)try{return d.instantiateWasm(e,a)}catch(f){return B("Module.instantiateWasm callback failed with error: "+
-f),!1}(function(){if(D||"function"!==typeof WebAssembly.instantiateStreaming||Ia()||Ha("file://")||"function"!==typeof fetch)return c(b);fetch(R,{credentials:"same-origin"}).then(function(f){return WebAssembly.instantiateStreaming(f,e).then(b,function(g){B("wasm streaming compile failed: "+g);B("falling back to ArrayBuffer instantiation");return c(b)})})})();return{}})();
-var Ma=d.___wasm_call_ctors=function(){return(Ma=d.___wasm_call_ctors=d.asm.B).apply(null,arguments)},yb=d._malloc=function(){return(yb=d._malloc=d.asm.C).apply(null,arguments)},Z=d._free=function(){return(Z=d._free=d.asm.D).apply(null,arguments)},lb=d.___getTypeName=function(){return(lb=d.___getTypeName=d.asm.E).apply(null,arguments)};d.___embind_register_native_and_builtin_types=function(){return(d.___embind_register_native_and_builtin_types=d.asm.F).apply(null,arguments)};
-d.dynCall_iii=function(){return(d.dynCall_iii=d.asm.G).apply(null,arguments)};d.dynCall_vii=function(){return(d.dynCall_vii=d.asm.H).apply(null,arguments)};d.dynCall_ii=function(){return(d.dynCall_ii=d.asm.I).apply(null,arguments)};d.dynCall_vi=function(){return(d.dynCall_vi=d.asm.J).apply(null,arguments)};d.dynCall_iidiiii=function(){return(d.dynCall_iidiiii=d.asm.K).apply(null,arguments)};d.dynCall_iiiiiii=function(){return(d.dynCall_iiiiiii=d.asm.L).apply(null,arguments)};
-d.dynCall_viii=function(){return(d.dynCall_viii=d.asm.M).apply(null,arguments)};d.dynCall_viiiiiii=function(){return(d.dynCall_viiiiiii=d.asm.N).apply(null,arguments)};d.dynCall_iiii=function(){return(d.dynCall_iiii=d.asm.O).apply(null,arguments)};d.dynCall_v=function(){return(d.dynCall_v=d.asm.P).apply(null,arguments)};d.dynCall_iiiii=function(){return(d.dynCall_iiiii=d.asm.Q).apply(null,arguments)};d.dynCall_iiji=function(){return(d.dynCall_iiji=d.asm.R).apply(null,arguments)};
-d.dynCall_iifi=function(){return(d.dynCall_iifi=d.asm.S).apply(null,arguments)};d.dynCall_jiji=function(){return(d.dynCall_jiji=d.asm.T).apply(null,arguments)};d.dynCall_viiiiii=function(){return(d.dynCall_viiiiii=d.asm.U).apply(null,arguments)};d.dynCall_viiiii=function(){return(d.dynCall_viiiii=d.asm.V).apply(null,arguments)};d.dynCall_viiii=function(){return(d.dynCall_viiii=d.asm.W).apply(null,arguments)};var Ab;Q=function Bb(){Ab||Cb();Ab||(Q=Bb)};
-function Cb(){function a(){if(!Ab&&(Ab=!0,d.calledRun=!0,!ka)){N(Aa);N(Ba);aa(d);if(d.onRuntimeInitialized)d.onRuntimeInitialized();if(d.postRun)for("function"==typeof d.postRun&&(d.postRun=[d.postRun]);d.postRun.length;){var b=d.postRun.shift();Ca.unshift(b)}N(Ca)}}if(!(0<O)){if(d.preRun)for("function"==typeof d.preRun&&(d.preRun=[d.preRun]);d.preRun.length;)Da();N(za);0<O||(d.setStatus?(d.setStatus("Running..."),setTimeout(function(){setTimeout(function(){d.setStatus("")},1);a()},1)):a())}}
-d.run=Cb;if(d.preInit)for("function"==typeof d.preInit&&(d.preInit=[d.preInit]);0<d.preInit.length;)d.preInit.pop()();noExitRuntime=!0;Cb();
+var readyPromiseResolve, readyPromiseReject;
+
+Module["ready"] = new Promise(function(resolve, reject) {
+ readyPromiseResolve = resolve;
+ readyPromiseReject = reject;
+});
+
+var moduleOverrides = {};
+
+var key;
+
+for (key in Module) {
+ if (Module.hasOwnProperty(key)) {
+  moduleOverrides[key] = Module[key];
+ }
+}
+
+var arguments_ = [];
+
+var thisProgram = "./this.program";
+
+var quit_ = function(status, toThrow) {
+ throw toThrow;
+};
+
+var ENVIRONMENT_IS_WEB = false;
+
+var ENVIRONMENT_IS_WORKER = false;
+
+var ENVIRONMENT_IS_NODE = false;
+
+var ENVIRONMENT_IS_SHELL = false;
+
+ENVIRONMENT_IS_WEB = typeof window === "object";
+
+ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
+
+ENVIRONMENT_IS_NODE = typeof process === "object" && typeof process.versions === "object" && typeof process.versions.node === "string";
+
+ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+var scriptDirectory = "";
+
+function locateFile(path) {
+ if (Module["locateFile"]) {
+  return Module["locateFile"](path, scriptDirectory);
+ }
+ return scriptDirectory + path;
+}
+
+var read_, readAsync, readBinary, setWindowTitle;
+
+var nodeFS;
+
+var nodePath;
+
+if (ENVIRONMENT_IS_NODE) {
+ if (ENVIRONMENT_IS_WORKER) {
+  scriptDirectory = require("path").dirname(scriptDirectory) + "/";
+ } else {
+  scriptDirectory = __dirname + "/";
+ }
+ read_ = function shell_read(filename, binary) {
+  if (!nodeFS) nodeFS = require("fs");
+  if (!nodePath) nodePath = require("path");
+  filename = nodePath["normalize"](filename);
+  return nodeFS["readFileSync"](filename, binary ? null : "utf8");
+ };
+ readBinary = function readBinary(filename) {
+  var ret = read_(filename, true);
+  if (!ret.buffer) {
+   ret = new Uint8Array(ret);
+  }
+  assert(ret.buffer);
+  return ret;
+ };
+ if (process["argv"].length > 1) {
+  thisProgram = process["argv"][1].replace(/\\/g, "/");
+ }
+ arguments_ = process["argv"].slice(2);
+ process["on"]("uncaughtException", function(ex) {
+  if (!(ex instanceof ExitStatus)) {
+   throw ex;
+  }
+ });
+ process["on"]("unhandledRejection", abort);
+ quit_ = function(status) {
+  process["exit"](status);
+ };
+ Module["inspect"] = function() {
+  return "[Emscripten Module object]";
+ };
+} else if (ENVIRONMENT_IS_SHELL) {
+ if (typeof read != "undefined") {
+  read_ = function shell_read(f) {
+   return read(f);
+  };
+ }
+ readBinary = function readBinary(f) {
+  var data;
+  if (typeof readbuffer === "function") {
+   return new Uint8Array(readbuffer(f));
+  }
+  data = read(f, "binary");
+  assert(typeof data === "object");
+  return data;
+ };
+ if (typeof scriptArgs != "undefined") {
+  arguments_ = scriptArgs;
+ } else if (typeof arguments != "undefined") {
+  arguments_ = arguments;
+ }
+ if (typeof quit === "function") {
+  quit_ = function(status) {
+   quit(status);
+  };
+ }
+ if (typeof print !== "undefined") {
+  if (typeof console === "undefined") console = {};
+  console.log = print;
+  console.warn = console.error = typeof printErr !== "undefined" ? printErr : print;
+ }
+} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ if (ENVIRONMENT_IS_WORKER) {
+  scriptDirectory = self.location.href;
+ } else if (document.currentScript) {
+  scriptDirectory = document.currentScript.src;
+ }
+ if (_scriptDir) {
+  scriptDirectory = _scriptDir;
+ }
+ if (scriptDirectory.indexOf("blob:") !== 0) {
+  scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf("/") + 1);
+ } else {
+  scriptDirectory = "";
+ }
+ {
+  read_ = function shell_read(url) {
+   var xhr = new XMLHttpRequest();
+   xhr.open("GET", url, false);
+   xhr.send(null);
+   return xhr.responseText;
+  };
+  if (ENVIRONMENT_IS_WORKER) {
+   readBinary = function readBinary(url) {
+    var xhr = new XMLHttpRequest();
+    xhr.open("GET", url, false);
+    xhr.responseType = "arraybuffer";
+    xhr.send(null);
+    return new Uint8Array(xhr.response);
+   };
+  }
+  readAsync = function readAsync(url, onload, onerror) {
+   var xhr = new XMLHttpRequest();
+   xhr.open("GET", url, true);
+   xhr.responseType = "arraybuffer";
+   xhr.onload = function xhr_onload() {
+    if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+     onload(xhr.response);
+     return;
+    }
+    onerror();
+   };
+   xhr.onerror = onerror;
+   xhr.send(null);
+  };
+ }
+ setWindowTitle = function(title) {
+  document.title = title;
+ };
+} else {}
+
+var out = Module["print"] || console.log.bind(console);
+
+var err = Module["printErr"] || console.warn.bind(console);
+
+for (key in moduleOverrides) {
+ if (moduleOverrides.hasOwnProperty(key)) {
+  Module[key] = moduleOverrides[key];
+ }
+}
+
+moduleOverrides = null;
+
+if (Module["arguments"]) arguments_ = Module["arguments"];
+
+if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
+
+if (Module["quit"]) quit_ = Module["quit"];
+
+var tempRet0 = 0;
+
+var setTempRet0 = function(value) {
+ tempRet0 = value;
+};
+
+var wasmBinary;
+
+if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
+
+var noExitRuntime;
+
+if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
+
+if (typeof WebAssembly !== "object") {
+ abort("no native wasm support detected");
+}
+
+var wasmMemory;
+
+var wasmTable = new WebAssembly.Table({
+ "initial": 568,
+ "maximum": 568 + 0,
+ "element": "anyfunc"
+});
+
+var ABORT = false;
+
+var EXITSTATUS = 0;
+
+function assert(condition, text) {
+ if (!condition) {
+  abort("Assertion failed: " + text);
+ }
+}
+
+var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
+
+function UTF8ArrayToString(heap, idx, maxBytesToRead) {
+ idx >>>= 0;
+ var endIdx = idx + maxBytesToRead;
+ var endPtr = idx;
+ while (heap[endPtr >>> 0] && !(endPtr >= endIdx)) ++endPtr;
+ if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
+  return UTF8Decoder.decode(heap.subarray(idx >>> 0, endPtr >>> 0));
+ } else {
+  var str = "";
+  while (idx < endPtr) {
+   var u0 = heap[idx++ >>> 0];
+   if (!(u0 & 128)) {
+    str += String.fromCharCode(u0);
+    continue;
+   }
+   var u1 = heap[idx++ >>> 0] & 63;
+   if ((u0 & 224) == 192) {
+    str += String.fromCharCode((u0 & 31) << 6 | u1);
+    continue;
+   }
+   var u2 = heap[idx++ >>> 0] & 63;
+   if ((u0 & 240) == 224) {
+    u0 = (u0 & 15) << 12 | u1 << 6 | u2;
+   } else {
+    u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heap[idx++ >>> 0] & 63;
+   }
+   if (u0 < 65536) {
+    str += String.fromCharCode(u0);
+   } else {
+    var ch = u0 - 65536;
+    str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+   }
+  }
+ }
+ return str;
+}
+
+function UTF8ToString(ptr, maxBytesToRead) {
+ ptr >>>= 0;
+ return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+}
+
+function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
+ outIdx >>>= 0;
+ if (!(maxBytesToWrite > 0)) return 0;
+ var startIdx = outIdx;
+ var endIdx = outIdx + maxBytesToWrite - 1;
+ for (var i = 0; i < str.length; ++i) {
+  var u = str.charCodeAt(i);
+  if (u >= 55296 && u <= 57343) {
+   var u1 = str.charCodeAt(++i);
+   u = 65536 + ((u & 1023) << 10) | u1 & 1023;
+  }
+  if (u <= 127) {
+   if (outIdx >= endIdx) break;
+   heap[outIdx++ >>> 0] = u;
+  } else if (u <= 2047) {
+   if (outIdx + 1 >= endIdx) break;
+   heap[outIdx++ >>> 0] = 192 | u >> 6;
+   heap[outIdx++ >>> 0] = 128 | u & 63;
+  } else if (u <= 65535) {
+   if (outIdx + 2 >= endIdx) break;
+   heap[outIdx++ >>> 0] = 224 | u >> 12;
+   heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
+   heap[outIdx++ >>> 0] = 128 | u & 63;
+  } else {
+   if (outIdx + 3 >= endIdx) break;
+   heap[outIdx++ >>> 0] = 240 | u >> 18;
+   heap[outIdx++ >>> 0] = 128 | u >> 12 & 63;
+   heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
+   heap[outIdx++ >>> 0] = 128 | u & 63;
+  }
+ }
+ heap[outIdx >>> 0] = 0;
+ return outIdx - startIdx;
+}
+
+function stringToUTF8(str, outPtr, maxBytesToWrite) {
+ return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+}
+
+function lengthBytesUTF8(str) {
+ var len = 0;
+ for (var i = 0; i < str.length; ++i) {
+  var u = str.charCodeAt(i);
+  if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
+  if (u <= 127) ++len; else if (u <= 2047) len += 2; else if (u <= 65535) len += 3; else len += 4;
+ }
+ return len;
+}
+
+var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined;
+
+function UTF16ToString(ptr, maxBytesToRead) {
+ var endPtr = ptr;
+ var idx = endPtr >> 1;
+ var maxIdx = idx + maxBytesToRead / 2;
+ while (!(idx >= maxIdx) && HEAPU16[idx >>> 0]) ++idx;
+ endPtr = idx << 1;
+ if (endPtr - ptr > 32 && UTF16Decoder) {
+  return UTF16Decoder.decode(HEAPU8.subarray(ptr >>> 0, endPtr >>> 0));
+ } else {
+  var i = 0;
+  var str = "";
+  while (1) {
+   var codeUnit = HEAP16[ptr + i * 2 >>> 1];
+   if (codeUnit == 0 || i == maxBytesToRead / 2) return str;
+   ++i;
+   str += String.fromCharCode(codeUnit);
+  }
+ }
+}
+
+function stringToUTF16(str, outPtr, maxBytesToWrite) {
+ if (maxBytesToWrite === undefined) {
+  maxBytesToWrite = 2147483647;
+ }
+ if (maxBytesToWrite < 2) return 0;
+ maxBytesToWrite -= 2;
+ var startPtr = outPtr;
+ var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
+ for (var i = 0; i < numCharsToWrite; ++i) {
+  var codeUnit = str.charCodeAt(i);
+  HEAP16[outPtr >>> 1] = codeUnit;
+  outPtr += 2;
+ }
+ HEAP16[outPtr >>> 1] = 0;
+ return outPtr - startPtr;
+}
+
+function lengthBytesUTF16(str) {
+ return str.length * 2;
+}
+
+function UTF32ToString(ptr, maxBytesToRead) {
+ var i = 0;
+ var str = "";
+ while (!(i >= maxBytesToRead / 4)) {
+  var utf32 = HEAP32[ptr + i * 4 >>> 2];
+  if (utf32 == 0) break;
+  ++i;
+  if (utf32 >= 65536) {
+   var ch = utf32 - 65536;
+   str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+  } else {
+   str += String.fromCharCode(utf32);
+  }
+ }
+ return str;
+}
+
+function stringToUTF32(str, outPtr, maxBytesToWrite) {
+ outPtr >>>= 0;
+ if (maxBytesToWrite === undefined) {
+  maxBytesToWrite = 2147483647;
+ }
+ if (maxBytesToWrite < 4) return 0;
+ var startPtr = outPtr;
+ var endPtr = startPtr + maxBytesToWrite - 4;
+ for (var i = 0; i < str.length; ++i) {
+  var codeUnit = str.charCodeAt(i);
+  if (codeUnit >= 55296 && codeUnit <= 57343) {
+   var trailSurrogate = str.charCodeAt(++i);
+   codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
+  }
+  HEAP32[outPtr >>> 2] = codeUnit;
+  outPtr += 4;
+  if (outPtr + 4 > endPtr) break;
+ }
+ HEAP32[outPtr >>> 2] = 0;
+ return outPtr - startPtr;
+}
+
+function lengthBytesUTF32(str) {
+ var len = 0;
+ for (var i = 0; i < str.length; ++i) {
+  var codeUnit = str.charCodeAt(i);
+  if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
+  len += 4;
+ }
+ return len;
+}
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+ for (var i = 0; i < str.length; ++i) {
+  HEAP8[buffer++ >>> 0] = str.charCodeAt(i);
+ }
+ if (!dontAddNull) HEAP8[buffer >>> 0] = 0;
+}
+
+var WASM_PAGE_SIZE = 65536;
+
+function alignUp(x, multiple) {
+ if (x % multiple > 0) {
+  x += multiple - x % multiple;
+ }
+ return x;
+}
+
+var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+function updateGlobalBufferAndViews(buf) {
+ buffer = buf;
+ Module["HEAP8"] = HEAP8 = new Int8Array(buf);
+ Module["HEAP16"] = HEAP16 = new Int16Array(buf);
+ Module["HEAP32"] = HEAP32 = new Int32Array(buf);
+ Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
+ Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
+ Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
+ Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
+ Module["HEAPF64"] = HEAPF64 = new Float64Array(buf);
+}
+
+var DYNAMIC_BASE = 5475088, DYNAMICTOP_PTR = 232048;
+
+var INITIAL_INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
+
+if (Module["wasmMemory"]) {
+ wasmMemory = Module["wasmMemory"];
+} else {
+ wasmMemory = new WebAssembly.Memory({
+  "initial": INITIAL_INITIAL_MEMORY / WASM_PAGE_SIZE,
+  "maximum": 4294967296 / WASM_PAGE_SIZE
+ });
+}
+
+if (wasmMemory) {
+ buffer = wasmMemory.buffer;
+}
+
+INITIAL_INITIAL_MEMORY = buffer.byteLength;
+
+updateGlobalBufferAndViews(buffer);
+
+HEAP32[DYNAMICTOP_PTR >>> 2] = DYNAMIC_BASE;
+
+function callRuntimeCallbacks(callbacks) {
+ while (callbacks.length > 0) {
+  var callback = callbacks.shift();
+  if (typeof callback == "function") {
+   callback(Module);
+   continue;
+  }
+  var func = callback.func;
+  if (typeof func === "number") {
+   if (callback.arg === undefined) {
+    Module["dynCall_v"](func);
+   } else {
+    Module["dynCall_vi"](func, callback.arg);
+   }
+  } else {
+   func(callback.arg === undefined ? null : callback.arg);
+  }
+ }
+}
+
+var __ATPRERUN__ = [];
+
+var __ATINIT__ = [];
+
+var __ATMAIN__ = [];
+
+var __ATPOSTRUN__ = [];
+
+var runtimeInitialized = false;
+
+function preRun() {
+ if (Module["preRun"]) {
+  if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
+  while (Module["preRun"].length) {
+   addOnPreRun(Module["preRun"].shift());
+  }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function initRuntime() {
+ runtimeInitialized = true;
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function postRun() {
+ if (Module["postRun"]) {
+  if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ];
+  while (Module["postRun"].length) {
+   addOnPostRun(Module["postRun"].shift());
+  }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+
+var Math_ceil = Math.ceil;
+
+var Math_floor = Math.floor;
+
+var runDependencies = 0;
+
+var runDependencyWatcher = null;
+
+var dependenciesFulfilled = null;
+
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module["monitorRunDependencies"]) {
+  Module["monitorRunDependencies"](runDependencies);
+ }
+}
+
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module["monitorRunDependencies"]) {
+  Module["monitorRunDependencies"](runDependencies);
+ }
+ if (runDependencies == 0) {
+  if (runDependencyWatcher !== null) {
+   clearInterval(runDependencyWatcher);
+   runDependencyWatcher = null;
+  }
+  if (dependenciesFulfilled) {
+   var callback = dependenciesFulfilled;
+   dependenciesFulfilled = null;
+   callback();
+  }
+ }
+}
+
+Module["preloadedImages"] = {};
+
+Module["preloadedAudios"] = {};
+
+function abort(what) {
+ if (Module["onAbort"]) {
+  Module["onAbort"](what);
+ }
+ what += "";
+ err(what);
+ ABORT = true;
+ EXITSTATUS = 1;
+ what = "abort(" + what + "). Build with -s ASSERTIONS=1 for more info.";
+ var e = new WebAssembly.RuntimeError(what);
+ readyPromiseReject(e);
+ throw e;
+}
+
+function hasPrefix(str, prefix) {
+ return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0;
+}
+
+var dataURIPrefix = "data:application/octet-stream;base64,";
+
+function isDataURI(filename) {
+ return hasPrefix(filename, dataURIPrefix);
+}
+
+var fileURIPrefix = "file://";
+
+function isFileURI(filename) {
+ return hasPrefix(filename, fileURIPrefix);
+}
+
+var wasmBinaryFile = "jxl_dec.wasm";
+
+if (!isDataURI(wasmBinaryFile)) {
+ wasmBinaryFile = locateFile(wasmBinaryFile);
+}
+
+function getBinary() {
+ try {
+  if (wasmBinary) {
+   return new Uint8Array(wasmBinary);
+  }
+  if (readBinary) {
+   return readBinary(wasmBinaryFile);
+  } else {
+   throw "both async and sync fetching of the wasm failed";
+  }
+ } catch (err) {
+  abort(err);
+ }
+}
+
+function getBinaryPromise() {
+ if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function" && !isFileURI(wasmBinaryFile)) {
+  return fetch(wasmBinaryFile, {
+   credentials: "same-origin"
+  }).then(function(response) {
+   if (!response["ok"]) {
+    throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
+   }
+   return response["arrayBuffer"]();
+  }).catch(function() {
+   return getBinary();
+  });
+ }
+ return new Promise(function(resolve, reject) {
+  resolve(getBinary());
+ });
+}
+
+function createWasm() {
+ var info = {
+  "a": asmLibraryArg
+ };
+ function receiveInstance(instance, module) {
+  var exports = instance.exports;
+  Module["asm"] = exports;
+  removeRunDependency("wasm-instantiate");
+ }
+ addRunDependency("wasm-instantiate");
+ function receiveInstantiatedSource(output) {
+  receiveInstance(output["instance"]);
+ }
+ function instantiateArrayBuffer(receiver) {
+  return getBinaryPromise().then(function(binary) {
+   return WebAssembly.instantiate(binary, info);
+  }).then(receiver, function(reason) {
+   err("failed to asynchronously prepare wasm: " + reason);
+   abort(reason);
+  });
+ }
+ function instantiateAsync() {
+  if (!wasmBinary && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && !isFileURI(wasmBinaryFile) && typeof fetch === "function") {
+   fetch(wasmBinaryFile, {
+    credentials: "same-origin"
+   }).then(function(response) {
+    var result = WebAssembly.instantiateStreaming(response, info);
+    return result.then(receiveInstantiatedSource, function(reason) {
+     err("wasm streaming compile failed: " + reason);
+     err("falling back to ArrayBuffer instantiation");
+     return instantiateArrayBuffer(receiveInstantiatedSource);
+    });
+   });
+  } else {
+   return instantiateArrayBuffer(receiveInstantiatedSource);
+  }
+ }
+ if (Module["instantiateWasm"]) {
+  try {
+   var exports = Module["instantiateWasm"](info, receiveInstance);
+   return exports;
+  } catch (e) {
+   err("Module.instantiateWasm callback failed with error: " + e);
+   return false;
+  }
+ }
+ instantiateAsync();
+ return {};
+}
+
+__ATINIT__.push({
+ func: function() {
+  ___wasm_call_ctors();
+ }
+});
+
+function ___cxa_allocate_exception(size) {
+ return _malloc(size);
+}
+
+function _atexit(func, arg) {}
+
+function ___cxa_thread_atexit(a0, a1) {
+ return _atexit(a0, a1);
+}
+
+var exceptionInfos = {};
+
+var exceptionLast = 0;
+
+function __ZSt18uncaught_exceptionv() {
+ return __ZSt18uncaught_exceptionv.uncaught_exceptions > 0;
+}
+
+function ___cxa_throw(ptr, type, destructor) {
+ exceptionInfos[ptr] = {
+  ptr: ptr,
+  adjusted: [ ptr ],
+  type: type,
+  destructor: destructor,
+  refcount: 0,
+  caught: false,
+  rethrown: false
+ };
+ exceptionLast = ptr;
+ if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) {
+  __ZSt18uncaught_exceptionv.uncaught_exceptions = 1;
+ } else {
+  __ZSt18uncaught_exceptionv.uncaught_exceptions++;
+ }
+ throw ptr;
+}
+
+function getShiftFromSize(size) {
+ switch (size) {
+ case 1:
+  return 0;
+
+ case 2:
+  return 1;
+
+ case 4:
+  return 2;
+
+ case 8:
+  return 3;
+
+ default:
+  throw new TypeError("Unknown type size: " + size);
+ }
+}
+
+function embind_init_charCodes() {
+ var codes = new Array(256);
+ for (var i = 0; i < 256; ++i) {
+  codes[i] = String.fromCharCode(i);
+ }
+ embind_charCodes = codes;
+}
+
+var embind_charCodes = undefined;
+
+function readLatin1String(ptr) {
+ var ret = "";
+ var c = ptr;
+ while (HEAPU8[c >>> 0]) {
+  ret += embind_charCodes[HEAPU8[c++ >>> 0]];
+ }
+ return ret;
+}
+
+var awaitingDependencies = {};
+
+var registeredTypes = {};
+
+var typeDependencies = {};
+
+var char_0 = 48;
+
+var char_9 = 57;
+
+function makeLegalFunctionName(name) {
+ if (undefined === name) {
+  return "_unknown";
+ }
+ name = name.replace(/[^a-zA-Z0-9_]/g, "$");
+ var f = name.charCodeAt(0);
+ if (f >= char_0 && f <= char_9) {
+  return "_" + name;
+ } else {
+  return name;
+ }
+}
+
+function createNamedFunction(name, body) {
+ name = makeLegalFunctionName(name);
+ return new Function("body", "return function " + name + "() {\n" + '    "use strict";' + "    return body.apply(this, arguments);\n" + "};\n")(body);
+}
+
+function extendError(baseErrorType, errorName) {
+ var errorClass = createNamedFunction(errorName, function(message) {
+  this.name = errorName;
+  this.message = message;
+  var stack = new Error(message).stack;
+  if (stack !== undefined) {
+   this.stack = this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, "");
+  }
+ });
+ errorClass.prototype = Object.create(baseErrorType.prototype);
+ errorClass.prototype.constructor = errorClass;
+ errorClass.prototype.toString = function() {
+  if (this.message === undefined) {
+   return this.name;
+  } else {
+   return this.name + ": " + this.message;
+  }
+ };
+ return errorClass;
+}
+
+var BindingError = undefined;
+
+function throwBindingError(message) {
+ throw new BindingError(message);
+}
+
+var InternalError = undefined;
+
+function throwInternalError(message) {
+ throw new InternalError(message);
+}
+
+function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {
+ myTypes.forEach(function(type) {
+  typeDependencies[type] = dependentTypes;
+ });
+ function onComplete(typeConverters) {
+  var myTypeConverters = getTypeConverters(typeConverters);
+  if (myTypeConverters.length !== myTypes.length) {
+   throwInternalError("Mismatched type converter count");
+  }
+  for (var i = 0; i < myTypes.length; ++i) {
+   registerType(myTypes[i], myTypeConverters[i]);
+  }
+ }
+ var typeConverters = new Array(dependentTypes.length);
+ var unregisteredTypes = [];
+ var registered = 0;
+ dependentTypes.forEach(function(dt, i) {
+  if (registeredTypes.hasOwnProperty(dt)) {
+   typeConverters[i] = registeredTypes[dt];
+  } else {
+   unregisteredTypes.push(dt);
+   if (!awaitingDependencies.hasOwnProperty(dt)) {
+    awaitingDependencies[dt] = [];
+   }
+   awaitingDependencies[dt].push(function() {
+    typeConverters[i] = registeredTypes[dt];
+    ++registered;
+    if (registered === unregisteredTypes.length) {
+     onComplete(typeConverters);
+    }
+   });
+  }
+ });
+ if (0 === unregisteredTypes.length) {
+  onComplete(typeConverters);
+ }
+}
+
+function registerType(rawType, registeredInstance, options) {
+ options = options || {};
+ if (!("argPackAdvance" in registeredInstance)) {
+  throw new TypeError("registerType registeredInstance requires argPackAdvance");
+ }
+ var name = registeredInstance.name;
+ if (!rawType) {
+  throwBindingError('type "' + name + '" must have a positive integer typeid pointer');
+ }
+ if (registeredTypes.hasOwnProperty(rawType)) {
+  if (options.ignoreDuplicateRegistrations) {
+   return;
+  } else {
+   throwBindingError("Cannot register type '" + name + "' twice");
+  }
+ }
+ registeredTypes[rawType] = registeredInstance;
+ delete typeDependencies[rawType];
+ if (awaitingDependencies.hasOwnProperty(rawType)) {
+  var callbacks = awaitingDependencies[rawType];
+  delete awaitingDependencies[rawType];
+  callbacks.forEach(function(cb) {
+   cb();
+  });
+ }
+}
+
+function __embind_register_bool(rawType, name, size, trueValue, falseValue) {
+ var shift = getShiftFromSize(size);
+ name = readLatin1String(name);
+ registerType(rawType, {
+  name: name,
+  "fromWireType": function(wt) {
+   return !!wt;
+  },
+  "toWireType": function(destructors, o) {
+   return o ? trueValue : falseValue;
+  },
+  "argPackAdvance": 8,
+  "readValueFromPointer": function(pointer) {
+   var heap;
+   if (size === 1) {
+    heap = HEAP8;
+   } else if (size === 2) {
+    heap = HEAP16;
+   } else if (size === 4) {
+    heap = HEAP32;
+   } else {
+    throw new TypeError("Unknown boolean type size: " + name);
+   }
+   return this["fromWireType"](heap[pointer >>> shift]);
+  },
+  destructorFunction: null
+ });
+}
+
+var emval_free_list = [];
+
+var emval_handle_array = [ {}, {
+ value: undefined
+}, {
+ value: null
+}, {
+ value: true
+}, {
+ value: false
+} ];
+
+function __emval_decref(handle) {
+ if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
+  emval_handle_array[handle] = undefined;
+  emval_free_list.push(handle);
+ }
+}
+
+function count_emval_handles() {
+ var count = 0;
+ for (var i = 5; i < emval_handle_array.length; ++i) {
+  if (emval_handle_array[i] !== undefined) {
+   ++count;
+  }
+ }
+ return count;
+}
+
+function get_first_emval() {
+ for (var i = 5; i < emval_handle_array.length; ++i) {
+  if (emval_handle_array[i] !== undefined) {
+   return emval_handle_array[i];
+  }
+ }
+ return null;
+}
+
+function init_emval() {
+ Module["count_emval_handles"] = count_emval_handles;
+ Module["get_first_emval"] = get_first_emval;
+}
+
+function __emval_register(value) {
+ switch (value) {
+ case undefined:
+  {
+   return 1;
+  }
+
+ case null:
+  {
+   return 2;
+  }
+
+ case true:
+  {
+   return 3;
+  }
+
+ case false:
+  {
+   return 4;
+  }
+
+ default:
+  {
+   var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length;
+   emval_handle_array[handle] = {
+    refcount: 1,
+    value: value
+   };
+   return handle;
+  }
+ }
+}
+
+function simpleReadValueFromPointer(pointer) {
+ return this["fromWireType"](HEAPU32[pointer >>> 2]);
+}
+
+function __embind_register_emval(rawType, name) {
+ name = readLatin1String(name);
+ registerType(rawType, {
+  name: name,
+  "fromWireType": function(handle) {
+   var rv = emval_handle_array[handle].value;
+   __emval_decref(handle);
+   return rv;
+  },
+  "toWireType": function(destructors, value) {
+   return __emval_register(value);
+  },
+  "argPackAdvance": 8,
+  "readValueFromPointer": simpleReadValueFromPointer,
+  destructorFunction: null
+ });
+}
+
+function _embind_repr(v) {
+ if (v === null) {
+  return "null";
+ }
+ var t = typeof v;
+ if (t === "object" || t === "array" || t === "function") {
+  return v.toString();
+ } else {
+  return "" + v;
+ }
+}
+
+function floatReadValueFromPointer(name, shift) {
+ switch (shift) {
+ case 2:
+  return function(pointer) {
+   return this["fromWireType"](HEAPF32[pointer >>> 2]);
+  };
+
+ case 3:
+  return function(pointer) {
+   return this["fromWireType"](HEAPF64[pointer >>> 3]);
+  };
+
+ default:
+  throw new TypeError("Unknown float type: " + name);
+ }
+}
+
+function __embind_register_float(rawType, name, size) {
+ var shift = getShiftFromSize(size);
+ name = readLatin1String(name);
+ registerType(rawType, {
+  name: name,
+  "fromWireType": function(value) {
+   return value;
+  },
+  "toWireType": function(destructors, value) {
+   if (typeof value !== "number" && typeof value !== "boolean") {
+    throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);
+   }
+   return value;
+  },
+  "argPackAdvance": 8,
+  "readValueFromPointer": floatReadValueFromPointer(name, shift),
+  destructorFunction: null
+ });
+}
+
+function new_(constructor, argumentList) {
+ if (!(constructor instanceof Function)) {
+  throw new TypeError("new_ called with constructor type " + typeof constructor + " which is not a function");
+ }
+ var dummy = createNamedFunction(constructor.name || "unknownFunctionName", function() {});
+ dummy.prototype = constructor.prototype;
+ var obj = new dummy();
+ var r = constructor.apply(obj, argumentList);
+ return r instanceof Object ? r : obj;
+}
+
+function runDestructors(destructors) {
+ while (destructors.length) {
+  var ptr = destructors.pop();
+  var del = destructors.pop();
+  del(ptr);
+ }
+}
+
+function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) {
+ var argCount = argTypes.length;
+ if (argCount < 2) {
+  throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
+ }
+ var isClassMethodFunc = argTypes[1] !== null && classType !== null;
+ var needsDestructorStack = false;
+ for (var i = 1; i < argTypes.length; ++i) {
+  if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
+   needsDestructorStack = true;
+   break;
+  }
+ }
+ var returns = argTypes[0].name !== "void";
+ var argsList = "";
+ var argsListWired = "";
+ for (var i = 0; i < argCount - 2; ++i) {
+  argsList += (i !== 0 ? ", " : "") + "arg" + i;
+  argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired";
+ }
+ var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\n" + "if (arguments.length !== " + (argCount - 2) + ") {\n" + "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" + "}\n";
+ if (needsDestructorStack) {
+  invokerFnBody += "var destructors = [];\n";
+ }
+ var dtorStack = needsDestructorStack ? "destructors" : "null";
+ var args1 = [ "throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam" ];
+ var args2 = [ throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1] ];
+ if (isClassMethodFunc) {
+  invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n";
+ }
+ for (var i = 0; i < argCount - 2; ++i) {
+  invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n";
+  args1.push("argType" + i);
+  args2.push(argTypes[i + 2]);
+ }
+ if (isClassMethodFunc) {
+  argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired;
+ }
+ invokerFnBody += (returns ? "var rv = " : "") + "invoker(fn" + (argsListWired.length > 0 ? ", " : "") + argsListWired + ");\n";
+ if (needsDestructorStack) {
+  invokerFnBody += "runDestructors(destructors);\n";
+ } else {
+  for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
+   var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
+   if (argTypes[i].destructorFunction !== null) {
+    invokerFnBody += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n";
+    args1.push(paramName + "_dtor");
+    args2.push(argTypes[i].destructorFunction);
+   }
+  }
+ }
+ if (returns) {
+  invokerFnBody += "var ret = retType.fromWireType(rv);\n" + "return ret;\n";
+ } else {}
+ invokerFnBody += "}\n";
+ args1.push(invokerFnBody);
+ var invokerFunction = new_(Function, args1).apply(null, args2);
+ return invokerFunction;
+}
+
+function ensureOverloadTable(proto, methodName, humanName) {
+ if (undefined === proto[methodName].overloadTable) {
+  var prevFunc = proto[methodName];
+  proto[methodName] = function() {
+   if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
+    throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!");
+   }
+   return proto[methodName].overloadTable[arguments.length].apply(this, arguments);
+  };
+  proto[methodName].overloadTable = [];
+  proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
+ }
+}
+
+function exposePublicSymbol(name, value, numArguments) {
+ if (Module.hasOwnProperty(name)) {
+  if (undefined === numArguments || undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments]) {
+   throwBindingError("Cannot register public name '" + name + "' twice");
+  }
+  ensureOverloadTable(Module, name, name);
+  if (Module.hasOwnProperty(numArguments)) {
+   throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!");
+  }
+  Module[name].overloadTable[numArguments] = value;
+ } else {
+  Module[name] = value;
+  if (undefined !== numArguments) {
+   Module[name].numArguments = numArguments;
+  }
+ }
+}
+
+function heap32VectorToArray(count, firstElement) {
+ var array = [];
+ for (var i = 0; i < count; i++) {
+  array.push(HEAP32[(firstElement >> 2) + i >>> 0]);
+ }
+ return array;
+}
+
+function replacePublicSymbol(name, value, numArguments) {
+ if (!Module.hasOwnProperty(name)) {
+  throwInternalError("Replacing nonexistant public symbol");
+ }
+ if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
+  Module[name].overloadTable[numArguments] = value;
+ } else {
+  Module[name] = value;
+  Module[name].argCount = numArguments;
+ }
+}
+
+function embind__requireFunction(signature, rawFunction) {
+ signature = readLatin1String(signature);
+ function makeDynCaller(dynCall) {
+  var args = [];
+  for (var i = 1; i < signature.length; ++i) {
+   args.push("a" + i);
+  }
+  var name = "dynCall_" + signature + "_" + rawFunction;
+  var body = "return function " + name + "(" + args.join(", ") + ") {\n";
+  body += "    return dynCall(rawFunction" + (args.length ? ", " : "") + args.join(", ") + ");\n";
+  body += "};\n";
+  return new Function("dynCall", "rawFunction", body)(dynCall, rawFunction);
+ }
+ var dc = Module["dynCall_" + signature];
+ var fp = makeDynCaller(dc);
+ if (typeof fp !== "function") {
+  throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction);
+ }
+ return fp;
+}
+
+var UnboundTypeError = undefined;
+
+function getTypeName(type) {
+ var ptr = ___getTypeName(type);
+ var rv = readLatin1String(ptr);
+ _free(ptr);
+ return rv;
+}
+
+function throwUnboundTypeError(message, types) {
+ var unboundTypes = [];
+ var seen = {};
+ function visit(type) {
+  if (seen[type]) {
+   return;
+  }
+  if (registeredTypes[type]) {
+   return;
+  }
+  if (typeDependencies[type]) {
+   typeDependencies[type].forEach(visit);
+   return;
+  }
+  unboundTypes.push(type);
+  seen[type] = true;
+ }
+ types.forEach(visit);
+ throw new UnboundTypeError(message + ": " + unboundTypes.map(getTypeName).join([ ", " ]));
+}
+
+function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn) {
+ var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+ name = readLatin1String(name);
+ rawInvoker = embind__requireFunction(signature, rawInvoker);
+ exposePublicSymbol(name, function() {
+  throwUnboundTypeError("Cannot call " + name + " due to unbound types", argTypes);
+ }, argCount - 1);
+ whenDependentTypesAreResolved([], argTypes, function(argTypes) {
+  var invokerArgsArray = [ argTypes[0], null ].concat(argTypes.slice(1));
+  replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn), argCount - 1);
+  return [];
+ });
+}
+
+function integerReadValueFromPointer(name, shift, signed) {
+ switch (shift) {
+ case 0:
+  return signed ? function readS8FromPointer(pointer) {
+   return HEAP8[pointer >>> 0];
+  } : function readU8FromPointer(pointer) {
+   return HEAPU8[pointer >>> 0];
+  };
+
+ case 1:
+  return signed ? function readS16FromPointer(pointer) {
+   return HEAP16[pointer >>> 1];
+  } : function readU16FromPointer(pointer) {
+   return HEAPU16[pointer >>> 1];
+  };
+
+ case 2:
+  return signed ? function readS32FromPointer(pointer) {
+   return HEAP32[pointer >>> 2];
+  } : function readU32FromPointer(pointer) {
+   return HEAPU32[pointer >>> 2];
+  };
+
+ default:
+  throw new TypeError("Unknown integer type: " + name);
+ }
+}
+
+function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
+ name = readLatin1String(name);
+ if (maxRange === -1) {
+  maxRange = 4294967295;
+ }
+ var shift = getShiftFromSize(size);
+ var fromWireType = function(value) {
+  return value;
+ };
+ if (minRange === 0) {
+  var bitshift = 32 - 8 * size;
+  fromWireType = function(value) {
+   return value << bitshift >>> bitshift;
+  };
+ }
+ var isUnsignedType = name.indexOf("unsigned") != -1;
+ registerType(primitiveType, {
+  name: name,
+  "fromWireType": fromWireType,
+  "toWireType": function(destructors, value) {
+   if (typeof value !== "number" && typeof value !== "boolean") {
+    throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);
+   }
+   if (value < minRange || value > maxRange) {
+    throw new TypeError('Passing a number "' + _embind_repr(value) + '" from JS side to C/C++ side to an argument of type "' + name + '", which is outside the valid range [' + minRange + ", " + maxRange + "]!");
+   }
+   return isUnsignedType ? value >>> 0 : value | 0;
+  },
+  "argPackAdvance": 8,
+  "readValueFromPointer": integerReadValueFromPointer(name, shift, minRange !== 0),
+  destructorFunction: null
+ });
+}
+
+function __embind_register_memory_view(rawType, dataTypeIndex, name) {
+ var typeMapping = [ Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array ];
+ var TA = typeMapping[dataTypeIndex];
+ function decodeMemoryView(handle) {
+  handle = handle >> 2;
+  var heap = HEAPU32;
+  var size = heap[handle >>> 0];
+  var data = heap[handle + 1 >>> 0];
+  return new TA(buffer, data, size);
+ }
+ name = readLatin1String(name);
+ registerType(rawType, {
+  name: name,
+  "fromWireType": decodeMemoryView,
+  "argPackAdvance": 8,
+  "readValueFromPointer": decodeMemoryView
+ }, {
+  ignoreDuplicateRegistrations: true
+ });
+}
+
+function __embind_register_std_string(rawType, name) {
+ name = readLatin1String(name);
+ var stdStringIsUTF8 = name === "std::string";
+ registerType(rawType, {
+  name: name,
+  "fromWireType": function(value) {
+   var length = HEAPU32[value >>> 2];
+   var str;
+   if (stdStringIsUTF8) {
+    var decodeStartPtr = value + 4;
+    for (var i = 0; i <= length; ++i) {
+     var currentBytePtr = value + 4 + i;
+     if (i == length || HEAPU8[currentBytePtr >>> 0] == 0) {
+      var maxRead = currentBytePtr - decodeStartPtr;
+      var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
+      if (str === undefined) {
+       str = stringSegment;
+      } else {
+       str += String.fromCharCode(0);
+       str += stringSegment;
+      }
+      decodeStartPtr = currentBytePtr + 1;
+     }
+    }
+   } else {
+    var a = new Array(length);
+    for (var i = 0; i < length; ++i) {
+     a[i] = String.fromCharCode(HEAPU8[value + 4 + i >>> 0]);
+    }
+    str = a.join("");
+   }
+   _free(value);
+   return str;
+  },
+  "toWireType": function(destructors, value) {
+   if (value instanceof ArrayBuffer) {
+    value = new Uint8Array(value);
+   }
+   var getLength;
+   var valueIsOfTypeString = typeof value === "string";
+   if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) {
+    throwBindingError("Cannot pass non-string to std::string");
+   }
+   if (stdStringIsUTF8 && valueIsOfTypeString) {
+    getLength = function() {
+     return lengthBytesUTF8(value);
+    };
+   } else {
+    getLength = function() {
+     return value.length;
+    };
+   }
+   var length = getLength();
+   var ptr = _malloc(4 + length + 1);
+   ptr >>>= 0;
+   HEAPU32[ptr >>> 2] = length;
+   if (stdStringIsUTF8 && valueIsOfTypeString) {
+    stringToUTF8(value, ptr + 4, length + 1);
+   } else {
+    if (valueIsOfTypeString) {
+     for (var i = 0; i < length; ++i) {
+      var charCode = value.charCodeAt(i);
+      if (charCode > 255) {
+       _free(ptr);
+       throwBindingError("String has UTF-16 code units that do not fit in 8 bits");
+      }
+      HEAPU8[ptr + 4 + i >>> 0] = charCode;
+     }
+    } else {
+     for (var i = 0; i < length; ++i) {
+      HEAPU8[ptr + 4 + i >>> 0] = value[i];
+     }
+    }
+   }
+   if (destructors !== null) {
+    destructors.push(_free, ptr);
+   }
+   return ptr;
+  },
+  "argPackAdvance": 8,
+  "readValueFromPointer": simpleReadValueFromPointer,
+  destructorFunction: function(ptr) {
+   _free(ptr);
+  }
+ });
+}
+
+function __embind_register_std_wstring(rawType, charSize, name) {
+ name = readLatin1String(name);
+ var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
+ if (charSize === 2) {
+  decodeString = UTF16ToString;
+  encodeString = stringToUTF16;
+  lengthBytesUTF = lengthBytesUTF16;
+  getHeap = function() {
+   return HEAPU16;
+  };
+  shift = 1;
+ } else if (charSize === 4) {
+  decodeString = UTF32ToString;
+  encodeString = stringToUTF32;
+  lengthBytesUTF = lengthBytesUTF32;
+  getHeap = function() {
+   return HEAPU32;
+  };
+  shift = 2;
+ }
+ registerType(rawType, {
+  name: name,
+  "fromWireType": function(value) {
+   var length = HEAPU32[value >>> 2];
+   var HEAP = getHeap();
+   var str;
+   var decodeStartPtr = value + 4;
+   for (var i = 0; i <= length; ++i) {
+    var currentBytePtr = value + 4 + i * charSize;
+    if (i == length || HEAP[currentBytePtr >>> shift] == 0) {
+     var maxReadBytes = currentBytePtr - decodeStartPtr;
+     var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
+     if (str === undefined) {
+      str = stringSegment;
+     } else {
+      str += String.fromCharCode(0);
+      str += stringSegment;
+     }
+     decodeStartPtr = currentBytePtr + charSize;
+    }
+   }
+   _free(value);
+   return str;
+  },
+  "toWireType": function(destructors, value) {
+   if (!(typeof value === "string")) {
+    throwBindingError("Cannot pass non-string to C++ string type " + name);
+   }
+   var length = lengthBytesUTF(value);
+   var ptr = _malloc(4 + length + charSize);
+   ptr >>>= 0;
+   HEAPU32[ptr >>> 2] = length >> shift;
+   encodeString(value, ptr + 4, length + charSize);
+   if (destructors !== null) {
+    destructors.push(_free, ptr);
+   }
+   return ptr;
+  },
+  "argPackAdvance": 8,
+  "readValueFromPointer": simpleReadValueFromPointer,
+  destructorFunction: function(ptr) {
+   _free(ptr);
+  }
+ });
+}
+
+function __embind_register_void(rawType, name) {
+ name = readLatin1String(name);
+ registerType(rawType, {
+  isVoid: true,
+  name: name,
+  "argPackAdvance": 0,
+  "fromWireType": function() {
+   return undefined;
+  },
+  "toWireType": function(destructors, o) {
+   return undefined;
+  }
+ });
+}
+
+var emval_symbols = {};
+
+function getStringOrSymbol(address) {
+ var symbol = emval_symbols[address];
+ if (symbol === undefined) {
+  return readLatin1String(address);
+ } else {
+  return symbol;
+ }
+}
+
+function emval_get_global() {
+ if (typeof globalThis === "object") {
+  return globalThis;
+ }
+ return function() {
+  return Function;
+ }()("return this")();
+}
+
+function __emval_get_global(name) {
+ if (name === 0) {
+  return __emval_register(emval_get_global());
+ } else {
+  name = getStringOrSymbol(name);
+  return __emval_register(emval_get_global()[name]);
+ }
+}
+
+function __emval_incref(handle) {
+ if (handle > 4) {
+  emval_handle_array[handle].refcount += 1;
+ }
+}
+
+function requireRegisteredType(rawType, humanName) {
+ var impl = registeredTypes[rawType];
+ if (undefined === impl) {
+  throwBindingError(humanName + " has unknown type " + getTypeName(rawType));
+ }
+ return impl;
+}
+
+function craftEmvalAllocator(argCount) {
+ var argsList = "";
+ for (var i = 0; i < argCount; ++i) {
+  argsList += (i !== 0 ? ", " : "") + "arg" + i;
+ }
+ var functionBody = "return function emval_allocator_" + argCount + "(constructor, argTypes, args) {\n";
+ for (var i = 0; i < argCount; ++i) {
+  functionBody += "var argType" + i + " = requireRegisteredType(Module['HEAP32'][(argTypes >>> 2) + " + i + '], "parameter ' + i + '");\n' + "var arg" + i + " = argType" + i + ".readValueFromPointer(args);\n" + "args += argType" + i + "['argPackAdvance'];\n";
+ }
+ functionBody += "var obj = new constructor(" + argsList + ");\n" + "return __emval_register(obj);\n" + "}\n";
+ return new Function("requireRegisteredType", "Module", "__emval_register", functionBody)(requireRegisteredType, Module, __emval_register);
+}
+
+var emval_newers = {};
+
+function requireHandle(handle) {
+ if (!handle) {
+  throwBindingError("Cannot use deleted val. handle = " + handle);
+ }
+ return emval_handle_array[handle].value;
+}
+
+function __emval_new(handle, argCount, argTypes, args) {
+ handle = requireHandle(handle);
+ var newer = emval_newers[argCount];
+ if (!newer) {
+  newer = craftEmvalAllocator(argCount);
+  emval_newers[argCount] = newer;
+ }
+ return newer(handle, argTypes, args);
+}
+
+function _abort() {
+ abort();
+}
+
+function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.copyWithin(dest >>> 0, src >>> 0, src + num >>> 0);
+}
+
+function _emscripten_get_heap_size() {
+ return HEAPU8.length;
+}
+
+function emscripten_realloc_buffer(size) {
+ try {
+  wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);
+  updateGlobalBufferAndViews(wasmMemory.buffer);
+  return 1;
+ } catch (e) {}
+}
+
+function _emscripten_resize_heap(requestedSize) {
+ requestedSize = requestedSize >>> 0;
+ var oldSize = _emscripten_get_heap_size();
+ var PAGE_MULTIPLE = 65536;
+ var maxHeapSize = 4294967296;
+ if (requestedSize > maxHeapSize) {
+  return false;
+ }
+ var minHeapSize = 16777216;
+ for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+  var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+  overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+  var newSize = Math.min(maxHeapSize, alignUp(Math.max(minHeapSize, requestedSize, overGrownHeapSize), PAGE_MULTIPLE));
+  var replacement = emscripten_realloc_buffer(newSize);
+  if (replacement) {
+   return true;
+  }
+ }
+ return false;
+}
+
+var ENV = {};
+
+function getExecutableName() {
+ return thisProgram || "./this.program";
+}
+
+function getEnvStrings() {
+ if (!getEnvStrings.strings) {
+  var lang = (typeof navigator === "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8";
+  var env = {
+   "USER": "web_user",
+   "LOGNAME": "web_user",
+   "PATH": "/",
+   "PWD": "/",
+   "HOME": "/home/web_user",
+   "LANG": lang,
+   "_": getExecutableName()
+  };
+  for (var x in ENV) {
+   env[x] = ENV[x];
+  }
+  var strings = [];
+  for (var x in env) {
+   strings.push(x + "=" + env[x]);
+  }
+  getEnvStrings.strings = strings;
+ }
+ return getEnvStrings.strings;
+}
+
+function _environ_get(__environ, environ_buf) {
+ var bufSize = 0;
+ getEnvStrings().forEach(function(string, i) {
+  var ptr = environ_buf + bufSize;
+  HEAP32[__environ + i * 4 >>> 2] = ptr;
+  writeAsciiToMemory(string, ptr);
+  bufSize += string.length + 1;
+ });
+ return 0;
+}
+
+function _environ_sizes_get(penviron_count, penviron_buf_size) {
+ var strings = getEnvStrings();
+ HEAP32[penviron_count >>> 2] = strings.length;
+ var bufSize = 0;
+ strings.forEach(function(string) {
+  bufSize += string.length + 1;
+ });
+ HEAP32[penviron_buf_size >>> 2] = bufSize;
+ return 0;
+}
+
+var PATH = {
+ splitPath: function(filename) {
+  var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+  return splitPathRe.exec(filename).slice(1);
+ },
+ normalizeArray: function(parts, allowAboveRoot) {
+  var up = 0;
+  for (var i = parts.length - 1; i >= 0; i--) {
+   var last = parts[i];
+   if (last === ".") {
+    parts.splice(i, 1);
+   } else if (last === "..") {
+    parts.splice(i, 1);
+    up++;
+   } else if (up) {
+    parts.splice(i, 1);
+    up--;
+   }
+  }
+  if (allowAboveRoot) {
+   for (;up; up--) {
+    parts.unshift("..");
+   }
+  }
+  return parts;
+ },
+ normalize: function(path) {
+  var isAbsolute = path.charAt(0) === "/", trailingSlash = path.substr(-1) === "/";
+  path = PATH.normalizeArray(path.split("/").filter(function(p) {
+   return !!p;
+  }), !isAbsolute).join("/");
+  if (!path && !isAbsolute) {
+   path = ".";
+  }
+  if (path && trailingSlash) {
+   path += "/";
+  }
+  return (isAbsolute ? "/" : "") + path;
+ },
+ dirname: function(path) {
+  var result = PATH.splitPath(path), root = result[0], dir = result[1];
+  if (!root && !dir) {
+   return ".";
+  }
+  if (dir) {
+   dir = dir.substr(0, dir.length - 1);
+  }
+  return root + dir;
+ },
+ basename: function(path) {
+  if (path === "/") return "/";
+  var lastSlash = path.lastIndexOf("/");
+  if (lastSlash === -1) return path;
+  return path.substr(lastSlash + 1);
+ },
+ extname: function(path) {
+  return PATH.splitPath(path)[3];
+ },
+ join: function() {
+  var paths = Array.prototype.slice.call(arguments, 0);
+  return PATH.normalize(paths.join("/"));
+ },
+ join2: function(l, r) {
+  return PATH.normalize(l + "/" + r);
+ }
+};
+
+var SYSCALLS = {
+ mappings: {},
+ buffers: [ null, [], [] ],
+ printChar: function(stream, curr) {
+  var buffer = SYSCALLS.buffers[stream];
+  if (curr === 0 || curr === 10) {
+   (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
+   buffer.length = 0;
+  } else {
+   buffer.push(curr);
+  }
+ },
+ varargs: undefined,
+ get: function() {
+  SYSCALLS.varargs += 4;
+  var ret = HEAP32[SYSCALLS.varargs - 4 >>> 2];
+  return ret;
+ },
+ getStr: function(ptr) {
+  var ret = UTF8ToString(ptr);
+  return ret;
+ },
+ get64: function(low, high) {
+  return low;
+ }
+};
+
+function _fd_close(fd) {
+ return 0;
+}
+
+function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {}
+
+function _fd_write(fd, iov, iovcnt, pnum) {
+ var num = 0;
+ for (var i = 0; i < iovcnt; i++) {
+  var ptr = HEAP32[iov + i * 8 >>> 2];
+  var len = HEAP32[iov + (i * 8 + 4) >>> 2];
+  for (var j = 0; j < len; j++) {
+   SYSCALLS.printChar(fd, HEAPU8[ptr + j >>> 0]);
+  }
+  num += len;
+ }
+ HEAP32[pnum >>> 2] = num;
+ return 0;
+}
+
+function _round(d) {
+ d = +d;
+ return d >= +0 ? +Math_floor(d + +.5) : +Math_ceil(d - +.5);
+}
+
+function _roundf(d) {
+ d = +d;
+ return d >= +0 ? +Math_floor(d + +.5) : +Math_ceil(d - +.5);
+}
+
+function _setTempRet0($i) {
+ setTempRet0($i | 0);
+}
+
+embind_init_charCodes();
+
+BindingError = Module["BindingError"] = extendError(Error, "BindingError");
+
+InternalError = Module["InternalError"] = extendError(Error, "InternalError");
+
+init_emval();
+
+UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError");
+
+var asmLibraryArg = {
+ "A": ___cxa_allocate_exception,
+ "l": ___cxa_thread_atexit,
+ "z": ___cxa_throw,
+ "v": __embind_register_bool,
+ "u": __embind_register_emval,
+ "j": __embind_register_float,
+ "t": __embind_register_function,
+ "b": __embind_register_integer,
+ "a": __embind_register_memory_view,
+ "i": __embind_register_std_string,
+ "d": __embind_register_std_wstring,
+ "s": __embind_register_void,
+ "r": __emval_decref,
+ "q": __emval_get_global,
+ "p": __emval_incref,
+ "h": __emval_new,
+ "g": _abort,
+ "o": _emscripten_memcpy_big,
+ "c": _emscripten_resize_heap,
+ "y": _environ_get,
+ "x": _environ_sizes_get,
+ "w": _fd_close,
+ "n": _fd_seek,
+ "k": _fd_write,
+ "memory": wasmMemory,
+ "f": _round,
+ "e": _roundf,
+ "m": _setTempRet0,
+ "table": wasmTable
+};
+
+var asm = createWasm();
+
+var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() {
+ return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["B"]).apply(null, arguments);
+};
+
+var _malloc = Module["_malloc"] = function() {
+ return (_malloc = Module["_malloc"] = Module["asm"]["C"]).apply(null, arguments);
+};
+
+var _free = Module["_free"] = function() {
+ return (_free = Module["_free"] = Module["asm"]["D"]).apply(null, arguments);
+};
+
+var ___getTypeName = Module["___getTypeName"] = function() {
+ return (___getTypeName = Module["___getTypeName"] = Module["asm"]["E"]).apply(null, arguments);
+};
+
+var ___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = function() {
+ return (___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = Module["asm"]["F"]).apply(null, arguments);
+};
+
+var dynCall_iii = Module["dynCall_iii"] = function() {
+ return (dynCall_iii = Module["dynCall_iii"] = Module["asm"]["G"]).apply(null, arguments);
+};
+
+var dynCall_vii = Module["dynCall_vii"] = function() {
+ return (dynCall_vii = Module["dynCall_vii"] = Module["asm"]["H"]).apply(null, arguments);
+};
+
+var dynCall_ii = Module["dynCall_ii"] = function() {
+ return (dynCall_ii = Module["dynCall_ii"] = Module["asm"]["I"]).apply(null, arguments);
+};
+
+var dynCall_vi = Module["dynCall_vi"] = function() {
+ return (dynCall_vi = Module["dynCall_vi"] = Module["asm"]["J"]).apply(null, arguments);
+};
+
+var dynCall_iidiiii = Module["dynCall_iidiiii"] = function() {
+ return (dynCall_iidiiii = Module["dynCall_iidiiii"] = Module["asm"]["K"]).apply(null, arguments);
+};
+
+var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = function() {
+ return (dynCall_iiiiiii = Module["dynCall_iiiiiii"] = Module["asm"]["L"]).apply(null, arguments);
+};
+
+var dynCall_viii = Module["dynCall_viii"] = function() {
+ return (dynCall_viii = Module["dynCall_viii"] = Module["asm"]["M"]).apply(null, arguments);
+};
+
+var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = function() {
+ return (dynCall_viiiiiii = Module["dynCall_viiiiiii"] = Module["asm"]["N"]).apply(null, arguments);
+};
+
+var dynCall_iiii = Module["dynCall_iiii"] = function() {
+ return (dynCall_iiii = Module["dynCall_iiii"] = Module["asm"]["O"]).apply(null, arguments);
+};
+
+var dynCall_v = Module["dynCall_v"] = function() {
+ return (dynCall_v = Module["dynCall_v"] = Module["asm"]["P"]).apply(null, arguments);
+};
+
+var dynCall_iiiii = Module["dynCall_iiiii"] = function() {
+ return (dynCall_iiiii = Module["dynCall_iiiii"] = Module["asm"]["Q"]).apply(null, arguments);
+};
+
+var dynCall_iiji = Module["dynCall_iiji"] = function() {
+ return (dynCall_iiji = Module["dynCall_iiji"] = Module["asm"]["R"]).apply(null, arguments);
+};
+
+var dynCall_iifi = Module["dynCall_iifi"] = function() {
+ return (dynCall_iifi = Module["dynCall_iifi"] = Module["asm"]["S"]).apply(null, arguments);
+};
+
+var dynCall_jiji = Module["dynCall_jiji"] = function() {
+ return (dynCall_jiji = Module["dynCall_jiji"] = Module["asm"]["T"]).apply(null, arguments);
+};
+
+var dynCall_viiiiii = Module["dynCall_viiiiii"] = function() {
+ return (dynCall_viiiiii = Module["dynCall_viiiiii"] = Module["asm"]["U"]).apply(null, arguments);
+};
+
+var dynCall_viiiii = Module["dynCall_viiiii"] = function() {
+ return (dynCall_viiiii = Module["dynCall_viiiii"] = Module["asm"]["V"]).apply(null, arguments);
+};
+
+var dynCall_viiii = Module["dynCall_viiii"] = function() {
+ return (dynCall_viiii = Module["dynCall_viiii"] = Module["asm"]["W"]).apply(null, arguments);
+};
+
+var calledRun;
+
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status;
+}
+
+dependenciesFulfilled = function runCaller() {
+ if (!calledRun) run();
+ if (!calledRun) dependenciesFulfilled = runCaller;
+};
+
+function run(args) {
+ args = args || arguments_;
+ if (runDependencies > 0) {
+  return;
+ }
+ preRun();
+ if (runDependencies > 0) return;
+ function doRun() {
+  if (calledRun) return;
+  calledRun = true;
+  Module["calledRun"] = true;
+  if (ABORT) return;
+  initRuntime();
+  preMain();
+  readyPromiseResolve(Module);
+  if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
+  postRun();
+ }
+ if (Module["setStatus"]) {
+  Module["setStatus"]("Running...");
+  setTimeout(function() {
+   setTimeout(function() {
+    Module["setStatus"]("");
+   }, 1);
+   doRun();
+  }, 1);
+ } else {
+  doRun();
+ }
+}
+
+Module["run"] = run;
+
+if (Module["preInit"]) {
+ if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
+ while (Module["preInit"].length > 0) {
+  Module["preInit"].pop()();
+ }
+}
+
+noExitRuntime = true;
+
+run();
 
 
   return jxl_dec.ready
diff --git a/codecs/jxl/dec/jxl_dec.wasm b/codecs/jxl/dec/jxl_dec.wasm
index 2e03312f..4ceef7ef 100644
Binary files a/codecs/jxl/dec/jxl_dec.wasm and b/codecs/jxl/dec/jxl_dec.wasm differ
diff --git a/codecs/jxl/enc/jxl_enc.js b/codecs/jxl/enc/jxl_enc.js
index bf5dae15..e1f90823 100644
--- a/codecs/jxl/enc/jxl_enc.js
+++ b/codecs/jxl/enc/jxl_enc.js
@@ -6,102 +6,4978 @@ var jxl_enc = (function() {
 function(jxl_enc) {
   jxl_enc = jxl_enc || {};
 
+var Module = typeof jxl_enc !== "undefined" ? jxl_enc : {};
 
-var f;f||(f=typeof jxl_enc !== 'undefined' ? jxl_enc : {});var aa,ba;f.ready=new Promise(function(a,b){aa=a;ba=b});var p={},t;for(t in f)f.hasOwnProperty(t)&&(p[t]=f[t]);var ca="./this.program",da=!1,w=!1,z=!1,ea=!1;da="object"===typeof window;w="function"===typeof importScripts;z="object"===typeof process&&"object"===typeof process.versions&&"string"===typeof process.versions.node;ea=!da&&!z&&!w;var A="",fa,ha,ia,ka;
-if(z)A=w?require("path").dirname(A)+"/":__dirname+"/",fa=function(a,b){ia||(ia=require("fs"));ka||(ka=require("path"));a=ka.normalize(a);return ia.readFileSync(a,b?null:"utf8")},ha=function(a){a=fa(a,!0);a.buffer||(a=new Uint8Array(a));assert(a.buffer);return a},1<process.argv.length&&(ca=process.argv[1].replace(/\\/g,"/")),process.argv.slice(2),process.on("uncaughtException",function(a){throw a;}),process.on("unhandledRejection",B),f.inspect=function(){return"[Emscripten Module object]"};else if(ea)"undefined"!=
-typeof read&&(fa=function(a){return read(a)}),ha=function(a){if("function"===typeof readbuffer)return new Uint8Array(readbuffer(a));a=read(a,"binary");assert("object"===typeof a);return a},"undefined"!==typeof print&&("undefined"===typeof console&&(console={}),console.log=print,console.warn=console.error="undefined"!==typeof printErr?printErr:print);else if(da||w)w?A=self.location.href:document.currentScript&&(A=document.currentScript.src),_scriptDir&&(A=_scriptDir),0!==A.indexOf("blob:")?A=A.substr(0,
-A.lastIndexOf("/")+1):A="",fa=function(a){var b=new XMLHttpRequest;b.open("GET",a,!1);b.send(null);return b.responseText},w&&(ha=function(a){var b=new XMLHttpRequest;b.open("GET",a,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)});var la=f.print||console.log.bind(console),C=f.printErr||console.warn.bind(console);for(t in p)p.hasOwnProperty(t)&&(f[t]=p[t]);p=null;f.thisProgram&&(ca=f.thisProgram);var ma;f.wasmBinary&&(ma=f.wasmBinary);var noExitRuntime;
-f.noExitRuntime&&(noExitRuntime=f.noExitRuntime);"object"!==typeof WebAssembly&&B("no native wasm support detected");var D,na=new WebAssembly.Table({initial:947,maximum:947,element:"anyfunc"}),oa=!1;function assert(a,b){a||B("Assertion failed: "+b)}var pa="undefined"!==typeof TextDecoder?new TextDecoder("utf8"):void 0;
-function qa(a,b,c){b>>>=0;var d=b+c;for(c=b;a[c>>>0]&&!(c>=d);)++c;if(16<c-b&&a.subarray&&pa)return pa.decode(a.subarray(b>>>0,c>>>0));for(d="";b<c;){var e=a[b++>>>0];if(e&128){var g=a[b++>>>0]&63;if(192==(e&224))d+=String.fromCharCode((e&31)<<6|g);else{var k=a[b++>>>0]&63;e=224==(e&240)?(e&15)<<12|g<<6|k:(e&7)<<18|g<<12|k<<6|a[b++>>>0]&63;65536>e?d+=String.fromCharCode(e):(e-=65536,d+=String.fromCharCode(55296|e>>10,56320|e&1023))}}else d+=String.fromCharCode(e)}return d}
-function ra(a,b){return(a>>>=0)?qa(E,a,b):""}
-function sa(a,b,c,d){c>>>=0;if(!(0<d))return 0;var e=c;d=c+d-1;for(var g=0;g<a.length;++g){var k=a.charCodeAt(g);if(55296<=k&&57343>=k){var m=a.charCodeAt(++g);k=65536+((k&1023)<<10)|m&1023}if(127>=k){if(c>=d)break;b[c++>>>0]=k}else{if(2047>=k){if(c+1>=d)break;b[c++>>>0]=192|k>>6}else{if(65535>=k){if(c+2>=d)break;b[c++>>>0]=224|k>>12}else{if(c+3>=d)break;b[c++>>>0]=240|k>>18;b[c++>>>0]=128|k>>12&63}b[c++>>>0]=128|k>>6&63}b[c++>>>0]=128|k&63}}b[c>>>0]=0;return c-e}
-function ta(a){for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);55296<=d&&57343>=d&&(d=65536+((d&1023)<<10)|a.charCodeAt(++c)&1023);127>=d?++b:b=2047>=d?b+2:65535>=d?b+3:b+4}return b}var ua="undefined"!==typeof TextDecoder?new TextDecoder("utf-16le"):void 0;function va(a,b){var c=a>>1;for(var d=c+b/2;!(c>=d)&&wa[c>>>0];)++c;c<<=1;if(32<c-a&&ua)return ua.decode(E.subarray(a>>>0,c>>>0));c=0;for(d="";;){var e=G[a+2*c>>1>>>0];if(0==e||c==b/2)return d;++c;d+=String.fromCharCode(e)}}
-function xa(a,b,c){void 0===c&&(c=2147483647);if(2>c)return 0;c-=2;var d=b;c=c<2*a.length?c/2:a.length;for(var e=0;e<c;++e)G[b>>1>>>0]=a.charCodeAt(e),b+=2;G[b>>1>>>0]=0;return b-d}function ya(a){return 2*a.length}function za(a,b){for(var c=0,d="";!(c>=b/4);){var e=H[a+4*c>>2>>>0];if(0==e)break;++c;65536<=e?(e-=65536,d+=String.fromCharCode(55296|e>>10,56320|e&1023)):d+=String.fromCharCode(e)}return d}
-function Aa(a,b,c){b>>>=0;void 0===c&&(c=2147483647);if(4>c)return 0;var d=b;c=d+c-4;for(var e=0;e<a.length;++e){var g=a.charCodeAt(e);if(55296<=g&&57343>=g){var k=a.charCodeAt(++e);g=65536+((g&1023)<<10)|k&1023}H[b>>2>>>0]=g;b+=4;if(b+4>c)break}H[b>>2>>>0]=0;return b-d}function Ba(a){for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);55296<=d&&57343>=d&&++c;b+=4}return b}var I,J,E,G,wa,H,K,Ca,Da;
-function Ea(a){I=a;f.HEAP8=J=new Int8Array(a);f.HEAP16=G=new Int16Array(a);f.HEAP32=H=new Int32Array(a);f.HEAPU8=E=new Uint8Array(a);f.HEAPU16=wa=new Uint16Array(a);f.HEAPU32=K=new Uint32Array(a);f.HEAPF32=Ca=new Float32Array(a);f.HEAPF64=Da=new Float64Array(a)}var Fa=f.INITIAL_MEMORY||16777216;f.wasmMemory?D=f.wasmMemory:D=new WebAssembly.Memory({initial:Fa/65536,maximum:65536});D&&(I=D.buffer);Fa=I.byteLength;Ea(I);H[68608]=5517472;
-function Ga(a){for(;0<a.length;){var b=a.shift();if("function"==typeof b)b(f);else{var c=b.eb;"number"===typeof c?void 0===b.Ma?f.dynCall_v(c):f.dynCall_vi(c,b.Ma):c(void 0===b.Ma?null:b.Ma)}}}var Ha=[],Ia=[],Ja=[],Ka=[];function La(){var a=f.preRun.shift();Ha.unshift(a)}var Ma=Math.abs,Na=Math.ceil,Oa=Math.floor,Pa=Math.min,L=0,Qa=null,Ra=null;f.preloadedImages={};f.preloadedAudios={};
-function B(a){if(f.onAbort)f.onAbort(a);C(a);oa=!0;a=new WebAssembly.RuntimeError("abort("+a+"). Build with -s ASSERTIONS=1 for more info.");ba(a);throw a;}function Sa(a){var b=M;return String.prototype.startsWith?b.startsWith(a):0===b.indexOf(a)}function Ta(){return Sa("data:application/octet-stream;base64,")}var M="jxl_enc.wasm";if(!Ta()){var Ua=M;M=f.locateFile?f.locateFile(Ua,A):A+Ua}
-function Va(){try{if(ma)return new Uint8Array(ma);if(ha)return ha(M);throw"both async and sync fetching of the wasm failed";}catch(a){B(a)}}function Wa(){return ma||!da&&!w||"function"!==typeof fetch||Sa("file://")?new Promise(function(a){a(Va())}):fetch(M,{credentials:"same-origin"}).then(function(a){if(!a.ok)throw"failed to load wasm binary file at '"+M+"'";return a.arrayBuffer()}).catch(function(){return Va()})}var N,Xa;Ia.push({eb:function(){Ya()}});function Za(){return 0<Za.Ia}
-function $a(a,b){for(var c=0,d=a.length-1;0<=d;d--){var e=a[d];"."===e?a.splice(d,1):".."===e?(a.splice(d,1),c++):c&&(a.splice(d,1),c--)}if(b)for(;c;c--)a.unshift("..");return a}function ab(a){var b="/"===a.charAt(0),c="/"===a.substr(-1);(a=$a(a.split("/").filter(function(d){return!!d}),!b).join("/"))||b||(a=".");a&&c&&(a+="/");return(b?"/":"")+a}
-function bb(a){var b=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/.exec(a).slice(1);a=b[0];b=b[1];if(!a&&!b)return".";b&&(b=b.substr(0,b.length-1));return a+b}function cb(a){if("/"===a)return"/";var b=a.lastIndexOf("/");return-1===b?a:a.substr(b+1)}
-function db(){for(var a="",b=!1,c=arguments.length-1;-1<=c&&!b;c--){b=0<=c?arguments[c]:"/";if("string"!==typeof b)throw new TypeError("Arguments to path.resolve must be strings");if(!b)return"";a=b+"/"+a;b="/"===b.charAt(0)}a=$a(a.split("/").filter(function(d){return!!d}),!b).join("/");return(b?"/":"")+a||"."}var eb=[];function fb(a,b){eb[a]={input:[],output:[],Ba:b};gb(a,hb)}
-var hb={open:function(a){var b=eb[a.node.rdev];if(!b)throw new O(43);a.tty=b;a.seekable=!1},close:function(a){a.tty.Ba.flush(a.tty)},flush:function(a){a.tty.Ba.flush(a.tty)},read:function(a,b,c,d){if(!a.tty||!a.tty.Ba.Xa)throw new O(60);for(var e=0,g=0;g<d;g++){try{var k=a.tty.Ba.Xa(a.tty)}catch(m){throw new O(29);}if(void 0===k&&0===e)throw new O(6);if(null===k||void 0===k)break;e++;b[c+g]=k}e&&(a.node.timestamp=Date.now());return e},write:function(a,b,c,d){if(!a.tty||!a.tty.Ba.Oa)throw new O(60);
-try{for(var e=0;e<d;e++)a.tty.Ba.Oa(a.tty,b[c+e])}catch(g){throw new O(29);}d&&(a.node.timestamp=Date.now());return e}},jb={Xa:function(a){if(!a.input.length){var b=null;if(z){var c=Buffer.Ia?Buffer.Ia(256):new Buffer(256),d=0;try{d=ia.readSync(process.stdin.fd,c,0,256,null)}catch(e){if(-1!=e.toString().indexOf("EOF"))d=0;else throw e;}0<d?b=c.slice(0,d).toString("utf-8"):b=null}else"undefined"!=typeof window&&"function"==typeof window.prompt?(b=window.prompt("Input: "),null!==b&&(b+="\n")):"function"==
-typeof readline&&(b=readline(),null!==b&&(b+="\n"));if(!b)return null;a.input=ib(b,!0)}return a.input.shift()},Oa:function(a,b){null===b||10===b?(la(qa(a.output,0)),a.output=[]):0!=b&&a.output.push(b)},flush:function(a){a.output&&0<a.output.length&&(la(qa(a.output,0)),a.output=[])}},kb={Oa:function(a,b){null===b||10===b?(C(qa(a.output,0)),a.output=[]):0!=b&&a.output.push(b)},flush:function(a){a.output&&0<a.output.length&&(C(qa(a.output,0)),a.output=[])}},P={ta:null,ya:function(){return P.createNode(null,
-"/",16895,0)},createNode:function(a,b,c,d){if(24576===(c&61440)||4096===(c&61440))throw new O(63);P.ta||(P.ta={dir:{node:{za:P.pa.za,va:P.pa.va,lookup:P.pa.lookup,Fa:P.pa.Fa,rename:P.pa.rename,unlink:P.pa.unlink,rmdir:P.pa.rmdir,readdir:P.pa.readdir,symlink:P.pa.symlink},stream:{Aa:P.qa.Aa}},file:{node:{za:P.pa.za,va:P.pa.va},stream:{Aa:P.qa.Aa,read:P.qa.read,write:P.qa.write,Ra:P.qa.Ra,Ya:P.qa.Ya,Ha:P.qa.Ha}},link:{node:{za:P.pa.za,va:P.pa.va,readlink:P.pa.readlink},stream:{}},Sa:{node:{za:P.pa.za,
-va:P.pa.va},stream:lb}});c=mb(a,b,c,d);16384===(c.mode&61440)?(c.pa=P.ta.dir.node,c.qa=P.ta.dir.stream,c.oa={}):32768===(c.mode&61440)?(c.pa=P.ta.file.node,c.qa=P.ta.file.stream,c.ra=0,c.oa=null):40960===(c.mode&61440)?(c.pa=P.ta.link.node,c.qa=P.ta.link.stream):8192===(c.mode&61440)&&(c.pa=P.ta.Sa.node,c.qa=P.ta.Sa.stream);c.timestamp=Date.now();a&&(a.oa[b]=c);return c},xb:function(a){if(a.oa&&a.oa.subarray){for(var b=[],c=0;c<a.ra;++c)b.push(a.oa[c]);return b}return a.oa},yb:function(a){return a.oa?
-a.oa.subarray?a.oa.subarray(0,a.ra):new Uint8Array(a.oa):new Uint8Array(0)},Ta:function(a,b){b>>>=0;var c=a.oa?a.oa.length:0;c>=b||(b=Math.max(b,c*(1048576>c?2:1.125)>>>0),0!=c&&(b=Math.max(b,256)),c=a.oa,a.oa=new Uint8Array(b),0<a.ra&&a.oa.set(c.subarray(0,a.ra),0))},nb:function(a,b){b>>>=0;if(a.ra!=b)if(0==b)a.oa=null,a.ra=0;else{if(!a.oa||a.oa.subarray){var c=a.oa;a.oa=new Uint8Array(b);c&&a.oa.set(c.subarray(0,Math.min(b,a.ra)))}else if(a.oa||(a.oa=[]),a.oa.length>b)a.oa.length=b;else for(;a.oa.length<
-b;)a.oa.push(0);a.ra=b}},pa:{za:function(a){var b={};b.dev=8192===(a.mode&61440)?a.id:1;b.ino=a.id;b.mode=a.mode;b.nlink=1;b.uid=0;b.gid=0;b.rdev=a.rdev;16384===(a.mode&61440)?b.size=4096:32768===(a.mode&61440)?b.size=a.ra:40960===(a.mode&61440)?b.size=a.link.length:b.size=0;b.atime=new Date(a.timestamp);b.mtime=new Date(a.timestamp);b.ctime=new Date(a.timestamp);b.bb=4096;b.blocks=Math.ceil(b.size/b.bb);return b},va:function(a,b){void 0!==b.mode&&(a.mode=b.mode);void 0!==b.timestamp&&(a.timestamp=
-b.timestamp);void 0!==b.size&&P.nb(a,b.size)},lookup:function(){throw nb[44];},Fa:function(a,b,c,d){return P.createNode(a,b,c,d)},rename:function(a,b,c){if(16384===(a.mode&61440)){try{var d=ob(b,c)}catch(g){}if(d)for(var e in d.oa)throw new O(55);}delete a.parent.oa[a.name];a.name=c;b.oa[c]=a;a.parent=b},unlink:function(a,b){delete a.oa[b]},rmdir:function(a,b){var c=ob(a,b),d;for(d in c.oa)throw new O(55);delete a.oa[b]},readdir:function(a){var b=[".",".."],c;for(c in a.oa)a.oa.hasOwnProperty(c)&&
-b.push(c);return b},symlink:function(a,b,c){a=P.createNode(a,b,41471,0);a.link=c;return a},readlink:function(a){if(40960!==(a.mode&61440))throw new O(28);return a.link}},qa:{read:function(a,b,c,d,e){var g=a.node.oa;if(e>=a.node.ra)return 0;a=Math.min(a.node.ra-e,d);if(8<a&&g.subarray)b.set(g.subarray(e,e+a),c);else for(d=0;d<a;d++)b[c+d]=g[e+d];return a},write:function(a,b,c,d,e,g){b.buffer===J.buffer&&(g=!1);if(!d)return 0;a=a.node;a.timestamp=Date.now();if(b.subarray&&(!a.oa||a.oa.subarray)){if(g)return a.oa=
-b.subarray(c,c+d),a.ra=d;if(0===a.ra&&0===e)return a.oa=b.slice(c,c+d),a.ra=d;if(e+d<=a.ra)return a.oa.set(b.subarray(c,c+d),e),d}P.Ta(a,e+d);if(a.oa.subarray&&b.subarray)a.oa.set(b.subarray(c,c+d),e);else for(g=0;g<d;g++)a.oa[e+g]=b[c+g];a.ra=Math.max(a.ra,e+d);return d},Aa:function(a,b,c){1===c?b+=a.position:2===c&&32768===(a.node.mode&61440)&&(b+=a.node.ra);if(0>b)throw new O(28);return b},Ra:function(a,b,c){P.Ta(a.node,b+c);a.node.ra=Math.max(a.node.ra,b+c)},Ya:function(a,b,c,d,e,g){assert(0===
-b);if(32768!==(a.node.mode&61440))throw new O(43);a=a.node.oa;if(g&2||a.buffer!==I){if(0<d||d+c<a.length)a.subarray?a=a.subarray(d,d+c):a=Array.prototype.slice.call(a,d,d+c);d=!0;g=16384*Math.ceil(c/16384);for(b=pb(g);c<g;)J[b+c++>>>0]=0;c=b;if(!c)throw new O(48);c>>>=0;J.set(a,c>>>0)}else d=!1,c=a.byteOffset;return{Fb:c,$a:d}},Ha:function(a,b,c,d,e){if(32768!==(a.node.mode&61440))throw new O(43);if(e&2)return 0;P.qa.write(a,b,0,d,c,!1);return 0}}},qb=null,rb={},Q=[],sb=1,tb=null,ub=!0,vb={},O=null,
-nb={};function R(a,b){a=db("/",a);b=b||{};if(!a)return{path:"",node:null};var c={Wa:!0,Pa:0},d;for(d in c)void 0===b[d]&&(b[d]=c[d]);if(8<b.Pa)throw new O(32);a=$a(a.split("/").filter(function(k){return!!k}),!1);var e=qb;c="/";for(d=0;d<a.length;d++){var g=d===a.length-1;if(g&&b.parent)break;e=ob(e,a[d]);c=ab(c+"/"+a[d]);e.Ga&&(!g||g&&b.Wa)&&(e=e.Ga.root);if(!g||b.Va)for(g=0;40960===(e.mode&61440);)if(e=wb(c),c=db(bb(c),e),e=R(c,{Pa:b.Pa}).node,40<g++)throw new O(32);}return{path:c,node:e}}
-function xb(a){for(var b;;){if(a===a.parent)return a=a.ya.Za,b?"/"!==a[a.length-1]?a+"/"+b:a+b:a;b=b?a.name+"/"+b:a.name;a=a.parent}}function yb(a,b){for(var c=0,d=0;d<b.length;d++)c=(c<<5)-c+b.charCodeAt(d)|0;return(a+c>>>0)%tb.length}function ob(a,b){var c;if(c=(c=zb(a,"x"))?c:a.pa.lookup?0:2)throw new O(c,a);for(c=tb[yb(a.id,b)];c;c=c.kb){var d=c.name;if(c.parent.id===a.id&&d===b)return c}return a.pa.lookup(a,b)}
-function mb(a,b,c,d){a=new Ab(a,b,c,d);b=yb(a.parent.id,a.name);a.kb=tb[b];return tb[b]=a}var Bb={r:0,rs:1052672,"r+":2,w:577,wx:705,xw:705,"w+":578,"wx+":706,"xw+":706,a:1089,ax:1217,xa:1217,"a+":1090,"ax+":1218,"xa+":1218};function Cb(a){var b=["r","w","rw"][a&3];a&512&&(b+="w");return b}function zb(a,b){if(ub)return 0;if(-1===b.indexOf("r")||a.mode&292){if(-1!==b.indexOf("w")&&!(a.mode&146)||-1!==b.indexOf("x")&&!(a.mode&73))return 2}else return 2;return 0}
-function Db(a,b){try{return ob(a,b),20}catch(c){}return zb(a,"wx")}function Eb(){var a=4096;for(var b=0;b<=a;b++)if(!Q[b])return b;throw new O(33);}function Fb(a){Gb||(Gb=function(){},Gb.prototype={});var b=new Gb,c;for(c in a)b[c]=a[c];a=b;b=Eb();a.fd=b;return Q[b]=a}var lb={open:function(a){a.qa=rb[a.node.rdev].qa;a.qa.open&&a.qa.open(a)},Aa:function(){throw new O(70);}};function gb(a,b){rb[a]={qa:b}}
-function Hb(a,b){var c="/"===b,d=!b;if(c&&qb)throw new O(10);if(!c&&!d){var e=R(b,{Wa:!1});b=e.path;e=e.node;if(e.Ga)throw new O(10);if(16384!==(e.mode&61440))throw new O(54);}b={type:a,Db:{},Za:b,jb:[]};a=a.ya(b);a.ya=b;b.root=a;c?qb=a:e&&(e.Ga=b,e.ya&&e.ya.jb.push(b))}function Ib(a,b,c){var d=R(a,{parent:!0}).node;a=cb(a);if(!a||"."===a||".."===a)throw new O(28);var e=Db(d,a);if(e)throw new O(e);if(!d.pa.Fa)throw new O(63);return d.pa.Fa(d,a,b,c)}function S(a){Ib(a,16895,0)}
-function Jb(a,b,c){"undefined"===typeof c&&(c=b,b=438);Ib(a,b|8192,c)}function Kb(a,b){if(!db(a))throw new O(44);var c=R(b,{parent:!0}).node;if(!c)throw new O(44);b=cb(b);var d=Db(c,b);if(d)throw new O(d);if(!c.pa.symlink)throw new O(63);c.pa.symlink(c,b,a)}function wb(a){a=R(a).node;if(!a)throw new O(44);if(!a.pa.readlink)throw new O(28);return db(xb(a.parent),a.pa.readlink(a))}
-function Lb(a,b){if(""===a)throw new O(44);if("string"===typeof b){var c=Bb[b];if("undefined"===typeof c)throw Error("Unknown file open mode: "+b);b=c}var d=b&64?("undefined"===typeof d?438:d)&4095|32768:0;if("object"===typeof a)var e=a;else{a=ab(a);try{e=R(a,{Va:!(b&131072)}).node}catch(k){}}c=!1;if(b&64)if(e){if(b&128)throw new O(20);}else e=Ib(a,d,0),c=!0;if(!e)throw new O(44);8192===(e.mode&61440)&&(b&=-513);if(b&65536&&16384!==(e.mode&61440))throw new O(54);if(!c&&(d=e?40960===(e.mode&61440)?
-32:16384===(e.mode&61440)&&("r"!==Cb(b)||b&512)?31:zb(e,Cb(b)):44))throw new O(d);if(b&512){d=e;var g;"string"===typeof d?g=R(d,{Va:!0}).node:g=d;if(!g.pa.va)throw new O(63);if(16384===(g.mode&61440))throw new O(31);if(32768!==(g.mode&61440))throw new O(28);if(d=zb(g,"w"))throw new O(d);g.pa.va(g,{size:0,timestamp:Date.now()})}b&=-131713;e=Fb({node:e,path:xb(e),flags:b,seekable:!0,position:0,qa:e.qa,wb:[],error:!1});e.qa.open&&e.qa.open(e);!f.logReadFiles||b&1||(Mb||(Mb={}),a in Mb||(Mb[a]=1,C("FS.trackingDelegate error on read file: "+
-a)));try{vb.onOpenFile&&(e=0,1!==(b&2097155)&&(e|=1),0!==(b&2097155)&&(e|=2),vb.onOpenFile(a,e))}catch(k){C("FS.trackingDelegate['onOpenFile']('"+a+"', flags) threw an exception: "+k.message)}}function Nb(a,b,c){if(null===a.fd)throw new O(8);if(!a.seekable||!a.qa.Aa)throw new O(70);if(0!=c&&1!=c&&2!=c)throw new O(28);a.position=a.qa.Aa(a,b,c);a.wb=[]}
-function Ob(){O||(O=function(a,b){this.node=b;this.ob=function(c){this.Ea=c};this.ob(a);this.message="FS error"},O.prototype=Error(),O.prototype.constructor=O,[44].forEach(function(a){nb[a]=new O(a);nb[a].stack="<generic error, no stack>"}))}var Pb;function Qb(a,b){var c=0;a&&(c|=365);b&&(c|=146);return c}
-function Rb(a,b,c){a=ab("/dev/"+a);var d=Qb(!!b,!!c);Sb||(Sb=64);var e=Sb++<<8|0;gb(e,{open:function(g){g.seekable=!1},close:function(){c&&c.buffer&&c.buffer.length&&c(10)},read:function(g,k,m,l){for(var q=0,r=0;r<l;r++){try{var u=b()}catch(x){throw new O(29);}if(void 0===u&&0===q)throw new O(6);if(null===u||void 0===u)break;q++;k[m+r]=u}q&&(g.node.timestamp=Date.now());return q},write:function(g,k,m,l){for(var q=0;q<l;q++)try{c(k[m+q])}catch(r){throw new O(29);}l&&(g.node.timestamp=Date.now());return q}});
-Jb(a,d,e)}var Sb,Tb={},Gb,Mb,Ub={};function Vb(a){a=Q[a];if(!a)throw new O(8);return a}var Wb={};function Xb(a){for(;a.length;){var b=a.pop();a.pop()(b)}}function Yb(a){return this.fromWireType(K[a>>>2])}var T={},U={},Zb={};function $b(a){if(void 0===a)return"_unknown";a=a.replace(/[^a-zA-Z0-9_]/g,"$");var b=a.charCodeAt(0);return 48<=b&&57>=b?"_"+a:a}
-function ac(a,b){a=$b(a);return(new Function("body","return function "+a+'() {\n    "use strict";    return body.apply(this, arguments);\n};\n'))(b)}function bc(a){var b=Error,c=ac(a,function(d){this.name=a;this.message=d;d=Error(d).stack;void 0!==d&&(this.stack=this.toString()+"\n"+d.replace(/^Error(:[^\n]*)?\n/,""))});c.prototype=Object.create(b.prototype);c.prototype.constructor=c;c.prototype.toString=function(){return void 0===this.message?this.name:this.name+": "+this.message};return c}
-var cc=void 0;function dc(a,b,c){function d(m){m=c(m);if(m.length!==a.length)throw new cc("Mismatched type converter count");for(var l=0;l<a.length;++l)V(a[l],m[l])}a.forEach(function(m){Zb[m]=b});var e=Array(b.length),g=[],k=0;b.forEach(function(m,l){U.hasOwnProperty(m)?e[l]=U[m]:(g.push(m),T.hasOwnProperty(m)||(T[m]=[]),T[m].push(function(){e[l]=U[m];++k;k===g.length&&d(e)}))});0===g.length&&d(e)}
-function ec(a){switch(a){case 1:return 0;case 2:return 1;case 4:return 2;case 8:return 3;default:throw new TypeError("Unknown type size: "+a);}}var fc=void 0;function W(a){for(var b="";E[a>>>0];)b+=fc[E[a++>>>0]];return b}var hc=void 0;function X(a){throw new hc(a);}
-function V(a,b,c){c=c||{};if(!("argPackAdvance"in b))throw new TypeError("registerType registeredInstance requires argPackAdvance");var d=b.name;a||X('type "'+d+'" must have a positive integer typeid pointer');if(U.hasOwnProperty(a)){if(c.ib)return;X("Cannot register type '"+d+"' twice")}U[a]=b;delete Zb[a];T.hasOwnProperty(a)&&(b=T[a],delete T[a],b.forEach(function(e){e()}))}var ic=[],Y=[{},{value:void 0},{value:null},{value:!0},{value:!1}];
-function jc(a){4<a&&0===--Y[a].Qa&&(Y[a]=void 0,ic.push(a))}function kc(a){switch(a){case void 0:return 1;case null:return 2;case !0:return 3;case !1:return 4;default:var b=ic.length?ic.pop():Y.length;Y[b]={Qa:1,value:a};return b}}function lc(a){if(null===a)return"null";var b=typeof a;return"object"===b||"array"===b||"function"===b?a.toString():""+a}
-function mc(a,b){switch(b){case 2:return function(c){return this.fromWireType(Ca[c>>>2])};case 3:return function(c){return this.fromWireType(Da[c>>>3])};default:throw new TypeError("Unknown float type: "+a);}}function nc(a){var b=Function;if(!(b instanceof Function))throw new TypeError("new_ called with constructor type "+typeof b+" which is not a function");var c=ac(b.name||"unknownFunctionName",function(){});c.prototype=b.prototype;c=new c;a=b.apply(c,a);return a instanceof Object?a:c}
-function oc(a,b){var c=f;if(void 0===c[a].ua){var d=c[a];c[a]=function(){c[a].ua.hasOwnProperty(arguments.length)||X("Function '"+b+"' called with an invalid number of arguments ("+arguments.length+") - expects one of ("+c[a].ua+")!");return c[a].ua[arguments.length].apply(this,arguments)};c[a].ua=[];c[a].ua[d.ab]=d}}
-function pc(a,b,c){f.hasOwnProperty(a)?((void 0===c||void 0!==f[a].ua&&void 0!==f[a].ua[c])&&X("Cannot register public name '"+a+"' twice"),oc(a,a),f.hasOwnProperty(c)&&X("Cannot register multiple overloads of a function with the same number of arguments ("+c+")!"),f[a].ua[c]=b):(f[a]=b,void 0!==c&&(f[a].Cb=c))}function qc(a,b){for(var c=[],d=0;d<a;d++)c.push(H[(b>>2)+d>>>0]);return c}
-function rc(a,b){a=W(a);var c=f["dynCall_"+a];for(var d=[],e=1;e<a.length;++e)d.push("a"+e);e="return function dynCall_"+(a+"_"+b)+"("+d.join(", ")+") {\n";e+="    return dynCall(rawFunction"+(d.length?", ":"")+d.join(", ")+");\n";c=(new Function("dynCall","rawFunction",e+"};\n"))(c,b);"function"!==typeof c&&X("unknown function pointer with signature "+a+": "+b);return c}var sc=void 0;function tc(a){a=uc(a);var b=W(a);Z(a);return b}
-function vc(a,b){function c(g){e[g]||U[g]||(Zb[g]?Zb[g].forEach(c):(d.push(g),e[g]=!0))}var d=[],e={};b.forEach(c);throw new sc(a+": "+d.map(tc).join([", "]));}function wc(a,b,c){switch(b){case 0:return c?function(d){return J[d>>>0]}:function(d){return E[d>>>0]};case 1:return c?function(d){return G[d>>>1]}:function(d){return wa[d>>>1]};case 2:return c?function(d){return H[d>>>2]}:function(d){return K[d>>>2]};default:throw new TypeError("Unknown integer type: "+a);}}var xc={};
-function yc(){return"object"===typeof globalThis?globalThis:Function("return this")()}function zc(a,b){var c=U[a];void 0===c&&X(b+" has unknown type "+tc(a));return c}var Ac={},Bc={};function Cc(){if(!Dc){var a={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"===typeof navigator&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",_:ca||"./this.program"},b;for(b in Bc)a[b]=Bc[b];var c=[];for(b in a)c.push(b+"="+a[b]);Dc=c}return Dc}var Dc;
-function Ec(a){return 0===a%4&&(0!==a%100||0===a%400)}function Fc(a,b){for(var c=0,d=0;d<=b;c+=a[d++]);return c}var Gc=[31,29,31,30,31,30,31,31,30,31,30,31],Hc=[31,28,31,30,31,30,31,31,30,31,30,31];function Ic(a,b){for(a=new Date(a.getTime());0<b;){var c=a.getMonth(),d=(Ec(a.getFullYear())?Gc:Hc)[c];if(b>d-a.getDate())b-=d-a.getDate()+1,a.setDate(1),11>c?a.setMonth(c+1):(a.setMonth(0),a.setFullYear(a.getFullYear()+1));else{a.setDate(a.getDate()+b);break}}return a}
-function Jc(a,b,c,d){function e(h,n,v){for(h="number"===typeof h?h.toString():h||"";h.length<n;)h=v[0]+h;return h}function g(h,n){return e(h,n,"0")}function k(h,n){function v(F){return 0>F?-1:0<F?1:0}var y;0===(y=v(h.getFullYear()-n.getFullYear()))&&0===(y=v(h.getMonth()-n.getMonth()))&&(y=v(h.getDate()-n.getDate()));return y}function m(h){switch(h.getDay()){case 0:return new Date(h.getFullYear()-1,11,29);case 1:return h;case 2:return new Date(h.getFullYear(),0,3);case 3:return new Date(h.getFullYear(),
-0,2);case 4:return new Date(h.getFullYear(),0,1);case 5:return new Date(h.getFullYear()-1,11,31);case 6:return new Date(h.getFullYear()-1,11,30)}}function l(h){h=Ic(new Date(h.sa+1900,0,1),h.La);var n=new Date(h.getFullYear()+1,0,4),v=m(new Date(h.getFullYear(),0,4));n=m(n);return 0>=k(v,h)?0>=k(n,h)?h.getFullYear()+1:h.getFullYear():h.getFullYear()-1}var q=H[d+40>>2>>>0];d={ub:H[d>>2>>>0],tb:H[d+4>>2>>>0],Ja:H[d+8>>2>>>0],Da:H[d+12>>2>>>0],Ca:H[d+16>>2>>>0],sa:H[d+20>>2>>>0],Ka:H[d+24>>2>>>0],La:H[d+
-28>>2>>>0],Gb:H[d+32>>2>>>0],sb:H[d+36>>2>>>0],vb:q?ra(q):""};c=ra(c);q={"%c":"%a %b %d %H:%M:%S %Y","%D":"%m/%d/%y","%F":"%Y-%m-%d","%h":"%b","%r":"%I:%M:%S %p","%R":"%H:%M","%T":"%H:%M:%S","%x":"%m/%d/%y","%X":"%H:%M:%S","%Ec":"%c","%EC":"%C","%Ex":"%m/%d/%y","%EX":"%H:%M:%S","%Ey":"%y","%EY":"%Y","%Od":"%d","%Oe":"%e","%OH":"%H","%OI":"%I","%Om":"%m","%OM":"%M","%OS":"%S","%Ou":"%u","%OU":"%U","%OV":"%V","%Ow":"%w","%OW":"%W","%Oy":"%y"};for(var r in q)c=c.replace(new RegExp(r,"g"),q[r]);var u=
-"Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "),x="January February March April May June July August September October November December".split(" ");q={"%a":function(h){return u[h.Ka].substring(0,3)},"%A":function(h){return u[h.Ka]},"%b":function(h){return x[h.Ca].substring(0,3)},"%B":function(h){return x[h.Ca]},"%C":function(h){return g((h.sa+1900)/100|0,2)},"%d":function(h){return g(h.Da,2)},"%e":function(h){return e(h.Da,2," ")},"%g":function(h){return l(h).toString().substring(2)},
-"%G":function(h){return l(h)},"%H":function(h){return g(h.Ja,2)},"%I":function(h){h=h.Ja;0==h?h=12:12<h&&(h-=12);return g(h,2)},"%j":function(h){return g(h.Da+Fc(Ec(h.sa+1900)?Gc:Hc,h.Ca-1),3)},"%m":function(h){return g(h.Ca+1,2)},"%M":function(h){return g(h.tb,2)},"%n":function(){return"\n"},"%p":function(h){return 0<=h.Ja&&12>h.Ja?"AM":"PM"},"%S":function(h){return g(h.ub,2)},"%t":function(){return"\t"},"%u":function(h){return h.Ka||7},"%U":function(h){var n=new Date(h.sa+1900,0,1),v=0===n.getDay()?
-n:Ic(n,7-n.getDay());h=new Date(h.sa+1900,h.Ca,h.Da);return 0>k(v,h)?g(Math.ceil((31-v.getDate()+(Fc(Ec(h.getFullYear())?Gc:Hc,h.getMonth()-1)-31)+h.getDate())/7),2):0===k(v,n)?"01":"00"},"%V":function(h){var n=new Date(h.sa+1901,0,4),v=m(new Date(h.sa+1900,0,4));n=m(n);var y=Ic(new Date(h.sa+1900,0,1),h.La);return 0>k(y,v)?"53":0>=k(n,y)?"01":g(Math.ceil((v.getFullYear()<h.sa+1900?h.La+32-v.getDate():h.La+1-v.getDate())/7),2)},"%w":function(h){return h.Ka},"%W":function(h){var n=new Date(h.sa,0,
-1),v=1===n.getDay()?n:Ic(n,0===n.getDay()?1:7-n.getDay()+1);h=new Date(h.sa+1900,h.Ca,h.Da);return 0>k(v,h)?g(Math.ceil((31-v.getDate()+(Fc(Ec(h.getFullYear())?Gc:Hc,h.getMonth()-1)-31)+h.getDate())/7),2):0===k(v,n)?"01":"00"},"%y":function(h){return(h.sa+1900).toString().substring(2)},"%Y":function(h){return h.sa+1900},"%z":function(h){h=h.sb;var n=0<=h;h=Math.abs(h)/60;return(n?"+":"-")+String("0000"+(h/60*100+h%60)).slice(-4)},"%Z":function(h){return h.vb},"%%":function(){return"%"}};for(r in q)0<=
-c.indexOf(r)&&(c=c.replace(new RegExp(r,"g"),q[r](d)));r=ib(c,!1);if(r.length>b)return 0;J.set(r,a>>>0);return r.length-1}function Ab(a,b,c,d){a||(a=this);this.parent=a;this.ya=a.ya;this.Ga=null;this.id=sb++;this.name=b;this.mode=c;this.pa={};this.qa={};this.rdev=d}
-Object.defineProperties(Ab.prototype,{read:{get:function(){return 365===(this.mode&365)},set:function(a){a?this.mode|=365:this.mode&=-366}},write:{get:function(){return 146===(this.mode&146)},set:function(a){a?this.mode|=146:this.mode&=-147}}});Ob();tb=Array(4096);Hb(P,"/");S("/tmp");S("/home");S("/home/web_user");
-(function(){S("/dev");gb(259,{read:function(){return 0},write:function(d,e,g,k){return k}});Jb("/dev/null",259);fb(1280,jb);fb(1536,kb);Jb("/dev/tty",1280);Jb("/dev/tty1",1536);if("object"===typeof crypto&&"function"===typeof crypto.getRandomValues){var a=new Uint8Array(1);var b=function(){crypto.getRandomValues(a);return a[0]}}else if(z)try{var c=require("crypto");b=function(){return c.randomBytes(1)[0]}}catch(d){}b||(b=function(){B("random_device")});Rb("random",b);Rb("urandom",b);S("/dev/shm");
-S("/dev/shm/tmp")})();S("/proc");S("/proc/self");S("/proc/self/fd");Hb({ya:function(){var a=mb("/proc/self","fd",16895,73);a.pa={lookup:function(b,c){var d=Q[+c];if(!d)throw new O(8);b={parent:null,ya:{Za:"fake"},pa:{readlink:function(){return d.path}}};return b.parent=b}};return a}},"/proc/self/fd");cc=f.InternalError=bc("InternalError");for(var Kc=Array(256),Lc=0;256>Lc;++Lc)Kc[Lc]=String.fromCharCode(Lc);fc=Kc;hc=f.BindingError=bc("BindingError");
-f.count_emval_handles=function(){for(var a=0,b=5;b<Y.length;++b)void 0!==Y[b]&&++a;return a};f.get_first_emval=function(){for(var a=5;a<Y.length;++a)if(void 0!==Y[a])return Y[a];return null};sc=f.UnboundTypeError=bc("UnboundTypeError");function ib(a,b){var c=Array(ta(a)+1);a=sa(a,c,0,c.length);b&&(c.length=a);return c}
-var Nc={t:function(a){return pb(a)},G:function(){},q:function(a){"uncaught_exception"in Za?Za.Ia++:Za.Ia=1;throw a;},x:function(){H[Mc()>>2>>>0]=63;return-1},w:function(a,b){try{a>>>=0;if(-1===(a|0)||0===b)var c=-28;else{var d=Ub[a];if(d&&b===d.Ab){var e=Q[d.fd];if(d.Eb&2){var g=d.flags,k=d.offset,m=E.slice(a,a+b);e&&e.qa.Ha&&e.qa.Ha(e,m,k>>>0,b,g)}Ub[a]=null;d.$a&&Z(d.Bb)}c=0}return c}catch(l){return"undefined"!==typeof Tb&&l instanceof O||B(l),-l.Ea}},n:function(a){var b=Wb[a];delete Wb[a];var c=
-b.lb,d=b.mb,e=b.Ua,g=e.map(function(k){return k.hb}).concat(e.map(function(k){return k.qb}));dc([a],g,function(k){var m={};e.forEach(function(l,q){var r=k[q],u=l.fb,x=l.gb,h=k[q+e.length],n=l.pb,v=l.rb;m[l.cb]={read:function(y){return r.fromWireType(u(x,y))},write:function(y,F){var ja=[];n(v,y,h.toWireType(ja,F));Xb(ja)}}});return[{name:b.name,fromWireType:function(l){var q={},r;for(r in m)q[r]=m[r].read(l);d(l);return q},toWireType:function(l,q){for(var r in m)if(!(r in q))throw new TypeError('Missing field:  "'+
-r+'"');var u=c();for(r in m)m[r].write(u,q[r]);null!==l&&l.push(d,u);return u},argPackAdvance:8,readValueFromPointer:Yb,wa:d}]})},C:function(a,b,c,d,e){var g=ec(c);b=W(b);V(a,{name:b,fromWireType:function(k){return!!k},toWireType:function(k,m){return m?d:e},argPackAdvance:8,readValueFromPointer:function(k){if(1===c)var m=J;else if(2===c)m=G;else if(4===c)m=H;else throw new TypeError("Unknown boolean type size: "+b);return this.fromWireType(m[k>>>g])},wa:null})},B:function(a,b){b=W(b);V(a,{name:b,
-fromWireType:function(c){var d=Y[c].value;jc(c);return d},toWireType:function(c,d){return kc(d)},argPackAdvance:8,readValueFromPointer:Yb,wa:null})},k:function(a,b,c){c=ec(c);b=W(b);V(a,{name:b,fromWireType:function(d){return d},toWireType:function(d,e){if("number"!==typeof e&&"boolean"!==typeof e)throw new TypeError('Cannot convert "'+lc(e)+'" to '+this.name);return e},argPackAdvance:8,readValueFromPointer:mc(b,c),wa:null})},m:function(a,b,c,d,e,g){var k=qc(b,c);a=W(a);e=rc(d,e);pc(a,function(){vc("Cannot call "+
-a+" due to unbound types",k)},b-1);dc([],k,function(m){var l=[m[0],null].concat(m.slice(1)),q=m=a,r=e,u=l.length;2>u&&X("argTypes array size mismatch! Must at least get return value and 'this' types!");for(var x=null!==l[1]&&!1,h=!1,n=1;n<l.length;++n)if(null!==l[n]&&void 0===l[n].wa){h=!0;break}var v="void"!==l[0].name,y="",F="";for(n=0;n<u-2;++n)y+=(0!==n?", ":"")+"arg"+n,F+=(0!==n?", ":"")+"arg"+n+"Wired";q="return function "+$b(q)+"("+y+") {\nif (arguments.length !== "+(u-2)+") {\nthrowBindingError('function "+
-q+" called with ' + arguments.length + ' arguments, expected "+(u-2)+" args!');\n}\n";h&&(q+="var destructors = [];\n");var ja=h?"destructors":"null";y="throwBindingError invoker fn runDestructors retType classParam".split(" ");r=[X,r,g,Xb,l[0],l[1]];x&&(q+="var thisWired = classParam.toWireType("+ja+", this);\n");for(n=0;n<u-2;++n)q+="var arg"+n+"Wired = argType"+n+".toWireType("+ja+", arg"+n+"); // "+l[n+2].name+"\n",y.push("argType"+n),r.push(l[n+2]);x&&(F="thisWired"+(0<F.length?", ":"")+F);q+=
-(v?"var rv = ":"")+"invoker(fn"+(0<F.length?", ":"")+F+");\n";if(h)q+="runDestructors(destructors);\n";else for(n=x?1:2;n<l.length;++n)u=1===n?"thisWired":"arg"+(n-2)+"Wired",null!==l[n].wa&&(q+=u+"_dtor("+u+"); // "+l[n].name+"\n",y.push(u+"_dtor"),r.push(l[n].wa));v&&(q+="var ret = retType.fromWireType(rv);\nreturn ret;\n");y.push(q+"}\n");l=nc(y).apply(null,r);n=b-1;if(!f.hasOwnProperty(m))throw new cc("Replacing nonexistant public symbol");void 0!==f[m].ua&&void 0!==n?f[m].ua[n]=l:(f[m]=l,f[m].ab=
-n);return[]})},b:function(a,b,c,d,e){function g(q){return q}b=W(b);-1===e&&(e=4294967295);var k=ec(c);if(0===d){var m=32-8*c;g=function(q){return q<<m>>>m}}var l=-1!=b.indexOf("unsigned");V(a,{name:b,fromWireType:g,toWireType:function(q,r){if("number"!==typeof r&&"boolean"!==typeof r)throw new TypeError('Cannot convert "'+lc(r)+'" to '+this.name);if(r<d||r>e)throw new TypeError('Passing a number "'+lc(r)+'" from JS side to C/C++ side to an argument of type "'+b+'", which is outside the valid range ['+
-d+", "+e+"]!");return l?r>>>0:r|0},argPackAdvance:8,readValueFromPointer:wc(b,k,0!==d),wa:null})},a:function(a,b,c){function d(g){g>>=2;var k=K;return new e(I,k[g+1>>>0],k[g>>>0])}var e=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array][b];c=W(c);V(a,{name:c,fromWireType:d,argPackAdvance:8,readValueFromPointer:d},{ib:!0})},l:function(a,b){b=W(b);var c="std::string"===b;V(a,{name:b,fromWireType:function(d){var e=K[d>>>2];if(c)for(var g=d+4,k=0;k<=e;++k){var m=
-d+4+k;if(k==e||0==E[m>>>0]){g=ra(g,m-g);if(void 0===l)var l=g;else l+=String.fromCharCode(0),l+=g;g=m+1}}else{l=Array(e);for(k=0;k<e;++k)l[k]=String.fromCharCode(E[d+4+k>>>0]);l=l.join("")}Z(d);return l},toWireType:function(d,e){e instanceof ArrayBuffer&&(e=new Uint8Array(e));var g="string"===typeof e;g||e instanceof Uint8Array||e instanceof Uint8ClampedArray||e instanceof Int8Array||X("Cannot pass non-string to std::string");var k=(c&&g?function(){return ta(e)}:function(){return e.length})(),m=pb(4+
-k+1);m>>>=0;K[m>>>2]=k;if(c&&g)sa(e,E,m+4,k+1);else if(g)for(g=0;g<k;++g){var l=e.charCodeAt(g);255<l&&(Z(m),X("String has UTF-16 code units that do not fit in 8 bits"));E[m+4+g>>>0]=l}else for(g=0;g<k;++g)E[m+4+g>>>0]=e[g];null!==d&&d.push(Z,m);return m},argPackAdvance:8,readValueFromPointer:Yb,wa:function(d){Z(d)}})},f:function(a,b,c){c=W(c);if(2===b){var d=va;var e=xa;var g=ya;var k=function(){return wa};var m=1}else 4===b&&(d=za,e=Aa,g=Ba,k=function(){return K},m=2);V(a,{name:c,fromWireType:function(l){for(var q=
-K[l>>>2],r=k(),u,x=l+4,h=0;h<=q;++h){var n=l+4+h*b;if(h==q||0==r[n>>>m])x=d(x,n-x),void 0===u?u=x:(u+=String.fromCharCode(0),u+=x),x=n+b}Z(l);return u},toWireType:function(l,q){"string"!==typeof q&&X("Cannot pass non-string to C++ string type "+c);var r=g(q),u=pb(4+r+b);u>>>=0;K[u>>>2]=r>>m;e(q,u+4,r+b);null!==l&&l.push(Z,u);return u},argPackAdvance:8,readValueFromPointer:Yb,wa:function(l){Z(l)}})},o:function(a,b,c,d,e,g){Wb[a]={name:W(b),lb:rc(c,d),mb:rc(e,g),Ua:[]}},h:function(a,b,c,d,e,g,k,m,l,
-q){Wb[a].Ua.push({cb:W(b),hb:c,fb:rc(d,e),gb:g,qb:k,pb:rc(m,l),rb:q})},D:function(a,b){b=W(b);V(a,{zb:!0,name:b,argPackAdvance:0,fromWireType:function(){},toWireType:function(){}})},j:jc,F:function(a){if(0===a)return kc(yc());var b=xc[a];a=void 0===b?W(a):b;return kc(yc()[a])},E:function(a){4<a&&(Y[a].Qa+=1)},p:function(a,b,c,d){a||X("Cannot use deleted val. handle = "+a);a=Y[a].value;var e=Ac[b];if(!e){e="";for(var g=0;g<b;++g)e+=(0!==g?", ":"")+"arg"+g;var k="return function emval_allocator_"+b+
-"(constructor, argTypes, args) {\n";for(g=0;g<b;++g)k+="var argType"+g+" = requireRegisteredType(Module['HEAP32'][(argTypes >>> 2) + "+g+'], "parameter '+g+'");\nvar arg'+g+" = argType"+g+".readValueFromPointer(args);\nargs += argType"+g+"['argPackAdvance'];\n";e=(new Function("requireRegisteredType","Module","__emval_register",k+("var obj = new constructor("+e+");\nreturn __emval_register(obj);\n}\n")))(zc,f,kc);Ac[b]=e}return e(a,c,d)},g:function(){B()},u:function(a,b,c){E.copyWithin(a>>>0,b>>>
-0,b+c>>>0)},d:function(a){a>>>=0;var b=E.length;if(4294967296<a)return!1;for(var c=1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,a+100663296);d=Math.max(16777216,a,d);0<d%65536&&(d+=65536-d%65536);a:{try{D.grow(Math.min(4294967296,d)-I.byteLength+65535>>>16);Ea(D.buffer);var e=1;break a}catch(g){}e=void 0}if(e)return!0}return!1},y:function(a,b){var c=0;Cc().forEach(function(d,e){var g=b+c;e=H[a+4*e>>2>>>0]=g;for(g=0;g<d.length;++g)J[e++>>0>>>0]=d.charCodeAt(g);J[e>>0>>>0]=0;c+=d.length+1});return 0},
-z:function(a,b){var c=Cc();H[a>>2>>>0]=c.length;var d=0;c.forEach(function(e){d+=e.length+1});H[b>>2>>>0]=d;return 0},A:function(a){try{var b=Vb(a);if(null===b.fd)throw new O(8);b.Na&&(b.Na=null);try{b.qa.close&&b.qa.close(b)}catch(c){throw c;}finally{Q[b.fd]=null}b.fd=null;return 0}catch(c){return"undefined"!==typeof Tb&&c instanceof O||B(c),c.Ea}},r:function(a,b,c,d,e){try{var g=Vb(a);a=4294967296*c+(b>>>0);if(-9007199254740992>=a||9007199254740992<=a)return-61;Nb(g,a,d);Xa=[g.position>>>0,(N=g.position,
-1<=+Ma(N)?0<N?(Pa(+Oa(N/4294967296),4294967295)|0)>>>0:~~+Na((N-+(~~N>>>0))/4294967296)>>>0:0)];H[e>>2>>>0]=Xa[0];H[e+4>>2>>>0]=Xa[1];g.Na&&0===a&&0===d&&(g.Na=null);return 0}catch(k){return"undefined"!==typeof Tb&&k instanceof O||B(k),k.Ea}},i:function(a,b,c,d){try{a:{for(var e=Vb(a),g=a=0;g<c;g++){var k=e,m=H[b+8*g>>2>>>0],l=H[b+(8*g+4)>>2>>>0],q=void 0,r=J;m>>>=0;if(0>l||0>q)throw new O(28);if(null===k.fd)throw new O(8);if(0===(k.flags&2097155))throw new O(8);if(16384===(k.node.mode&61440))throw new O(31);
-if(!k.qa.write)throw new O(28);k.seekable&&k.flags&1024&&Nb(k,0,2);var u="undefined"!==typeof q;if(!u)q=k.position;else if(!k.seekable)throw new O(70);var x=k.qa.write(k,r,m,l,q,void 0);u||(k.position+=x);try{if(k.path&&vb.onWriteToFile)vb.onWriteToFile(k.path)}catch(v){C("FS.trackingDelegate['onWriteToFile']('"+k.path+"') threw an exception: "+v.message)}var h=x;if(0>h){var n=-1;break a}a+=h}n=a}H[d>>2>>>0]=n;return 0}catch(v){return"undefined"!==typeof Tb&&v instanceof O||B(v),v.Ea}},memory:D,e:function(a){a=
-+a;return 0<=a?+Oa(a+.5):+Na(a-.5)},c:function(a){a=+a;return 0<=a?+Oa(a+.5):+Na(a-.5)},s:function(){},v:function(a,b,c,d){return Jc(a,b,c,d)},table:na};
-(function(){function a(e){f.asm=e.exports;L--;f.monitorRunDependencies&&f.monitorRunDependencies(L);0==L&&(null!==Qa&&(clearInterval(Qa),Qa=null),Ra&&(e=Ra,Ra=null,e()))}function b(e){a(e.instance)}function c(e){return Wa().then(function(g){return WebAssembly.instantiate(g,d)}).then(e,function(g){C("failed to asynchronously prepare wasm: "+g);B(g)})}var d={a:Nc};L++;f.monitorRunDependencies&&f.monitorRunDependencies(L);if(f.instantiateWasm)try{return f.instantiateWasm(d,a)}catch(e){return C("Module.instantiateWasm callback failed with error: "+
-e),!1}(function(){if(ma||"function"!==typeof WebAssembly.instantiateStreaming||Ta()||Sa("file://")||"function"!==typeof fetch)return c(b);fetch(M,{credentials:"same-origin"}).then(function(e){return WebAssembly.instantiateStreaming(e,d).then(b,function(g){C("wasm streaming compile failed: "+g);C("falling back to ArrayBuffer instantiation");return c(b)})})})();return{}})();
-var Ya=f.___wasm_call_ctors=function(){return(Ya=f.___wasm_call_ctors=f.asm.H).apply(null,arguments)},pb=f._malloc=function(){return(pb=f._malloc=f.asm.I).apply(null,arguments)},Z=f._free=function(){return(Z=f._free=f.asm.J).apply(null,arguments)},Mc=f.___errno_location=function(){return(Mc=f.___errno_location=f.asm.K).apply(null,arguments)},uc=f.___getTypeName=function(){return(uc=f.___getTypeName=f.asm.L).apply(null,arguments)};
-f.___embind_register_native_and_builtin_types=function(){return(f.___embind_register_native_and_builtin_types=f.asm.M).apply(null,arguments)};f.dynCall_i=function(){return(f.dynCall_i=f.asm.N).apply(null,arguments)};f.dynCall_vi=function(){return(f.dynCall_vi=f.asm.O).apply(null,arguments)};f.dynCall_iii=function(){return(f.dynCall_iii=f.asm.P).apply(null,arguments)};f.dynCall_viii=function(){return(f.dynCall_viii=f.asm.Q).apply(null,arguments)};
-f.dynCall_fii=function(){return(f.dynCall_fii=f.asm.R).apply(null,arguments)};f.dynCall_viif=function(){return(f.dynCall_viif=f.asm.S).apply(null,arguments)};f.dynCall_iiiiii=function(){return(f.dynCall_iiiiii=f.asm.T).apply(null,arguments)};f.dynCall_viiiii=function(){return(f.dynCall_viiiii=f.asm.U).apply(null,arguments)};f.dynCall_ii=function(){return(f.dynCall_ii=f.asm.V).apply(null,arguments)};f.dynCall_iidiiii=function(){return(f.dynCall_iidiiii=f.asm.W).apply(null,arguments)};
-f.dynCall_vii=function(){return(f.dynCall_vii=f.asm.X).apply(null,arguments)};f.dynCall_iiiiiii=function(){return(f.dynCall_iiiiiii=f.asm.Y).apply(null,arguments)};f.dynCall_iiii=function(){return(f.dynCall_iiii=f.asm.Z).apply(null,arguments)};f.dynCall_v=function(){return(f.dynCall_v=f.asm._).apply(null,arguments)};f.dynCall_viiiiiii=function(){return(f.dynCall_viiiiiii=f.asm.$).apply(null,arguments)};f.dynCall_viijii=function(){return(f.dynCall_viijii=f.asm.aa).apply(null,arguments)};
-f.dynCall_viiii=function(){return(f.dynCall_viiii=f.asm.ba).apply(null,arguments)};f.dynCall_iiiii=function(){return(f.dynCall_iiiii=f.asm.ca).apply(null,arguments)};f.dynCall_fi=function(){return(f.dynCall_fi=f.asm.da).apply(null,arguments)};f.dynCall_iiji=function(){return(f.dynCall_iiji=f.asm.ea).apply(null,arguments)};f.dynCall_iifi=function(){return(f.dynCall_iifi=f.asm.fa).apply(null,arguments)};f.dynCall_jiji=function(){return(f.dynCall_jiji=f.asm.ga).apply(null,arguments)};
-f.dynCall_iiiiiiiii=function(){return(f.dynCall_iiiiiiiii=f.asm.ha).apply(null,arguments)};f.dynCall_viiiiii=function(){return(f.dynCall_viiiiii=f.asm.ia).apply(null,arguments)};f.dynCall_iiiiiiii=function(){return(f.dynCall_iiiiiiii=f.asm.ja).apply(null,arguments)};f.dynCall_iiiiiijj=function(){return(f.dynCall_iiiiiijj=f.asm.ka).apply(null,arguments)};f.dynCall_iiiiij=function(){return(f.dynCall_iiiiij=f.asm.la).apply(null,arguments)};
-f.dynCall_iiiiid=function(){return(f.dynCall_iiiiid=f.asm.ma).apply(null,arguments)};f.dynCall_iiiiijj=function(){return(f.dynCall_iiiiijj=f.asm.na).apply(null,arguments)};var Oc;Ra=function Pc(){Oc||Qc();Oc||(Ra=Pc)};
-function Qc(){function a(){if(!Oc&&(Oc=!0,f.calledRun=!0,!oa)){f.noFSInit||Pb||(Pb=!0,Ob(),f.stdin=f.stdin,f.stdout=f.stdout,f.stderr=f.stderr,f.stdin?Rb("stdin",f.stdin):Kb("/dev/tty","/dev/stdin"),f.stdout?Rb("stdout",null,f.stdout):Kb("/dev/tty","/dev/stdout"),f.stderr?Rb("stderr",null,f.stderr):Kb("/dev/tty1","/dev/stderr"),Lb("/dev/stdin","r"),Lb("/dev/stdout","w"),Lb("/dev/stderr","w"));Ga(Ia);ub=!1;Ga(Ja);aa(f);if(f.onRuntimeInitialized)f.onRuntimeInitialized();if(f.postRun)for("function"==
-typeof f.postRun&&(f.postRun=[f.postRun]);f.postRun.length;){var b=f.postRun.shift();Ka.unshift(b)}Ga(Ka)}}if(!(0<L)){if(f.preRun)for("function"==typeof f.preRun&&(f.preRun=[f.preRun]);f.preRun.length;)La();Ga(Ha);0<L||(f.setStatus?(f.setStatus("Running..."),setTimeout(function(){setTimeout(function(){f.setStatus("")},1);a()},1)):a())}}f.run=Qc;if(f.preInit)for("function"==typeof f.preInit&&(f.preInit=[f.preInit]);0<f.preInit.length;)f.preInit.pop()();noExitRuntime=!0;Qc();
+var readyPromiseResolve, readyPromiseReject;
+
+Module["ready"] = new Promise(function(resolve, reject) {
+ readyPromiseResolve = resolve;
+ readyPromiseReject = reject;
+});
+
+var moduleOverrides = {};
+
+var key;
+
+for (key in Module) {
+ if (Module.hasOwnProperty(key)) {
+  moduleOverrides[key] = Module[key];
+ }
+}
+
+var arguments_ = [];
+
+var thisProgram = "./this.program";
+
+var quit_ = function(status, toThrow) {
+ throw toThrow;
+};
+
+var ENVIRONMENT_IS_WEB = false;
+
+var ENVIRONMENT_IS_WORKER = false;
+
+var ENVIRONMENT_IS_NODE = false;
+
+var ENVIRONMENT_IS_SHELL = false;
+
+ENVIRONMENT_IS_WEB = typeof window === "object";
+
+ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
+
+ENVIRONMENT_IS_NODE = typeof process === "object" && typeof process.versions === "object" && typeof process.versions.node === "string";
+
+ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+var scriptDirectory = "";
+
+function locateFile(path) {
+ if (Module["locateFile"]) {
+  return Module["locateFile"](path, scriptDirectory);
+ }
+ return scriptDirectory + path;
+}
+
+var read_, readAsync, readBinary, setWindowTitle;
+
+var nodeFS;
+
+var nodePath;
+
+if (ENVIRONMENT_IS_NODE) {
+ if (ENVIRONMENT_IS_WORKER) {
+  scriptDirectory = require("path").dirname(scriptDirectory) + "/";
+ } else {
+  scriptDirectory = __dirname + "/";
+ }
+ read_ = function shell_read(filename, binary) {
+  if (!nodeFS) nodeFS = require("fs");
+  if (!nodePath) nodePath = require("path");
+  filename = nodePath["normalize"](filename);
+  return nodeFS["readFileSync"](filename, binary ? null : "utf8");
+ };
+ readBinary = function readBinary(filename) {
+  var ret = read_(filename, true);
+  if (!ret.buffer) {
+   ret = new Uint8Array(ret);
+  }
+  assert(ret.buffer);
+  return ret;
+ };
+ if (process["argv"].length > 1) {
+  thisProgram = process["argv"][1].replace(/\\/g, "/");
+ }
+ arguments_ = process["argv"].slice(2);
+ process["on"]("uncaughtException", function(ex) {
+  if (!(ex instanceof ExitStatus)) {
+   throw ex;
+  }
+ });
+ process["on"]("unhandledRejection", abort);
+ quit_ = function(status) {
+  process["exit"](status);
+ };
+ Module["inspect"] = function() {
+  return "[Emscripten Module object]";
+ };
+} else if (ENVIRONMENT_IS_SHELL) {
+ if (typeof read != "undefined") {
+  read_ = function shell_read(f) {
+   return read(f);
+  };
+ }
+ readBinary = function readBinary(f) {
+  var data;
+  if (typeof readbuffer === "function") {
+   return new Uint8Array(readbuffer(f));
+  }
+  data = read(f, "binary");
+  assert(typeof data === "object");
+  return data;
+ };
+ if (typeof scriptArgs != "undefined") {
+  arguments_ = scriptArgs;
+ } else if (typeof arguments != "undefined") {
+  arguments_ = arguments;
+ }
+ if (typeof quit === "function") {
+  quit_ = function(status) {
+   quit(status);
+  };
+ }
+ if (typeof print !== "undefined") {
+  if (typeof console === "undefined") console = {};
+  console.log = print;
+  console.warn = console.error = typeof printErr !== "undefined" ? printErr : print;
+ }
+} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ if (ENVIRONMENT_IS_WORKER) {
+  scriptDirectory = self.location.href;
+ } else if (document.currentScript) {
+  scriptDirectory = document.currentScript.src;
+ }
+ if (_scriptDir) {
+  scriptDirectory = _scriptDir;
+ }
+ if (scriptDirectory.indexOf("blob:") !== 0) {
+  scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf("/") + 1);
+ } else {
+  scriptDirectory = "";
+ }
+ {
+  read_ = function shell_read(url) {
+   var xhr = new XMLHttpRequest();
+   xhr.open("GET", url, false);
+   xhr.send(null);
+   return xhr.responseText;
+  };
+  if (ENVIRONMENT_IS_WORKER) {
+   readBinary = function readBinary(url) {
+    var xhr = new XMLHttpRequest();
+    xhr.open("GET", url, false);
+    xhr.responseType = "arraybuffer";
+    xhr.send(null);
+    return new Uint8Array(xhr.response);
+   };
+  }
+  readAsync = function readAsync(url, onload, onerror) {
+   var xhr = new XMLHttpRequest();
+   xhr.open("GET", url, true);
+   xhr.responseType = "arraybuffer";
+   xhr.onload = function xhr_onload() {
+    if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+     onload(xhr.response);
+     return;
+    }
+    onerror();
+   };
+   xhr.onerror = onerror;
+   xhr.send(null);
+  };
+ }
+ setWindowTitle = function(title) {
+  document.title = title;
+ };
+} else {}
+
+var out = Module["print"] || console.log.bind(console);
+
+var err = Module["printErr"] || console.warn.bind(console);
+
+for (key in moduleOverrides) {
+ if (moduleOverrides.hasOwnProperty(key)) {
+  Module[key] = moduleOverrides[key];
+ }
+}
+
+moduleOverrides = null;
+
+if (Module["arguments"]) arguments_ = Module["arguments"];
+
+if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
+
+if (Module["quit"]) quit_ = Module["quit"];
+
+var STACK_ALIGN = 16;
+
+function alignMemory(size, factor) {
+ if (!factor) factor = STACK_ALIGN;
+ return Math.ceil(size / factor) * factor;
+}
+
+var tempRet0 = 0;
+
+var setTempRet0 = function(value) {
+ tempRet0 = value;
+};
+
+var wasmBinary;
+
+if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
+
+var noExitRuntime;
+
+if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
+
+if (typeof WebAssembly !== "object") {
+ abort("no native wasm support detected");
+}
+
+var wasmMemory;
+
+var wasmTable = new WebAssembly.Table({
+ "initial": 947,
+ "maximum": 947 + 0,
+ "element": "anyfunc"
+});
+
+var ABORT = false;
+
+var EXITSTATUS = 0;
+
+function assert(condition, text) {
+ if (!condition) {
+  abort("Assertion failed: " + text);
+ }
+}
+
+var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : undefined;
+
+function UTF8ArrayToString(heap, idx, maxBytesToRead) {
+ idx >>>= 0;
+ var endIdx = idx + maxBytesToRead;
+ var endPtr = idx;
+ while (heap[endPtr >>> 0] && !(endPtr >= endIdx)) ++endPtr;
+ if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
+  return UTF8Decoder.decode(heap.subarray(idx >>> 0, endPtr >>> 0));
+ } else {
+  var str = "";
+  while (idx < endPtr) {
+   var u0 = heap[idx++ >>> 0];
+   if (!(u0 & 128)) {
+    str += String.fromCharCode(u0);
+    continue;
+   }
+   var u1 = heap[idx++ >>> 0] & 63;
+   if ((u0 & 224) == 192) {
+    str += String.fromCharCode((u0 & 31) << 6 | u1);
+    continue;
+   }
+   var u2 = heap[idx++ >>> 0] & 63;
+   if ((u0 & 240) == 224) {
+    u0 = (u0 & 15) << 12 | u1 << 6 | u2;
+   } else {
+    u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heap[idx++ >>> 0] & 63;
+   }
+   if (u0 < 65536) {
+    str += String.fromCharCode(u0);
+   } else {
+    var ch = u0 - 65536;
+    str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+   }
+  }
+ }
+ return str;
+}
+
+function UTF8ToString(ptr, maxBytesToRead) {
+ ptr >>>= 0;
+ return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+}
+
+function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
+ outIdx >>>= 0;
+ if (!(maxBytesToWrite > 0)) return 0;
+ var startIdx = outIdx;
+ var endIdx = outIdx + maxBytesToWrite - 1;
+ for (var i = 0; i < str.length; ++i) {
+  var u = str.charCodeAt(i);
+  if (u >= 55296 && u <= 57343) {
+   var u1 = str.charCodeAt(++i);
+   u = 65536 + ((u & 1023) << 10) | u1 & 1023;
+  }
+  if (u <= 127) {
+   if (outIdx >= endIdx) break;
+   heap[outIdx++ >>> 0] = u;
+  } else if (u <= 2047) {
+   if (outIdx + 1 >= endIdx) break;
+   heap[outIdx++ >>> 0] = 192 | u >> 6;
+   heap[outIdx++ >>> 0] = 128 | u & 63;
+  } else if (u <= 65535) {
+   if (outIdx + 2 >= endIdx) break;
+   heap[outIdx++ >>> 0] = 224 | u >> 12;
+   heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
+   heap[outIdx++ >>> 0] = 128 | u & 63;
+  } else {
+   if (outIdx + 3 >= endIdx) break;
+   heap[outIdx++ >>> 0] = 240 | u >> 18;
+   heap[outIdx++ >>> 0] = 128 | u >> 12 & 63;
+   heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
+   heap[outIdx++ >>> 0] = 128 | u & 63;
+  }
+ }
+ heap[outIdx >>> 0] = 0;
+ return outIdx - startIdx;
+}
+
+function stringToUTF8(str, outPtr, maxBytesToWrite) {
+ return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+}
+
+function lengthBytesUTF8(str) {
+ var len = 0;
+ for (var i = 0; i < str.length; ++i) {
+  var u = str.charCodeAt(i);
+  if (u >= 55296 && u <= 57343) u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
+  if (u <= 127) ++len; else if (u <= 2047) len += 2; else if (u <= 65535) len += 3; else len += 4;
+ }
+ return len;
+}
+
+var UTF16Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : undefined;
+
+function UTF16ToString(ptr, maxBytesToRead) {
+ var endPtr = ptr;
+ var idx = endPtr >> 1;
+ var maxIdx = idx + maxBytesToRead / 2;
+ while (!(idx >= maxIdx) && HEAPU16[idx >>> 0]) ++idx;
+ endPtr = idx << 1;
+ if (endPtr - ptr > 32 && UTF16Decoder) {
+  return UTF16Decoder.decode(HEAPU8.subarray(ptr >>> 0, endPtr >>> 0));
+ } else {
+  var i = 0;
+  var str = "";
+  while (1) {
+   var codeUnit = HEAP16[ptr + i * 2 >>> 1];
+   if (codeUnit == 0 || i == maxBytesToRead / 2) return str;
+   ++i;
+   str += String.fromCharCode(codeUnit);
+  }
+ }
+}
+
+function stringToUTF16(str, outPtr, maxBytesToWrite) {
+ if (maxBytesToWrite === undefined) {
+  maxBytesToWrite = 2147483647;
+ }
+ if (maxBytesToWrite < 2) return 0;
+ maxBytesToWrite -= 2;
+ var startPtr = outPtr;
+ var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
+ for (var i = 0; i < numCharsToWrite; ++i) {
+  var codeUnit = str.charCodeAt(i);
+  HEAP16[outPtr >>> 1] = codeUnit;
+  outPtr += 2;
+ }
+ HEAP16[outPtr >>> 1] = 0;
+ return outPtr - startPtr;
+}
+
+function lengthBytesUTF16(str) {
+ return str.length * 2;
+}
+
+function UTF32ToString(ptr, maxBytesToRead) {
+ var i = 0;
+ var str = "";
+ while (!(i >= maxBytesToRead / 4)) {
+  var utf32 = HEAP32[ptr + i * 4 >>> 2];
+  if (utf32 == 0) break;
+  ++i;
+  if (utf32 >= 65536) {
+   var ch = utf32 - 65536;
+   str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+  } else {
+   str += String.fromCharCode(utf32);
+  }
+ }
+ return str;
+}
+
+function stringToUTF32(str, outPtr, maxBytesToWrite) {
+ outPtr >>>= 0;
+ if (maxBytesToWrite === undefined) {
+  maxBytesToWrite = 2147483647;
+ }
+ if (maxBytesToWrite < 4) return 0;
+ var startPtr = outPtr;
+ var endPtr = startPtr + maxBytesToWrite - 4;
+ for (var i = 0; i < str.length; ++i) {
+  var codeUnit = str.charCodeAt(i);
+  if (codeUnit >= 55296 && codeUnit <= 57343) {
+   var trailSurrogate = str.charCodeAt(++i);
+   codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
+  }
+  HEAP32[outPtr >>> 2] = codeUnit;
+  outPtr += 4;
+  if (outPtr + 4 > endPtr) break;
+ }
+ HEAP32[outPtr >>> 2] = 0;
+ return outPtr - startPtr;
+}
+
+function lengthBytesUTF32(str) {
+ var len = 0;
+ for (var i = 0; i < str.length; ++i) {
+  var codeUnit = str.charCodeAt(i);
+  if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
+  len += 4;
+ }
+ return len;
+}
+
+function writeArrayToMemory(array, buffer) {
+ HEAP8.set(array, buffer >>> 0);
+}
+
+function writeAsciiToMemory(str, buffer, dontAddNull) {
+ for (var i = 0; i < str.length; ++i) {
+  HEAP8[buffer++ >>> 0] = str.charCodeAt(i);
+ }
+ if (!dontAddNull) HEAP8[buffer >>> 0] = 0;
+}
+
+var WASM_PAGE_SIZE = 65536;
+
+function alignUp(x, multiple) {
+ if (x % multiple > 0) {
+  x += multiple - x % multiple;
+ }
+ return x;
+}
+
+var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+function updateGlobalBufferAndViews(buf) {
+ buffer = buf;
+ Module["HEAP8"] = HEAP8 = new Int8Array(buf);
+ Module["HEAP16"] = HEAP16 = new Int16Array(buf);
+ Module["HEAP32"] = HEAP32 = new Int32Array(buf);
+ Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
+ Module["HEAPU16"] = HEAPU16 = new Uint16Array(buf);
+ Module["HEAPU32"] = HEAPU32 = new Uint32Array(buf);
+ Module["HEAPF32"] = HEAPF32 = new Float32Array(buf);
+ Module["HEAPF64"] = HEAPF64 = new Float64Array(buf);
+}
+
+var DYNAMIC_BASE = 5517328, DYNAMICTOP_PTR = 274288;
+
+var INITIAL_INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 16777216;
+
+if (Module["wasmMemory"]) {
+ wasmMemory = Module["wasmMemory"];
+} else {
+ wasmMemory = new WebAssembly.Memory({
+  "initial": INITIAL_INITIAL_MEMORY / WASM_PAGE_SIZE,
+  "maximum": 4294967296 / WASM_PAGE_SIZE
+ });
+}
+
+if (wasmMemory) {
+ buffer = wasmMemory.buffer;
+}
+
+INITIAL_INITIAL_MEMORY = buffer.byteLength;
+
+updateGlobalBufferAndViews(buffer);
+
+HEAP32[DYNAMICTOP_PTR >>> 2] = DYNAMIC_BASE;
+
+function callRuntimeCallbacks(callbacks) {
+ while (callbacks.length > 0) {
+  var callback = callbacks.shift();
+  if (typeof callback == "function") {
+   callback(Module);
+   continue;
+  }
+  var func = callback.func;
+  if (typeof func === "number") {
+   if (callback.arg === undefined) {
+    Module["dynCall_v"](func);
+   } else {
+    Module["dynCall_vi"](func, callback.arg);
+   }
+  } else {
+   func(callback.arg === undefined ? null : callback.arg);
+  }
+ }
+}
+
+var __ATPRERUN__ = [];
+
+var __ATINIT__ = [];
+
+var __ATMAIN__ = [];
+
+var __ATPOSTRUN__ = [];
+
+var runtimeInitialized = false;
+
+function preRun() {
+ if (Module["preRun"]) {
+  if (typeof Module["preRun"] == "function") Module["preRun"] = [ Module["preRun"] ];
+  while (Module["preRun"].length) {
+   addOnPreRun(Module["preRun"].shift());
+  }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function initRuntime() {
+ runtimeInitialized = true;
+ if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
+ TTY.init();
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ FS.ignorePermissions = false;
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function postRun() {
+ if (Module["postRun"]) {
+  if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ];
+  while (Module["postRun"].length) {
+   addOnPostRun(Module["postRun"].shift());
+  }
+ }
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+
+var Math_abs = Math.abs;
+
+var Math_ceil = Math.ceil;
+
+var Math_floor = Math.floor;
+
+var Math_min = Math.min;
+
+var runDependencies = 0;
+
+var runDependencyWatcher = null;
+
+var dependenciesFulfilled = null;
+
+function getUniqueRunDependency(id) {
+ return id;
+}
+
+function addRunDependency(id) {
+ runDependencies++;
+ if (Module["monitorRunDependencies"]) {
+  Module["monitorRunDependencies"](runDependencies);
+ }
+}
+
+function removeRunDependency(id) {
+ runDependencies--;
+ if (Module["monitorRunDependencies"]) {
+  Module["monitorRunDependencies"](runDependencies);
+ }
+ if (runDependencies == 0) {
+  if (runDependencyWatcher !== null) {
+   clearInterval(runDependencyWatcher);
+   runDependencyWatcher = null;
+  }
+  if (dependenciesFulfilled) {
+   var callback = dependenciesFulfilled;
+   dependenciesFulfilled = null;
+   callback();
+  }
+ }
+}
+
+Module["preloadedImages"] = {};
+
+Module["preloadedAudios"] = {};
+
+function abort(what) {
+ if (Module["onAbort"]) {
+  Module["onAbort"](what);
+ }
+ what += "";
+ err(what);
+ ABORT = true;
+ EXITSTATUS = 1;
+ what = "abort(" + what + "). Build with -s ASSERTIONS=1 for more info.";
+ var e = new WebAssembly.RuntimeError(what);
+ readyPromiseReject(e);
+ throw e;
+}
+
+function hasPrefix(str, prefix) {
+ return String.prototype.startsWith ? str.startsWith(prefix) : str.indexOf(prefix) === 0;
+}
+
+var dataURIPrefix = "data:application/octet-stream;base64,";
+
+function isDataURI(filename) {
+ return hasPrefix(filename, dataURIPrefix);
+}
+
+var fileURIPrefix = "file://";
+
+function isFileURI(filename) {
+ return hasPrefix(filename, fileURIPrefix);
+}
+
+var wasmBinaryFile = "jxl_enc.wasm";
+
+if (!isDataURI(wasmBinaryFile)) {
+ wasmBinaryFile = locateFile(wasmBinaryFile);
+}
+
+function getBinary() {
+ try {
+  if (wasmBinary) {
+   return new Uint8Array(wasmBinary);
+  }
+  if (readBinary) {
+   return readBinary(wasmBinaryFile);
+  } else {
+   throw "both async and sync fetching of the wasm failed";
+  }
+ } catch (err) {
+  abort(err);
+ }
+}
+
+function getBinaryPromise() {
+ if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === "function" && !isFileURI(wasmBinaryFile)) {
+  return fetch(wasmBinaryFile, {
+   credentials: "same-origin"
+  }).then(function(response) {
+   if (!response["ok"]) {
+    throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
+   }
+   return response["arrayBuffer"]();
+  }).catch(function() {
+   return getBinary();
+  });
+ }
+ return new Promise(function(resolve, reject) {
+  resolve(getBinary());
+ });
+}
+
+function createWasm() {
+ var info = {
+  "a": asmLibraryArg
+ };
+ function receiveInstance(instance, module) {
+  var exports = instance.exports;
+  Module["asm"] = exports;
+  removeRunDependency("wasm-instantiate");
+ }
+ addRunDependency("wasm-instantiate");
+ function receiveInstantiatedSource(output) {
+  receiveInstance(output["instance"]);
+ }
+ function instantiateArrayBuffer(receiver) {
+  return getBinaryPromise().then(function(binary) {
+   return WebAssembly.instantiate(binary, info);
+  }).then(receiver, function(reason) {
+   err("failed to asynchronously prepare wasm: " + reason);
+   abort(reason);
+  });
+ }
+ function instantiateAsync() {
+  if (!wasmBinary && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && !isFileURI(wasmBinaryFile) && typeof fetch === "function") {
+   fetch(wasmBinaryFile, {
+    credentials: "same-origin"
+   }).then(function(response) {
+    var result = WebAssembly.instantiateStreaming(response, info);
+    return result.then(receiveInstantiatedSource, function(reason) {
+     err("wasm streaming compile failed: " + reason);
+     err("falling back to ArrayBuffer instantiation");
+     return instantiateArrayBuffer(receiveInstantiatedSource);
+    });
+   });
+  } else {
+   return instantiateArrayBuffer(receiveInstantiatedSource);
+  }
+ }
+ if (Module["instantiateWasm"]) {
+  try {
+   var exports = Module["instantiateWasm"](info, receiveInstance);
+   return exports;
+  } catch (e) {
+   err("Module.instantiateWasm callback failed with error: " + e);
+   return false;
+  }
+ }
+ instantiateAsync();
+ return {};
+}
+
+var tempDouble;
+
+var tempI64;
+
+__ATINIT__.push({
+ func: function() {
+  ___wasm_call_ctors();
+ }
+});
+
+function demangle(func) {
+ return func;
+}
+
+function demangleAll(text) {
+ var regex = /\b_Z[\w\d_]+/g;
+ return text.replace(regex, function(x) {
+  var y = demangle(x);
+  return x === y ? x : y + " [" + x + "]";
+ });
+}
+
+function jsStackTrace() {
+ var err = new Error();
+ if (!err.stack) {
+  try {
+   throw new Error();
+  } catch (e) {
+   err = e;
+  }
+  if (!err.stack) {
+   return "(no stack trace available)";
+  }
+ }
+ return err.stack.toString();
+}
+
+function stackTrace() {
+ var js = jsStackTrace();
+ if (Module["extraStackTrace"]) js += "\n" + Module["extraStackTrace"]();
+ return demangleAll(js);
+}
+
+function ___cxa_allocate_exception(size) {
+ return _malloc(size);
+}
+
+function _atexit(func, arg) {}
+
+function ___cxa_thread_atexit(a0, a1) {
+ return _atexit(a0, a1);
+}
+
+var exceptionInfos = {};
+
+var exceptionLast = 0;
+
+function __ZSt18uncaught_exceptionv() {
+ return __ZSt18uncaught_exceptionv.uncaught_exceptions > 0;
+}
+
+function ___cxa_throw(ptr, type, destructor) {
+ exceptionInfos[ptr] = {
+  ptr: ptr,
+  adjusted: [ ptr ],
+  type: type,
+  destructor: destructor,
+  refcount: 0,
+  caught: false,
+  rethrown: false
+ };
+ exceptionLast = ptr;
+ if (!("uncaught_exception" in __ZSt18uncaught_exceptionv)) {
+  __ZSt18uncaught_exceptionv.uncaught_exceptions = 1;
+ } else {
+  __ZSt18uncaught_exceptionv.uncaught_exceptions++;
+ }
+ throw ptr;
+}
+
+function setErrNo(value) {
+ HEAP32[___errno_location() >>> 2] = value;
+ return value;
+}
+
+function ___map_file(pathname, size) {
+ setErrNo(63);
+ return -1;
+}
+
+var PATH = {
+ splitPath: function(filename) {
+  var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+  return splitPathRe.exec(filename).slice(1);
+ },
+ normalizeArray: function(parts, allowAboveRoot) {
+  var up = 0;
+  for (var i = parts.length - 1; i >= 0; i--) {
+   var last = parts[i];
+   if (last === ".") {
+    parts.splice(i, 1);
+   } else if (last === "..") {
+    parts.splice(i, 1);
+    up++;
+   } else if (up) {
+    parts.splice(i, 1);
+    up--;
+   }
+  }
+  if (allowAboveRoot) {
+   for (;up; up--) {
+    parts.unshift("..");
+   }
+  }
+  return parts;
+ },
+ normalize: function(path) {
+  var isAbsolute = path.charAt(0) === "/", trailingSlash = path.substr(-1) === "/";
+  path = PATH.normalizeArray(path.split("/").filter(function(p) {
+   return !!p;
+  }), !isAbsolute).join("/");
+  if (!path && !isAbsolute) {
+   path = ".";
+  }
+  if (path && trailingSlash) {
+   path += "/";
+  }
+  return (isAbsolute ? "/" : "") + path;
+ },
+ dirname: function(path) {
+  var result = PATH.splitPath(path), root = result[0], dir = result[1];
+  if (!root && !dir) {
+   return ".";
+  }
+  if (dir) {
+   dir = dir.substr(0, dir.length - 1);
+  }
+  return root + dir;
+ },
+ basename: function(path) {
+  if (path === "/") return "/";
+  var lastSlash = path.lastIndexOf("/");
+  if (lastSlash === -1) return path;
+  return path.substr(lastSlash + 1);
+ },
+ extname: function(path) {
+  return PATH.splitPath(path)[3];
+ },
+ join: function() {
+  var paths = Array.prototype.slice.call(arguments, 0);
+  return PATH.normalize(paths.join("/"));
+ },
+ join2: function(l, r) {
+  return PATH.normalize(l + "/" + r);
+ }
+};
+
+var PATH_FS = {
+ resolve: function() {
+  var resolvedPath = "", resolvedAbsolute = false;
+  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+   var path = i >= 0 ? arguments[i] : FS.cwd();
+   if (typeof path !== "string") {
+    throw new TypeError("Arguments to path.resolve must be strings");
+   } else if (!path) {
+    return "";
+   }
+   resolvedPath = path + "/" + resolvedPath;
+   resolvedAbsolute = path.charAt(0) === "/";
+  }
+  resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(function(p) {
+   return !!p;
+  }), !resolvedAbsolute).join("/");
+  return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
+ },
+ relative: function(from, to) {
+  from = PATH_FS.resolve(from).substr(1);
+  to = PATH_FS.resolve(to).substr(1);
+  function trim(arr) {
+   var start = 0;
+   for (;start < arr.length; start++) {
+    if (arr[start] !== "") break;
+   }
+   var end = arr.length - 1;
+   for (;end >= 0; end--) {
+    if (arr[end] !== "") break;
+   }
+   if (start > end) return [];
+   return arr.slice(start, end - start + 1);
+  }
+  var fromParts = trim(from.split("/"));
+  var toParts = trim(to.split("/"));
+  var length = Math.min(fromParts.length, toParts.length);
+  var samePartsLength = length;
+  for (var i = 0; i < length; i++) {
+   if (fromParts[i] !== toParts[i]) {
+    samePartsLength = i;
+    break;
+   }
+  }
+  var outputParts = [];
+  for (var i = samePartsLength; i < fromParts.length; i++) {
+   outputParts.push("..");
+  }
+  outputParts = outputParts.concat(toParts.slice(samePartsLength));
+  return outputParts.join("/");
+ }
+};
+
+var TTY = {
+ ttys: [],
+ init: function() {},
+ shutdown: function() {},
+ register: function(dev, ops) {
+  TTY.ttys[dev] = {
+   input: [],
+   output: [],
+   ops: ops
+  };
+  FS.registerDevice(dev, TTY.stream_ops);
+ },
+ stream_ops: {
+  open: function(stream) {
+   var tty = TTY.ttys[stream.node.rdev];
+   if (!tty) {
+    throw new FS.ErrnoError(43);
+   }
+   stream.tty = tty;
+   stream.seekable = false;
+  },
+  close: function(stream) {
+   stream.tty.ops.flush(stream.tty);
+  },
+  flush: function(stream) {
+   stream.tty.ops.flush(stream.tty);
+  },
+  read: function(stream, buffer, offset, length, pos) {
+   if (!stream.tty || !stream.tty.ops.get_char) {
+    throw new FS.ErrnoError(60);
+   }
+   var bytesRead = 0;
+   for (var i = 0; i < length; i++) {
+    var result;
+    try {
+     result = stream.tty.ops.get_char(stream.tty);
+    } catch (e) {
+     throw new FS.ErrnoError(29);
+    }
+    if (result === undefined && bytesRead === 0) {
+     throw new FS.ErrnoError(6);
+    }
+    if (result === null || result === undefined) break;
+    bytesRead++;
+    buffer[offset + i] = result;
+   }
+   if (bytesRead) {
+    stream.node.timestamp = Date.now();
+   }
+   return bytesRead;
+  },
+  write: function(stream, buffer, offset, length, pos) {
+   if (!stream.tty || !stream.tty.ops.put_char) {
+    throw new FS.ErrnoError(60);
+   }
+   try {
+    for (var i = 0; i < length; i++) {
+     stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
+    }
+   } catch (e) {
+    throw new FS.ErrnoError(29);
+   }
+   if (length) {
+    stream.node.timestamp = Date.now();
+   }
+   return i;
+  }
+ },
+ default_tty_ops: {
+  get_char: function(tty) {
+   if (!tty.input.length) {
+    var result = null;
+    if (ENVIRONMENT_IS_NODE) {
+     var BUFSIZE = 256;
+     var buf = Buffer.alloc ? Buffer.alloc(BUFSIZE) : new Buffer(BUFSIZE);
+     var bytesRead = 0;
+     try {
+      bytesRead = nodeFS.readSync(process.stdin.fd, buf, 0, BUFSIZE, null);
+     } catch (e) {
+      if (e.toString().indexOf("EOF") != -1) bytesRead = 0; else throw e;
+     }
+     if (bytesRead > 0) {
+      result = buf.slice(0, bytesRead).toString("utf-8");
+     } else {
+      result = null;
+     }
+    } else if (typeof window != "undefined" && typeof window.prompt == "function") {
+     result = window.prompt("Input: ");
+     if (result !== null) {
+      result += "\n";
+     }
+    } else if (typeof readline == "function") {
+     result = readline();
+     if (result !== null) {
+      result += "\n";
+     }
+    }
+    if (!result) {
+     return null;
+    }
+    tty.input = intArrayFromString(result, true);
+   }
+   return tty.input.shift();
+  },
+  put_char: function(tty, val) {
+   if (val === null || val === 10) {
+    out(UTF8ArrayToString(tty.output, 0));
+    tty.output = [];
+   } else {
+    if (val != 0) tty.output.push(val);
+   }
+  },
+  flush: function(tty) {
+   if (tty.output && tty.output.length > 0) {
+    out(UTF8ArrayToString(tty.output, 0));
+    tty.output = [];
+   }
+  }
+ },
+ default_tty1_ops: {
+  put_char: function(tty, val) {
+   if (val === null || val === 10) {
+    err(UTF8ArrayToString(tty.output, 0));
+    tty.output = [];
+   } else {
+    if (val != 0) tty.output.push(val);
+   }
+  },
+  flush: function(tty) {
+   if (tty.output && tty.output.length > 0) {
+    err(UTF8ArrayToString(tty.output, 0));
+    tty.output = [];
+   }
+  }
+ }
+};
+
+var MEMFS = {
+ ops_table: null,
+ mount: function(mount) {
+  return MEMFS.createNode(null, "/", 16384 | 511, 0);
+ },
+ createNode: function(parent, name, mode, dev) {
+  if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+   throw new FS.ErrnoError(63);
+  }
+  if (!MEMFS.ops_table) {
+   MEMFS.ops_table = {
+    dir: {
+     node: {
+      getattr: MEMFS.node_ops.getattr,
+      setattr: MEMFS.node_ops.setattr,
+      lookup: MEMFS.node_ops.lookup,
+      mknod: MEMFS.node_ops.mknod,
+      rename: MEMFS.node_ops.rename,
+      unlink: MEMFS.node_ops.unlink,
+      rmdir: MEMFS.node_ops.rmdir,
+      readdir: MEMFS.node_ops.readdir,
+      symlink: MEMFS.node_ops.symlink
+     },
+     stream: {
+      llseek: MEMFS.stream_ops.llseek
+     }
+    },
+    file: {
+     node: {
+      getattr: MEMFS.node_ops.getattr,
+      setattr: MEMFS.node_ops.setattr
+     },
+     stream: {
+      llseek: MEMFS.stream_ops.llseek,
+      read: MEMFS.stream_ops.read,
+      write: MEMFS.stream_ops.write,
+      allocate: MEMFS.stream_ops.allocate,
+      mmap: MEMFS.stream_ops.mmap,
+      msync: MEMFS.stream_ops.msync
+     }
+    },
+    link: {
+     node: {
+      getattr: MEMFS.node_ops.getattr,
+      setattr: MEMFS.node_ops.setattr,
+      readlink: MEMFS.node_ops.readlink
+     },
+     stream: {}
+    },
+    chrdev: {
+     node: {
+      getattr: MEMFS.node_ops.getattr,
+      setattr: MEMFS.node_ops.setattr
+     },
+     stream: FS.chrdev_stream_ops
+    }
+   };
+  }
+  var node = FS.createNode(parent, name, mode, dev);
+  if (FS.isDir(node.mode)) {
+   node.node_ops = MEMFS.ops_table.dir.node;
+   node.stream_ops = MEMFS.ops_table.dir.stream;
+   node.contents = {};
+  } else if (FS.isFile(node.mode)) {
+   node.node_ops = MEMFS.ops_table.file.node;
+   node.stream_ops = MEMFS.ops_table.file.stream;
+   node.usedBytes = 0;
+   node.contents = null;
+  } else if (FS.isLink(node.mode)) {
+   node.node_ops = MEMFS.ops_table.link.node;
+   node.stream_ops = MEMFS.ops_table.link.stream;
+  } else if (FS.isChrdev(node.mode)) {
+   node.node_ops = MEMFS.ops_table.chrdev.node;
+   node.stream_ops = MEMFS.ops_table.chrdev.stream;
+  }
+  node.timestamp = Date.now();
+  if (parent) {
+   parent.contents[name] = node;
+  }
+  return node;
+ },
+ getFileDataAsRegularArray: function(node) {
+  if (node.contents && node.contents.subarray) {
+   var arr = [];
+   for (var i = 0; i < node.usedBytes; ++i) arr.push(node.contents[i]);
+   return arr;
+  }
+  return node.contents;
+ },
+ getFileDataAsTypedArray: function(node) {
+  if (!node.contents) return new Uint8Array(0);
+  if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes);
+  return new Uint8Array(node.contents);
+ },
+ expandFileStorage: function(node, newCapacity) {
+  newCapacity >>>= 0;
+  var prevCapacity = node.contents ? node.contents.length : 0;
+  if (prevCapacity >= newCapacity) return;
+  var CAPACITY_DOUBLING_MAX = 1024 * 1024;
+  newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
+  if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
+  var oldContents = node.contents;
+  node.contents = new Uint8Array(newCapacity);
+  if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
+  return;
+ },
+ resizeFileStorage: function(node, newSize) {
+  newSize >>>= 0;
+  if (node.usedBytes == newSize) return;
+  if (newSize == 0) {
+   node.contents = null;
+   node.usedBytes = 0;
+   return;
+  }
+  if (!node.contents || node.contents.subarray) {
+   var oldContents = node.contents;
+   node.contents = new Uint8Array(newSize);
+   if (oldContents) {
+    node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
+   }
+   node.usedBytes = newSize;
+   return;
+  }
+  if (!node.contents) node.contents = [];
+  if (node.contents.length > newSize) node.contents.length = newSize; else while (node.contents.length < newSize) node.contents.push(0);
+  node.usedBytes = newSize;
+ },
+ node_ops: {
+  getattr: function(node) {
+   var attr = {};
+   attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+   attr.ino = node.id;
+   attr.mode = node.mode;
+   attr.nlink = 1;
+   attr.uid = 0;
+   attr.gid = 0;
+   attr.rdev = node.rdev;
+   if (FS.isDir(node.mode)) {
+    attr.size = 4096;
+   } else if (FS.isFile(node.mode)) {
+    attr.size = node.usedBytes;
+   } else if (FS.isLink(node.mode)) {
+    attr.size = node.link.length;
+   } else {
+    attr.size = 0;
+   }
+   attr.atime = new Date(node.timestamp);
+   attr.mtime = new Date(node.timestamp);
+   attr.ctime = new Date(node.timestamp);
+   attr.blksize = 4096;
+   attr.blocks = Math.ceil(attr.size / attr.blksize);
+   return attr;
+  },
+  setattr: function(node, attr) {
+   if (attr.mode !== undefined) {
+    node.mode = attr.mode;
+   }
+   if (attr.timestamp !== undefined) {
+    node.timestamp = attr.timestamp;
+   }
+   if (attr.size !== undefined) {
+    MEMFS.resizeFileStorage(node, attr.size);
+   }
+  },
+  lookup: function(parent, name) {
+   throw FS.genericErrors[44];
+  },
+  mknod: function(parent, name, mode, dev) {
+   return MEMFS.createNode(parent, name, mode, dev);
+  },
+  rename: function(old_node, new_dir, new_name) {
+   if (FS.isDir(old_node.mode)) {
+    var new_node;
+    try {
+     new_node = FS.lookupNode(new_dir, new_name);
+    } catch (e) {}
+    if (new_node) {
+     for (var i in new_node.contents) {
+      throw new FS.ErrnoError(55);
+     }
+    }
+   }
+   delete old_node.parent.contents[old_node.name];
+   old_node.name = new_name;
+   new_dir.contents[new_name] = old_node;
+   old_node.parent = new_dir;
+  },
+  unlink: function(parent, name) {
+   delete parent.contents[name];
+  },
+  rmdir: function(parent, name) {
+   var node = FS.lookupNode(parent, name);
+   for (var i in node.contents) {
+    throw new FS.ErrnoError(55);
+   }
+   delete parent.contents[name];
+  },
+  readdir: function(node) {
+   var entries = [ ".", ".." ];
+   for (var key in node.contents) {
+    if (!node.contents.hasOwnProperty(key)) {
+     continue;
+    }
+    entries.push(key);
+   }
+   return entries;
+  },
+  symlink: function(parent, newname, oldpath) {
+   var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
+   node.link = oldpath;
+   return node;
+  },
+  readlink: function(node) {
+   if (!FS.isLink(node.mode)) {
+    throw new FS.ErrnoError(28);
+   }
+   return node.link;
+  }
+ },
+ stream_ops: {
+  read: function(stream, buffer, offset, length, position) {
+   var contents = stream.node.contents;
+   if (position >= stream.node.usedBytes) return 0;
+   var size = Math.min(stream.node.usedBytes - position, length);
+   if (size > 8 && contents.subarray) {
+    buffer.set(contents.subarray(position, position + size), offset);
+   } else {
+    for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i];
+   }
+   return size;
+  },
+  write: function(stream, buffer, offset, length, position, canOwn) {
+   if (buffer.buffer === HEAP8.buffer) {
+    canOwn = false;
+   }
+   if (!length) return 0;
+   var node = stream.node;
+   node.timestamp = Date.now();
+   if (buffer.subarray && (!node.contents || node.contents.subarray)) {
+    if (canOwn) {
+     node.contents = buffer.subarray(offset, offset + length);
+     node.usedBytes = length;
+     return length;
+    } else if (node.usedBytes === 0 && position === 0) {
+     node.contents = buffer.slice(offset, offset + length);
+     node.usedBytes = length;
+     return length;
+    } else if (position + length <= node.usedBytes) {
+     node.contents.set(buffer.subarray(offset, offset + length), position);
+     return length;
+    }
+   }
+   MEMFS.expandFileStorage(node, position + length);
+   if (node.contents.subarray && buffer.subarray) {
+    node.contents.set(buffer.subarray(offset, offset + length), position);
+   } else {
+    for (var i = 0; i < length; i++) {
+     node.contents[position + i] = buffer[offset + i];
+    }
+   }
+   node.usedBytes = Math.max(node.usedBytes, position + length);
+   return length;
+  },
+  llseek: function(stream, offset, whence) {
+   var position = offset;
+   if (whence === 1) {
+    position += stream.position;
+   } else if (whence === 2) {
+    if (FS.isFile(stream.node.mode)) {
+     position += stream.node.usedBytes;
+    }
+   }
+   if (position < 0) {
+    throw new FS.ErrnoError(28);
+   }
+   return position;
+  },
+  allocate: function(stream, offset, length) {
+   MEMFS.expandFileStorage(stream.node, offset + length);
+   stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
+  },
+  mmap: function(stream, address, length, position, prot, flags) {
+   assert(address === 0);
+   if (!FS.isFile(stream.node.mode)) {
+    throw new FS.ErrnoError(43);
+   }
+   var ptr;
+   var allocated;
+   var contents = stream.node.contents;
+   if (!(flags & 2) && contents.buffer === buffer) {
+    allocated = false;
+    ptr = contents.byteOffset;
+   } else {
+    if (position > 0 || position + length < contents.length) {
+     if (contents.subarray) {
+      contents = contents.subarray(position, position + length);
+     } else {
+      contents = Array.prototype.slice.call(contents, position, position + length);
+     }
+    }
+    allocated = true;
+    ptr = FS.mmapAlloc(length);
+    if (!ptr) {
+     throw new FS.ErrnoError(48);
+    }
+    ptr >>>= 0;
+    HEAP8.set(contents, ptr >>> 0);
+   }
+   return {
+    ptr: ptr,
+    allocated: allocated
+   };
+  },
+  msync: function(stream, buffer, offset, length, mmapFlags) {
+   if (!FS.isFile(stream.node.mode)) {
+    throw new FS.ErrnoError(43);
+   }
+   if (mmapFlags & 2) {
+    return 0;
+   }
+   var bytesWritten = MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
+   return 0;
+  }
+ }
+};
+
+var FS = {
+ root: null,
+ mounts: [],
+ devices: {},
+ streams: [],
+ nextInode: 1,
+ nameTable: null,
+ currentPath: "/",
+ initialized: false,
+ ignorePermissions: true,
+ trackingDelegate: {},
+ tracking: {
+  openFlags: {
+   READ: 1,
+   WRITE: 2
+  }
+ },
+ ErrnoError: null,
+ genericErrors: {},
+ filesystems: null,
+ syncFSRequests: 0,
+ handleFSError: function(e) {
+  if (!(e instanceof FS.ErrnoError)) throw e + " : " + stackTrace();
+  return setErrNo(e.errno);
+ },
+ lookupPath: function(path, opts) {
+  path = PATH_FS.resolve(FS.cwd(), path);
+  opts = opts || {};
+  if (!path) return {
+   path: "",
+   node: null
+  };
+  var defaults = {
+   follow_mount: true,
+   recurse_count: 0
+  };
+  for (var key in defaults) {
+   if (opts[key] === undefined) {
+    opts[key] = defaults[key];
+   }
+  }
+  if (opts.recurse_count > 8) {
+   throw new FS.ErrnoError(32);
+  }
+  var parts = PATH.normalizeArray(path.split("/").filter(function(p) {
+   return !!p;
+  }), false);
+  var current = FS.root;
+  var current_path = "/";
+  for (var i = 0; i < parts.length; i++) {
+   var islast = i === parts.length - 1;
+   if (islast && opts.parent) {
+    break;
+   }
+   current = FS.lookupNode(current, parts[i]);
+   current_path = PATH.join2(current_path, parts[i]);
+   if (FS.isMountpoint(current)) {
+    if (!islast || islast && opts.follow_mount) {
+     current = current.mounted.root;
+    }
+   }
+   if (!islast || opts.follow) {
+    var count = 0;
+    while (FS.isLink(current.mode)) {
+     var link = FS.readlink(current_path);
+     current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
+     var lookup = FS.lookupPath(current_path, {
+      recurse_count: opts.recurse_count
+     });
+     current = lookup.node;
+     if (count++ > 40) {
+      throw new FS.ErrnoError(32);
+     }
+    }
+   }
+  }
+  return {
+   path: current_path,
+   node: current
+  };
+ },
+ getPath: function(node) {
+  var path;
+  while (true) {
+   if (FS.isRoot(node)) {
+    var mount = node.mount.mountpoint;
+    if (!path) return mount;
+    return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path;
+   }
+   path = path ? node.name + "/" + path : node.name;
+   node = node.parent;
+  }
+ },
+ hashName: function(parentid, name) {
+  var hash = 0;
+  for (var i = 0; i < name.length; i++) {
+   hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
+  }
+  return (parentid + hash >>> 0) % FS.nameTable.length;
+ },
+ hashAddNode: function(node) {
+  var hash = FS.hashName(node.parent.id, node.name);
+  node.name_next = FS.nameTable[hash];
+  FS.nameTable[hash] = node;
+ },
+ hashRemoveNode: function(node) {
+  var hash = FS.hashName(node.parent.id, node.name);
+  if (FS.nameTable[hash] === node) {
+   FS.nameTable[hash] = node.name_next;
+  } else {
+   var current = FS.nameTable[hash];
+   while (current) {
+    if (current.name_next === node) {
+     current.name_next = node.name_next;
+     break;
+    }
+    current = current.name_next;
+   }
+  }
+ },
+ lookupNode: function(parent, name) {
+  var errCode = FS.mayLookup(parent);
+  if (errCode) {
+   throw new FS.ErrnoError(errCode, parent);
+  }
+  var hash = FS.hashName(parent.id, name);
+  for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+   var nodeName = node.name;
+   if (node.parent.id === parent.id && nodeName === name) {
+    return node;
+   }
+  }
+  return FS.lookup(parent, name);
+ },
+ createNode: function(parent, name, mode, rdev) {
+  var node = new FS.FSNode(parent, name, mode, rdev);
+  FS.hashAddNode(node);
+  return node;
+ },
+ destroyNode: function(node) {
+  FS.hashRemoveNode(node);
+ },
+ isRoot: function(node) {
+  return node === node.parent;
+ },
+ isMountpoint: function(node) {
+  return !!node.mounted;
+ },
+ isFile: function(mode) {
+  return (mode & 61440) === 32768;
+ },
+ isDir: function(mode) {
+  return (mode & 61440) === 16384;
+ },
+ isLink: function(mode) {
+  return (mode & 61440) === 40960;
+ },
+ isChrdev: function(mode) {
+  return (mode & 61440) === 8192;
+ },
+ isBlkdev: function(mode) {
+  return (mode & 61440) === 24576;
+ },
+ isFIFO: function(mode) {
+  return (mode & 61440) === 4096;
+ },
+ isSocket: function(mode) {
+  return (mode & 49152) === 49152;
+ },
+ flagModes: {
+  "r": 0,
+  "rs": 1052672,
+  "r+": 2,
+  "w": 577,
+  "wx": 705,
+  "xw": 705,
+  "w+": 578,
+  "wx+": 706,
+  "xw+": 706,
+  "a": 1089,
+  "ax": 1217,
+  "xa": 1217,
+  "a+": 1090,
+  "ax+": 1218,
+  "xa+": 1218
+ },
+ modeStringToFlags: function(str) {
+  var flags = FS.flagModes[str];
+  if (typeof flags === "undefined") {
+   throw new Error("Unknown file open mode: " + str);
+  }
+  return flags;
+ },
+ flagsToPermissionString: function(flag) {
+  var perms = [ "r", "w", "rw" ][flag & 3];
+  if (flag & 512) {
+   perms += "w";
+  }
+  return perms;
+ },
+ nodePermissions: function(node, perms) {
+  if (FS.ignorePermissions) {
+   return 0;
+  }
+  if (perms.indexOf("r") !== -1 && !(node.mode & 292)) {
+   return 2;
+  } else if (perms.indexOf("w") !== -1 && !(node.mode & 146)) {
+   return 2;
+  } else if (perms.indexOf("x") !== -1 && !(node.mode & 73)) {
+   return 2;
+  }
+  return 0;
+ },
+ mayLookup: function(dir) {
+  var errCode = FS.nodePermissions(dir, "x");
+  if (errCode) return errCode;
+  if (!dir.node_ops.lookup) return 2;
+  return 0;
+ },
+ mayCreate: function(dir, name) {
+  try {
+   var node = FS.lookupNode(dir, name);
+   return 20;
+  } catch (e) {}
+  return FS.nodePermissions(dir, "wx");
+ },
+ mayDelete: function(dir, name, isdir) {
+  var node;
+  try {
+   node = FS.lookupNode(dir, name);
+  } catch (e) {
+   return e.errno;
+  }
+  var errCode = FS.nodePermissions(dir, "wx");
+  if (errCode) {
+   return errCode;
+  }
+  if (isdir) {
+   if (!FS.isDir(node.mode)) {
+    return 54;
+   }
+   if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+    return 10;
+   }
+  } else {
+   if (FS.isDir(node.mode)) {
+    return 31;
+   }
+  }
+  return 0;
+ },
+ mayOpen: function(node, flags) {
+  if (!node) {
+   return 44;
+  }
+  if (FS.isLink(node.mode)) {
+   return 32;
+  } else if (FS.isDir(node.mode)) {
+   if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) {
+    return 31;
+   }
+  }
+  return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+ },
+ MAX_OPEN_FDS: 4096,
+ nextfd: function(fd_start, fd_end) {
+  fd_start = fd_start || 0;
+  fd_end = fd_end || FS.MAX_OPEN_FDS;
+  for (var fd = fd_start; fd <= fd_end; fd++) {
+   if (!FS.streams[fd]) {
+    return fd;
+   }
+  }
+  throw new FS.ErrnoError(33);
+ },
+ getStream: function(fd) {
+  return FS.streams[fd];
+ },
+ createStream: function(stream, fd_start, fd_end) {
+  if (!FS.FSStream) {
+   FS.FSStream = function() {};
+   FS.FSStream.prototype = {
+    object: {
+     get: function() {
+      return this.node;
+     },
+     set: function(val) {
+      this.node = val;
+     }
+    },
+    isRead: {
+     get: function() {
+      return (this.flags & 2097155) !== 1;
+     }
+    },
+    isWrite: {
+     get: function() {
+      return (this.flags & 2097155) !== 0;
+     }
+    },
+    isAppend: {
+     get: function() {
+      return this.flags & 1024;
+     }
+    }
+   };
+  }
+  var newStream = new FS.FSStream();
+  for (var p in stream) {
+   newStream[p] = stream[p];
+  }
+  stream = newStream;
+  var fd = FS.nextfd(fd_start, fd_end);
+  stream.fd = fd;
+  FS.streams[fd] = stream;
+  return stream;
+ },
+ closeStream: function(fd) {
+  FS.streams[fd] = null;
+ },
+ chrdev_stream_ops: {
+  open: function(stream) {
+   var device = FS.getDevice(stream.node.rdev);
+   stream.stream_ops = device.stream_ops;
+   if (stream.stream_ops.open) {
+    stream.stream_ops.open(stream);
+   }
+  },
+  llseek: function() {
+   throw new FS.ErrnoError(70);
+  }
+ },
+ major: function(dev) {
+  return dev >> 8;
+ },
+ minor: function(dev) {
+  return dev & 255;
+ },
+ makedev: function(ma, mi) {
+  return ma << 8 | mi;
+ },
+ registerDevice: function(dev, ops) {
+  FS.devices[dev] = {
+   stream_ops: ops
+  };
+ },
+ getDevice: function(dev) {
+  return FS.devices[dev];
+ },
+ getMounts: function(mount) {
+  var mounts = [];
+  var check = [ mount ];
+  while (check.length) {
+   var m = check.pop();
+   mounts.push(m);
+   check.push.apply(check, m.mounts);
+  }
+  return mounts;
+ },
+ syncfs: function(populate, callback) {
+  if (typeof populate === "function") {
+   callback = populate;
+   populate = false;
+  }
+  FS.syncFSRequests++;
+  if (FS.syncFSRequests > 1) {
+   err("warning: " + FS.syncFSRequests + " FS.syncfs operations in flight at once, probably just doing extra work");
+  }
+  var mounts = FS.getMounts(FS.root.mount);
+  var completed = 0;
+  function doCallback(errCode) {
+   FS.syncFSRequests--;
+   return callback(errCode);
+  }
+  function done(errCode) {
+   if (errCode) {
+    if (!done.errored) {
+     done.errored = true;
+     return doCallback(errCode);
+    }
+    return;
+   }
+   if (++completed >= mounts.length) {
+    doCallback(null);
+   }
+  }
+  mounts.forEach(function(mount) {
+   if (!mount.type.syncfs) {
+    return done(null);
+   }
+   mount.type.syncfs(mount, populate, done);
+  });
+ },
+ mount: function(type, opts, mountpoint) {
+  var root = mountpoint === "/";
+  var pseudo = !mountpoint;
+  var node;
+  if (root && FS.root) {
+   throw new FS.ErrnoError(10);
+  } else if (!root && !pseudo) {
+   var lookup = FS.lookupPath(mountpoint, {
+    follow_mount: false
+   });
+   mountpoint = lookup.path;
+   node = lookup.node;
+   if (FS.isMountpoint(node)) {
+    throw new FS.ErrnoError(10);
+   }
+   if (!FS.isDir(node.mode)) {
+    throw new FS.ErrnoError(54);
+   }
+  }
+  var mount = {
+   type: type,
+   opts: opts,
+   mountpoint: mountpoint,
+   mounts: []
+  };
+  var mountRoot = type.mount(mount);
+  mountRoot.mount = mount;
+  mount.root = mountRoot;
+  if (root) {
+   FS.root = mountRoot;
+  } else if (node) {
+   node.mounted = mount;
+   if (node.mount) {
+    node.mount.mounts.push(mount);
+   }
+  }
+  return mountRoot;
+ },
+ unmount: function(mountpoint) {
+  var lookup = FS.lookupPath(mountpoint, {
+   follow_mount: false
+  });
+  if (!FS.isMountpoint(lookup.node)) {
+   throw new FS.ErrnoError(28);
+  }
+  var node = lookup.node;
+  var mount = node.mounted;
+  var mounts = FS.getMounts(mount);
+  Object.keys(FS.nameTable).forEach(function(hash) {
+   var current = FS.nameTable[hash];
+   while (current) {
+    var next = current.name_next;
+    if (mounts.indexOf(current.mount) !== -1) {
+     FS.destroyNode(current);
+    }
+    current = next;
+   }
+  });
+  node.mounted = null;
+  var idx = node.mount.mounts.indexOf(mount);
+  node.mount.mounts.splice(idx, 1);
+ },
+ lookup: function(parent, name) {
+  return parent.node_ops.lookup(parent, name);
+ },
+ mknod: function(path, mode, dev) {
+  var lookup = FS.lookupPath(path, {
+   parent: true
+  });
+  var parent = lookup.node;
+  var name = PATH.basename(path);
+  if (!name || name === "." || name === "..") {
+   throw new FS.ErrnoError(28);
+  }
+  var errCode = FS.mayCreate(parent, name);
+  if (errCode) {
+   throw new FS.ErrnoError(errCode);
+  }
+  if (!parent.node_ops.mknod) {
+   throw new FS.ErrnoError(63);
+  }
+  return parent.node_ops.mknod(parent, name, mode, dev);
+ },
+ create: function(path, mode) {
+  mode = mode !== undefined ? mode : 438;
+  mode &= 4095;
+  mode |= 32768;
+  return FS.mknod(path, mode, 0);
+ },
+ mkdir: function(path, mode) {
+  mode = mode !== undefined ? mode : 511;
+  mode &= 511 | 512;
+  mode |= 16384;
+  return FS.mknod(path, mode, 0);
+ },
+ mkdirTree: function(path, mode) {
+  var dirs = path.split("/");
+  var d = "";
+  for (var i = 0; i < dirs.length; ++i) {
+   if (!dirs[i]) continue;
+   d += "/" + dirs[i];
+   try {
+    FS.mkdir(d, mode);
+   } catch (e) {
+    if (e.errno != 20) throw e;
+   }
+  }
+ },
+ mkdev: function(path, mode, dev) {
+  if (typeof dev === "undefined") {
+   dev = mode;
+   mode = 438;
+  }
+  mode |= 8192;
+  return FS.mknod(path, mode, dev);
+ },
+ symlink: function(oldpath, newpath) {
+  if (!PATH_FS.resolve(oldpath)) {
+   throw new FS.ErrnoError(44);
+  }
+  var lookup = FS.lookupPath(newpath, {
+   parent: true
+  });
+  var parent = lookup.node;
+  if (!parent) {
+   throw new FS.ErrnoError(44);
+  }
+  var newname = PATH.basename(newpath);
+  var errCode = FS.mayCreate(parent, newname);
+  if (errCode) {
+   throw new FS.ErrnoError(errCode);
+  }
+  if (!parent.node_ops.symlink) {
+   throw new FS.ErrnoError(63);
+  }
+  return parent.node_ops.symlink(parent, newname, oldpath);
+ },
+ rename: function(old_path, new_path) {
+  var old_dirname = PATH.dirname(old_path);
+  var new_dirname = PATH.dirname(new_path);
+  var old_name = PATH.basename(old_path);
+  var new_name = PATH.basename(new_path);
+  var lookup, old_dir, new_dir;
+  try {
+   lookup = FS.lookupPath(old_path, {
+    parent: true
+   });
+   old_dir = lookup.node;
+   lookup = FS.lookupPath(new_path, {
+    parent: true
+   });
+   new_dir = lookup.node;
+  } catch (e) {
+   throw new FS.ErrnoError(10);
+  }
+  if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
+  if (old_dir.mount !== new_dir.mount) {
+   throw new FS.ErrnoError(75);
+  }
+  var old_node = FS.lookupNode(old_dir, old_name);
+  var relative = PATH_FS.relative(old_path, new_dirname);
+  if (relative.charAt(0) !== ".") {
+   throw new FS.ErrnoError(28);
+  }
+  relative = PATH_FS.relative(new_path, old_dirname);
+  if (relative.charAt(0) !== ".") {
+   throw new FS.ErrnoError(55);
+  }
+  var new_node;
+  try {
+   new_node = FS.lookupNode(new_dir, new_name);
+  } catch (e) {}
+  if (old_node === new_node) {
+   return;
+  }
+  var isdir = FS.isDir(old_node.mode);
+  var errCode = FS.mayDelete(old_dir, old_name, isdir);
+  if (errCode) {
+   throw new FS.ErrnoError(errCode);
+  }
+  errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
+  if (errCode) {
+   throw new FS.ErrnoError(errCode);
+  }
+  if (!old_dir.node_ops.rename) {
+   throw new FS.ErrnoError(63);
+  }
+  if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
+   throw new FS.ErrnoError(10);
+  }
+  if (new_dir !== old_dir) {
+   errCode = FS.nodePermissions(old_dir, "w");
+   if (errCode) {
+    throw new FS.ErrnoError(errCode);
+   }
+  }
+  try {
+   if (FS.trackingDelegate["willMovePath"]) {
+    FS.trackingDelegate["willMovePath"](old_path, new_path);
+   }
+  } catch (e) {
+   err("FS.trackingDelegate['willMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message);
+  }
+  FS.hashRemoveNode(old_node);
+  try {
+   old_dir.node_ops.rename(old_node, new_dir, new_name);
+  } catch (e) {
+   throw e;
+  } finally {
+   FS.hashAddNode(old_node);
+  }
+  try {
+   if (FS.trackingDelegate["onMovePath"]) FS.trackingDelegate["onMovePath"](old_path, new_path);
+  } catch (e) {
+   err("FS.trackingDelegate['onMovePath']('" + old_path + "', '" + new_path + "') threw an exception: " + e.message);
+  }
+ },
+ rmdir: function(path) {
+  var lookup = FS.lookupPath(path, {
+   parent: true
+  });
+  var parent = lookup.node;
+  var name = PATH.basename(path);
+  var node = FS.lookupNode(parent, name);
+  var errCode = FS.mayDelete(parent, name, true);
+  if (errCode) {
+   throw new FS.ErrnoError(errCode);
+  }
+  if (!parent.node_ops.rmdir) {
+   throw new FS.ErrnoError(63);
+  }
+  if (FS.isMountpoint(node)) {
+   throw new FS.ErrnoError(10);
+  }
+  try {
+   if (FS.trackingDelegate["willDeletePath"]) {
+    FS.trackingDelegate["willDeletePath"](path);
+   }
+  } catch (e) {
+   err("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message);
+  }
+  parent.node_ops.rmdir(parent, name);
+  FS.destroyNode(node);
+  try {
+   if (FS.trackingDelegate["onDeletePath"]) FS.trackingDelegate["onDeletePath"](path);
+  } catch (e) {
+   err("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message);
+  }
+ },
+ readdir: function(path) {
+  var lookup = FS.lookupPath(path, {
+   follow: true
+  });
+  var node = lookup.node;
+  if (!node.node_ops.readdir) {
+   throw new FS.ErrnoError(54);
+  }
+  return node.node_ops.readdir(node);
+ },
+ unlink: function(path) {
+  var lookup = FS.lookupPath(path, {
+   parent: true
+  });
+  var parent = lookup.node;
+  var name = PATH.basename(path);
+  var node = FS.lookupNode(parent, name);
+  var errCode = FS.mayDelete(parent, name, false);
+  if (errCode) {
+   throw new FS.ErrnoError(errCode);
+  }
+  if (!parent.node_ops.unlink) {
+   throw new FS.ErrnoError(63);
+  }
+  if (FS.isMountpoint(node)) {
+   throw new FS.ErrnoError(10);
+  }
+  try {
+   if (FS.trackingDelegate["willDeletePath"]) {
+    FS.trackingDelegate["willDeletePath"](path);
+   }
+  } catch (e) {
+   err("FS.trackingDelegate['willDeletePath']('" + path + "') threw an exception: " + e.message);
+  }
+  parent.node_ops.unlink(parent, name);
+  FS.destroyNode(node);
+  try {
+   if (FS.trackingDelegate["onDeletePath"]) FS.trackingDelegate["onDeletePath"](path);
+  } catch (e) {
+   err("FS.trackingDelegate['onDeletePath']('" + path + "') threw an exception: " + e.message);
+  }
+ },
+ readlink: function(path) {
+  var lookup = FS.lookupPath(path);
+  var link = lookup.node;
+  if (!link) {
+   throw new FS.ErrnoError(44);
+  }
+  if (!link.node_ops.readlink) {
+   throw new FS.ErrnoError(28);
+  }
+  return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link));
+ },
+ stat: function(path, dontFollow) {
+  var lookup = FS.lookupPath(path, {
+   follow: !dontFollow
+  });
+  var node = lookup.node;
+  if (!node) {
+   throw new FS.ErrnoError(44);
+  }
+  if (!node.node_ops.getattr) {
+   throw new FS.ErrnoError(63);
+  }
+  return node.node_ops.getattr(node);
+ },
+ lstat: function(path) {
+  return FS.stat(path, true);
+ },
+ chmod: function(path, mode, dontFollow) {
+  var node;
+  if (typeof path === "string") {
+   var lookup = FS.lookupPath(path, {
+    follow: !dontFollow
+   });
+   node = lookup.node;
+  } else {
+   node = path;
+  }
+  if (!node.node_ops.setattr) {
+   throw new FS.ErrnoError(63);
+  }
+  node.node_ops.setattr(node, {
+   mode: mode & 4095 | node.mode & ~4095,
+   timestamp: Date.now()
+  });
+ },
+ lchmod: function(path, mode) {
+  FS.chmod(path, mode, true);
+ },
+ fchmod: function(fd, mode) {
+  var stream = FS.getStream(fd);
+  if (!stream) {
+   throw new FS.ErrnoError(8);
+  }
+  FS.chmod(stream.node, mode);
+ },
+ chown: function(path, uid, gid, dontFollow) {
+  var node;
+  if (typeof path === "string") {
+   var lookup = FS.lookupPath(path, {
+    follow: !dontFollow
+   });
+   node = lookup.node;
+  } else {
+   node = path;
+  }
+  if (!node.node_ops.setattr) {
+   throw new FS.ErrnoError(63);
+  }
+  node.node_ops.setattr(node, {
+   timestamp: Date.now()
+  });
+ },
+ lchown: function(path, uid, gid) {
+  FS.chown(path, uid, gid, true);
+ },
+ fchown: function(fd, uid, gid) {
+  var stream = FS.getStream(fd);
+  if (!stream) {
+   throw new FS.ErrnoError(8);
+  }
+  FS.chown(stream.node, uid, gid);
+ },
+ truncate: function(path, len) {
+  if (len < 0) {
+   throw new FS.ErrnoError(28);
+  }
+  var node;
+  if (typeof path === "string") {
+   var lookup = FS.lookupPath(path, {
+    follow: true
+   });
+   node = lookup.node;
+  } else {
+   node = path;
+  }
+  if (!node.node_ops.setattr) {
+   throw new FS.ErrnoError(63);
+  }
+  if (FS.isDir(node.mode)) {
+   throw new FS.ErrnoError(31);
+  }
+  if (!FS.isFile(node.mode)) {
+   throw new FS.ErrnoError(28);
+  }
+  var errCode = FS.nodePermissions(node, "w");
+  if (errCode) {
+   throw new FS.ErrnoError(errCode);
+  }
+  node.node_ops.setattr(node, {
+   size: len,
+   timestamp: Date.now()
+  });
+ },
+ ftruncate: function(fd, len) {
+  var stream = FS.getStream(fd);
+  if (!stream) {
+   throw new FS.ErrnoError(8);
+  }
+  if ((stream.flags & 2097155) === 0) {
+   throw new FS.ErrnoError(28);
+  }
+  FS.truncate(stream.node, len);
+ },
+ utime: function(path, atime, mtime) {
+  var lookup = FS.lookupPath(path, {
+   follow: true
+  });
+  var node = lookup.node;
+  node.node_ops.setattr(node, {
+   timestamp: Math.max(atime, mtime)
+  });
+ },
+ open: function(path, flags, mode, fd_start, fd_end) {
+  if (path === "") {
+   throw new FS.ErrnoError(44);
+  }
+  flags = typeof flags === "string" ? FS.modeStringToFlags(flags) : flags;
+  mode = typeof mode === "undefined" ? 438 : mode;
+  if (flags & 64) {
+   mode = mode & 4095 | 32768;
+  } else {
+   mode = 0;
+  }
+  var node;
+  if (typeof path === "object") {
+   node = path;
+  } else {
+   path = PATH.normalize(path);
+   try {
+    var lookup = FS.lookupPath(path, {
+     follow: !(flags & 131072)
+    });
+    node = lookup.node;
+   } catch (e) {}
+  }
+  var created = false;
+  if (flags & 64) {
+   if (node) {
+    if (flags & 128) {
+     throw new FS.ErrnoError(20);
+    }
+   } else {
+    node = FS.mknod(path, mode, 0);
+    created = true;
+   }
+  }
+  if (!node) {
+   throw new FS.ErrnoError(44);
+  }
+  if (FS.isChrdev(node.mode)) {
+   flags &= ~512;
+  }
+  if (flags & 65536 && !FS.isDir(node.mode)) {
+   throw new FS.ErrnoError(54);
+  }
+  if (!created) {
+   var errCode = FS.mayOpen(node, flags);
+   if (errCode) {
+    throw new FS.ErrnoError(errCode);
+   }
+  }
+  if (flags & 512) {
+   FS.truncate(node, 0);
+  }
+  flags &= ~(128 | 512 | 131072);
+  var stream = FS.createStream({
+   node: node,
+   path: FS.getPath(node),
+   flags: flags,
+   seekable: true,
+   position: 0,
+   stream_ops: node.stream_ops,
+   ungotten: [],
+   error: false
+  }, fd_start, fd_end);
+  if (stream.stream_ops.open) {
+   stream.stream_ops.open(stream);
+  }
+  if (Module["logReadFiles"] && !(flags & 1)) {
+   if (!FS.readFiles) FS.readFiles = {};
+   if (!(path in FS.readFiles)) {
+    FS.readFiles[path] = 1;
+    err("FS.trackingDelegate error on read file: " + path);
+   }
+  }
+  try {
+   if (FS.trackingDelegate["onOpenFile"]) {
+    var trackingFlags = 0;
+    if ((flags & 2097155) !== 1) {
+     trackingFlags |= FS.tracking.openFlags.READ;
+    }
+    if ((flags & 2097155) !== 0) {
+     trackingFlags |= FS.tracking.openFlags.WRITE;
+    }
+    FS.trackingDelegate["onOpenFile"](path, trackingFlags);
+   }
+  } catch (e) {
+   err("FS.trackingDelegate['onOpenFile']('" + path + "', flags) threw an exception: " + e.message);
+  }
+  return stream;
+ },
+ close: function(stream) {
+  if (FS.isClosed(stream)) {
+   throw new FS.ErrnoError(8);
+  }
+  if (stream.getdents) stream.getdents = null;
+  try {
+   if (stream.stream_ops.close) {
+    stream.stream_ops.close(stream);
+   }
+  } catch (e) {
+   throw e;
+  } finally {
+   FS.closeStream(stream.fd);
+  }
+  stream.fd = null;
+ },
+ isClosed: function(stream) {
+  return stream.fd === null;
+ },
+ llseek: function(stream, offset, whence) {
+  if (FS.isClosed(stream)) {
+   throw new FS.ErrnoError(8);
+  }
+  if (!stream.seekable || !stream.stream_ops.llseek) {
+   throw new FS.ErrnoError(70);
+  }
+  if (whence != 0 && whence != 1 && whence != 2) {
+   throw new FS.ErrnoError(28);
+  }
+  stream.position = stream.stream_ops.llseek(stream, offset, whence);
+  stream.ungotten = [];
+  return stream.position;
+ },
+ read: function(stream, buffer, offset, length, position) {
+  offset >>>= 0;
+  if (length < 0 || position < 0) {
+   throw new FS.ErrnoError(28);
+  }
+  if (FS.isClosed(stream)) {
+   throw new FS.ErrnoError(8);
+  }
+  if ((stream.flags & 2097155) === 1) {
+   throw new FS.ErrnoError(8);
+  }
+  if (FS.isDir(stream.node.mode)) {
+   throw new FS.ErrnoError(31);
+  }
+  if (!stream.stream_ops.read) {
+   throw new FS.ErrnoError(28);
+  }
+  var seeking = typeof position !== "undefined";
+  if (!seeking) {
+   position = stream.position;
+  } else if (!stream.seekable) {
+   throw new FS.ErrnoError(70);
+  }
+  var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
+  if (!seeking) stream.position += bytesRead;
+  return bytesRead;
+ },
+ write: function(stream, buffer, offset, length, position, canOwn) {
+  offset >>>= 0;
+  if (length < 0 || position < 0) {
+   throw new FS.ErrnoError(28);
+  }
+  if (FS.isClosed(stream)) {
+   throw new FS.ErrnoError(8);
+  }
+  if ((stream.flags & 2097155) === 0) {
+   throw new FS.ErrnoError(8);
+  }
+  if (FS.isDir(stream.node.mode)) {
+   throw new FS.ErrnoError(31);
+  }
+  if (!stream.stream_ops.write) {
+   throw new FS.ErrnoError(28);
+  }
+  if (stream.seekable && stream.flags & 1024) {
+   FS.llseek(stream, 0, 2);
+  }
+  var seeking = typeof position !== "undefined";
+  if (!seeking) {
+   position = stream.position;
+  } else if (!stream.seekable) {
+   throw new FS.ErrnoError(70);
+  }
+  var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
+  if (!seeking) stream.position += bytesWritten;
+  try {
+   if (stream.path && FS.trackingDelegate["onWriteToFile"]) FS.trackingDelegate["onWriteToFile"](stream.path);
+  } catch (e) {
+   err("FS.trackingDelegate['onWriteToFile']('" + stream.path + "') threw an exception: " + e.message);
+  }
+  return bytesWritten;
+ },
+ allocate: function(stream, offset, length) {
+  if (FS.isClosed(stream)) {
+   throw new FS.ErrnoError(8);
+  }
+  if (offset < 0 || length <= 0) {
+   throw new FS.ErrnoError(28);
+  }
+  if ((stream.flags & 2097155) === 0) {
+   throw new FS.ErrnoError(8);
+  }
+  if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
+   throw new FS.ErrnoError(43);
+  }
+  if (!stream.stream_ops.allocate) {
+   throw new FS.ErrnoError(138);
+  }
+  stream.stream_ops.allocate(stream, offset, length);
+ },
+ mmap: function(stream, address, length, position, prot, flags) {
+  address >>>= 0;
+  if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
+   throw new FS.ErrnoError(2);
+  }
+  if ((stream.flags & 2097155) === 1) {
+   throw new FS.ErrnoError(2);
+  }
+  if (!stream.stream_ops.mmap) {
+   throw new FS.ErrnoError(43);
+  }
+  return stream.stream_ops.mmap(stream, address, length, position, prot, flags);
+ },
+ msync: function(stream, buffer, offset, length, mmapFlags) {
+  offset >>>= 0;
+  if (!stream || !stream.stream_ops.msync) {
+   return 0;
+  }
+  return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
+ },
+ munmap: function(stream) {
+  return 0;
+ },
+ ioctl: function(stream, cmd, arg) {
+  if (!stream.stream_ops.ioctl) {
+   throw new FS.ErrnoError(59);
+  }
+  return stream.stream_ops.ioctl(stream, cmd, arg);
+ },
+ readFile: function(path, opts) {
+  opts = opts || {};
+  opts.flags = opts.flags || "r";
+  opts.encoding = opts.encoding || "binary";
+  if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
+   throw new Error('Invalid encoding type "' + opts.encoding + '"');
+  }
+  var ret;
+  var stream = FS.open(path, opts.flags);
+  var stat = FS.stat(path);
+  var length = stat.size;
+  var buf = new Uint8Array(length);
+  FS.read(stream, buf, 0, length, 0);
+  if (opts.encoding === "utf8") {
+   ret = UTF8ArrayToString(buf, 0);
+  } else if (opts.encoding === "binary") {
+   ret = buf;
+  }
+  FS.close(stream);
+  return ret;
+ },
+ writeFile: function(path, data, opts) {
+  opts = opts || {};
+  opts.flags = opts.flags || "w";
+  var stream = FS.open(path, opts.flags, opts.mode);
+  if (typeof data === "string") {
+   var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
+   var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
+   FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
+  } else if (ArrayBuffer.isView(data)) {
+   FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
+  } else {
+   throw new Error("Unsupported data type");
+  }
+  FS.close(stream);
+ },
+ cwd: function() {
+  return FS.currentPath;
+ },
+ chdir: function(path) {
+  var lookup = FS.lookupPath(path, {
+   follow: true
+  });
+  if (lookup.node === null) {
+   throw new FS.ErrnoError(44);
+  }
+  if (!FS.isDir(lookup.node.mode)) {
+   throw new FS.ErrnoError(54);
+  }
+  var errCode = FS.nodePermissions(lookup.node, "x");
+  if (errCode) {
+   throw new FS.ErrnoError(errCode);
+  }
+  FS.currentPath = lookup.path;
+ },
+ createDefaultDirectories: function() {
+  FS.mkdir("/tmp");
+  FS.mkdir("/home");
+  FS.mkdir("/home/web_user");
+ },
+ createDefaultDevices: function() {
+  FS.mkdir("/dev");
+  FS.registerDevice(FS.makedev(1, 3), {
+   read: function() {
+    return 0;
+   },
+   write: function(stream, buffer, offset, length, pos) {
+    return length;
+   }
+  });
+  FS.mkdev("/dev/null", FS.makedev(1, 3));
+  TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+  TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+  FS.mkdev("/dev/tty", FS.makedev(5, 0));
+  FS.mkdev("/dev/tty1", FS.makedev(6, 0));
+  var random_device;
+  if (typeof crypto === "object" && typeof crypto["getRandomValues"] === "function") {
+   var randomBuffer = new Uint8Array(1);
+   random_device = function() {
+    crypto.getRandomValues(randomBuffer);
+    return randomBuffer[0];
+   };
+  } else if (ENVIRONMENT_IS_NODE) {
+   try {
+    var crypto_module = require("crypto");
+    random_device = function() {
+     return crypto_module["randomBytes"](1)[0];
+    };
+   } catch (e) {}
+  } else {}
+  if (!random_device) {
+   random_device = function() {
+    abort("random_device");
+   };
+  }
+  FS.createDevice("/dev", "random", random_device);
+  FS.createDevice("/dev", "urandom", random_device);
+  FS.mkdir("/dev/shm");
+  FS.mkdir("/dev/shm/tmp");
+ },
+ createSpecialDirectories: function() {
+  FS.mkdir("/proc");
+  FS.mkdir("/proc/self");
+  FS.mkdir("/proc/self/fd");
+  FS.mount({
+   mount: function() {
+    var node = FS.createNode("/proc/self", "fd", 16384 | 511, 73);
+    node.node_ops = {
+     lookup: function(parent, name) {
+      var fd = +name;
+      var stream = FS.getStream(fd);
+      if (!stream) throw new FS.ErrnoError(8);
+      var ret = {
+       parent: null,
+       mount: {
+        mountpoint: "fake"
+       },
+       node_ops: {
+        readlink: function() {
+         return stream.path;
+        }
+       }
+      };
+      ret.parent = ret;
+      return ret;
+     }
+    };
+    return node;
+   }
+  }, {}, "/proc/self/fd");
+ },
+ createStandardStreams: function() {
+  if (Module["stdin"]) {
+   FS.createDevice("/dev", "stdin", Module["stdin"]);
+  } else {
+   FS.symlink("/dev/tty", "/dev/stdin");
+  }
+  if (Module["stdout"]) {
+   FS.createDevice("/dev", "stdout", null, Module["stdout"]);
+  } else {
+   FS.symlink("/dev/tty", "/dev/stdout");
+  }
+  if (Module["stderr"]) {
+   FS.createDevice("/dev", "stderr", null, Module["stderr"]);
+  } else {
+   FS.symlink("/dev/tty1", "/dev/stderr");
+  }
+  var stdin = FS.open("/dev/stdin", "r");
+  var stdout = FS.open("/dev/stdout", "w");
+  var stderr = FS.open("/dev/stderr", "w");
+ },
+ ensureErrnoError: function() {
+  if (FS.ErrnoError) return;
+  FS.ErrnoError = function ErrnoError(errno, node) {
+   this.node = node;
+   this.setErrno = function(errno) {
+    this.errno = errno;
+   };
+   this.setErrno(errno);
+   this.message = "FS error";
+  };
+  FS.ErrnoError.prototype = new Error();
+  FS.ErrnoError.prototype.constructor = FS.ErrnoError;
+  [ 44 ].forEach(function(code) {
+   FS.genericErrors[code] = new FS.ErrnoError(code);
+   FS.genericErrors[code].stack = "<generic error, no stack>";
+  });
+ },
+ staticInit: function() {
+  FS.ensureErrnoError();
+  FS.nameTable = new Array(4096);
+  FS.mount(MEMFS, {}, "/");
+  FS.createDefaultDirectories();
+  FS.createDefaultDevices();
+  FS.createSpecialDirectories();
+  FS.filesystems = {
+   "MEMFS": MEMFS
+  };
+ },
+ init: function(input, output, error) {
+  FS.init.initialized = true;
+  FS.ensureErrnoError();
+  Module["stdin"] = input || Module["stdin"];
+  Module["stdout"] = output || Module["stdout"];
+  Module["stderr"] = error || Module["stderr"];
+  FS.createStandardStreams();
+ },
+ quit: function() {
+  FS.init.initialized = false;
+  var fflush = Module["_fflush"];
+  if (fflush) fflush(0);
+  for (var i = 0; i < FS.streams.length; i++) {
+   var stream = FS.streams[i];
+   if (!stream) {
+    continue;
+   }
+   FS.close(stream);
+  }
+ },
+ getMode: function(canRead, canWrite) {
+  var mode = 0;
+  if (canRead) mode |= 292 | 73;
+  if (canWrite) mode |= 146;
+  return mode;
+ },
+ joinPath: function(parts, forceRelative) {
+  var path = PATH.join.apply(null, parts);
+  if (forceRelative && path[0] == "/") path = path.substr(1);
+  return path;
+ },
+ absolutePath: function(relative, base) {
+  return PATH_FS.resolve(base, relative);
+ },
+ standardizePath: function(path) {
+  return PATH.normalize(path);
+ },
+ findObject: function(path, dontResolveLastLink) {
+  var ret = FS.analyzePath(path, dontResolveLastLink);
+  if (ret.exists) {
+   return ret.object;
+  } else {
+   setErrNo(ret.error);
+   return null;
+  }
+ },
+ analyzePath: function(path, dontResolveLastLink) {
+  try {
+   var lookup = FS.lookupPath(path, {
+    follow: !dontResolveLastLink
+   });
+   path = lookup.path;
+  } catch (e) {}
+  var ret = {
+   isRoot: false,
+   exists: false,
+   error: 0,
+   name: null,
+   path: null,
+   object: null,
+   parentExists: false,
+   parentPath: null,
+   parentObject: null
+  };
+  try {
+   var lookup = FS.lookupPath(path, {
+    parent: true
+   });
+   ret.parentExists = true;
+   ret.parentPath = lookup.path;
+   ret.parentObject = lookup.node;
+   ret.name = PATH.basename(path);
+   lookup = FS.lookupPath(path, {
+    follow: !dontResolveLastLink
+   });
+   ret.exists = true;
+   ret.path = lookup.path;
+   ret.object = lookup.node;
+   ret.name = lookup.node.name;
+   ret.isRoot = lookup.path === "/";
+  } catch (e) {
+   ret.error = e.errno;
+  }
+  return ret;
+ },
+ createFolder: function(parent, name, canRead, canWrite) {
+  var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
+  var mode = FS.getMode(canRead, canWrite);
+  return FS.mkdir(path, mode);
+ },
+ createPath: function(parent, path, canRead, canWrite) {
+  parent = typeof parent === "string" ? parent : FS.getPath(parent);
+  var parts = path.split("/").reverse();
+  while (parts.length) {
+   var part = parts.pop();
+   if (!part) continue;
+   var current = PATH.join2(parent, part);
+   try {
+    FS.mkdir(current);
+   } catch (e) {}
+   parent = current;
+  }
+  return current;
+ },
+ createFile: function(parent, name, properties, canRead, canWrite) {
+  var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
+  var mode = FS.getMode(canRead, canWrite);
+  return FS.create(path, mode);
+ },
+ createDataFile: function(parent, name, data, canRead, canWrite, canOwn) {
+  var path = name ? PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name) : parent;
+  var mode = FS.getMode(canRead, canWrite);
+  var node = FS.create(path, mode);
+  if (data) {
+   if (typeof data === "string") {
+    var arr = new Array(data.length);
+    for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
+    data = arr;
+   }
+   FS.chmod(node, mode | 146);
+   var stream = FS.open(node, "w");
+   FS.write(stream, data, 0, data.length, 0, canOwn);
+   FS.close(stream);
+   FS.chmod(node, mode);
+  }
+  return node;
+ },
+ createDevice: function(parent, name, input, output) {
+  var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
+  var mode = FS.getMode(!!input, !!output);
+  if (!FS.createDevice.major) FS.createDevice.major = 64;
+  var dev = FS.makedev(FS.createDevice.major++, 0);
+  FS.registerDevice(dev, {
+   open: function(stream) {
+    stream.seekable = false;
+   },
+   close: function(stream) {
+    if (output && output.buffer && output.buffer.length) {
+     output(10);
+    }
+   },
+   read: function(stream, buffer, offset, length, pos) {
+    var bytesRead = 0;
+    for (var i = 0; i < length; i++) {
+     var result;
+     try {
+      result = input();
+     } catch (e) {
+      throw new FS.ErrnoError(29);
+     }
+     if (result === undefined && bytesRead === 0) {
+      throw new FS.ErrnoError(6);
+     }
+     if (result === null || result === undefined) break;
+     bytesRead++;
+     buffer[offset + i] = result;
+    }
+    if (bytesRead) {
+     stream.node.timestamp = Date.now();
+    }
+    return bytesRead;
+   },
+   write: function(stream, buffer, offset, length, pos) {
+    for (var i = 0; i < length; i++) {
+     try {
+      output(buffer[offset + i]);
+     } catch (e) {
+      throw new FS.ErrnoError(29);
+     }
+    }
+    if (length) {
+     stream.node.timestamp = Date.now();
+    }
+    return i;
+   }
+  });
+  return FS.mkdev(path, mode, dev);
+ },
+ createLink: function(parent, name, target, canRead, canWrite) {
+  var path = PATH.join2(typeof parent === "string" ? parent : FS.getPath(parent), name);
+  return FS.symlink(target, path);
+ },
+ forceLoadFile: function(obj) {
+  if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+  var success = true;
+  if (typeof XMLHttpRequest !== "undefined") {
+   throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
+  } else if (read_) {
+   try {
+    obj.contents = intArrayFromString(read_(obj.url), true);
+    obj.usedBytes = obj.contents.length;
+   } catch (e) {
+    success = false;
+   }
+  } else {
+   throw new Error("Cannot load without read() or XMLHttpRequest.");
+  }
+  if (!success) setErrNo(29);
+  return success;
+ },
+ createLazyFile: function(parent, name, url, canRead, canWrite) {
+  function LazyUint8Array() {
+   this.lengthKnown = false;
+   this.chunks = [];
+  }
+  LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) {
+   if (idx > this.length - 1 || idx < 0) {
+    return undefined;
+   }
+   var chunkOffset = idx % this.chunkSize;
+   var chunkNum = idx / this.chunkSize | 0;
+   return this.getter(chunkNum)[chunkOffset];
+  };
+  LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) {
+   this.getter = getter;
+  };
+  LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() {
+   var xhr = new XMLHttpRequest();
+   xhr.open("HEAD", url, false);
+   xhr.send(null);
+   if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+   var datalength = Number(xhr.getResponseHeader("Content-length"));
+   var header;
+   var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+   var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
+   var chunkSize = 1024 * 1024;
+   if (!hasByteServing) chunkSize = datalength;
+   var doXHR = function(from, to) {
+    if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+    if (to > datalength - 1) throw new Error("only " + datalength + " bytes available! programmer error!");
+    var xhr = new XMLHttpRequest();
+    xhr.open("GET", url, false);
+    if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+    if (typeof Uint8Array != "undefined") xhr.responseType = "arraybuffer";
+    if (xhr.overrideMimeType) {
+     xhr.overrideMimeType("text/plain; charset=x-user-defined");
+    }
+    xhr.send(null);
+    if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+    if (xhr.response !== undefined) {
+     return new Uint8Array(xhr.response || []);
+    } else {
+     return intArrayFromString(xhr.responseText || "", true);
+    }
+   };
+   var lazyArray = this;
+   lazyArray.setDataGetter(function(chunkNum) {
+    var start = chunkNum * chunkSize;
+    var end = (chunkNum + 1) * chunkSize - 1;
+    end = Math.min(end, datalength - 1);
+    if (typeof lazyArray.chunks[chunkNum] === "undefined") {
+     lazyArray.chunks[chunkNum] = doXHR(start, end);
+    }
+    if (typeof lazyArray.chunks[chunkNum] === "undefined") throw new Error("doXHR failed!");
+    return lazyArray.chunks[chunkNum];
+   });
+   if (usesGzip || !datalength) {
+    chunkSize = datalength = 1;
+    datalength = this.getter(0).length;
+    chunkSize = datalength;
+    out("LazyFiles on gzip forces download of the whole file when length is accessed");
+   }
+   this._length = datalength;
+   this._chunkSize = chunkSize;
+   this.lengthKnown = true;
+  };
+  if (typeof XMLHttpRequest !== "undefined") {
+   if (!ENVIRONMENT_IS_WORKER) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
+   var lazyArray = new LazyUint8Array();
+   Object.defineProperties(lazyArray, {
+    length: {
+     get: function() {
+      if (!this.lengthKnown) {
+       this.cacheLength();
+      }
+      return this._length;
+     }
+    },
+    chunkSize: {
+     get: function() {
+      if (!this.lengthKnown) {
+       this.cacheLength();
+      }
+      return this._chunkSize;
+     }
+    }
+   });
+   var properties = {
+    isDevice: false,
+    contents: lazyArray
+   };
+  } else {
+   var properties = {
+    isDevice: false,
+    url: url
+   };
+  }
+  var node = FS.createFile(parent, name, properties, canRead, canWrite);
+  if (properties.contents) {
+   node.contents = properties.contents;
+  } else if (properties.url) {
+   node.contents = null;
+   node.url = properties.url;
+  }
+  Object.defineProperties(node, {
+   usedBytes: {
+    get: function() {
+     return this.contents.length;
+    }
+   }
+  });
+  var stream_ops = {};
+  var keys = Object.keys(node.stream_ops);
+  keys.forEach(function(key) {
+   var fn = node.stream_ops[key];
+   stream_ops[key] = function forceLoadLazyFile() {
+    if (!FS.forceLoadFile(node)) {
+     throw new FS.ErrnoError(29);
+    }
+    return fn.apply(null, arguments);
+   };
+  });
+  stream_ops.read = function stream_ops_read(stream, buffer, offset, length, position) {
+   if (!FS.forceLoadFile(node)) {
+    throw new FS.ErrnoError(29);
+   }
+   var contents = stream.node.contents;
+   if (position >= contents.length) return 0;
+   var size = Math.min(contents.length - position, length);
+   if (contents.slice) {
+    for (var i = 0; i < size; i++) {
+     buffer[offset + i] = contents[position + i];
+    }
+   } else {
+    for (var i = 0; i < size; i++) {
+     buffer[offset + i] = contents.get(position + i);
+    }
+   }
+   return size;
+  };
+  node.stream_ops = stream_ops;
+  return node;
+ },
+ createPreloadedFile: function(parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) {
+  Browser.init();
+  var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
+  var dep = getUniqueRunDependency("cp " + fullname);
+  function processData(byteArray) {
+   function finish(byteArray) {
+    if (preFinish) preFinish();
+    if (!dontCreateFile) {
+     FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+    }
+    if (onload) onload();
+    removeRunDependency(dep);
+   }
+   var handled = false;
+   Module["preloadPlugins"].forEach(function(plugin) {
+    if (handled) return;
+    if (plugin["canHandle"](fullname)) {
+     plugin["handle"](byteArray, fullname, finish, function() {
+      if (onerror) onerror();
+      removeRunDependency(dep);
+     });
+     handled = true;
+    }
+   });
+   if (!handled) finish(byteArray);
+  }
+  addRunDependency(dep);
+  if (typeof url == "string") {
+   Browser.asyncLoad(url, function(byteArray) {
+    processData(byteArray);
+   }, onerror);
+  } else {
+   processData(url);
+  }
+ },
+ indexedDB: function() {
+  return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+ },
+ DB_NAME: function() {
+  return "EM_FS_" + window.location.pathname;
+ },
+ DB_VERSION: 20,
+ DB_STORE_NAME: "FILE_DATA",
+ saveFilesToDB: function(paths, onload, onerror) {
+  onload = onload || function() {};
+  onerror = onerror || function() {};
+  var indexedDB = FS.indexedDB();
+  try {
+   var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+  } catch (e) {
+   return onerror(e);
+  }
+  openRequest.onupgradeneeded = function openRequest_onupgradeneeded() {
+   out("creating db");
+   var db = openRequest.result;
+   db.createObjectStore(FS.DB_STORE_NAME);
+  };
+  openRequest.onsuccess = function openRequest_onsuccess() {
+   var db = openRequest.result;
+   var transaction = db.transaction([ FS.DB_STORE_NAME ], "readwrite");
+   var files = transaction.objectStore(FS.DB_STORE_NAME);
+   var ok = 0, fail = 0, total = paths.length;
+   function finish() {
+    if (fail == 0) onload(); else onerror();
+   }
+   paths.forEach(function(path) {
+    var putRequest = files.put(FS.analyzePath(path).object.contents, path);
+    putRequest.onsuccess = function putRequest_onsuccess() {
+     ok++;
+     if (ok + fail == total) finish();
+    };
+    putRequest.onerror = function putRequest_onerror() {
+     fail++;
+     if (ok + fail == total) finish();
+    };
+   });
+   transaction.onerror = onerror;
+  };
+  openRequest.onerror = onerror;
+ },
+ loadFilesFromDB: function(paths, onload, onerror) {
+  onload = onload || function() {};
+  onerror = onerror || function() {};
+  var indexedDB = FS.indexedDB();
+  try {
+   var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
+  } catch (e) {
+   return onerror(e);
+  }
+  openRequest.onupgradeneeded = onerror;
+  openRequest.onsuccess = function openRequest_onsuccess() {
+   var db = openRequest.result;
+   try {
+    var transaction = db.transaction([ FS.DB_STORE_NAME ], "readonly");
+   } catch (e) {
+    onerror(e);
+    return;
+   }
+   var files = transaction.objectStore(FS.DB_STORE_NAME);
+   var ok = 0, fail = 0, total = paths.length;
+   function finish() {
+    if (fail == 0) onload(); else onerror();
+   }
+   paths.forEach(function(path) {
+    var getRequest = files.get(path);
+    getRequest.onsuccess = function getRequest_onsuccess() {
+     if (FS.analyzePath(path).exists) {
+      FS.unlink(path);
+     }
+     FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true);
+     ok++;
+     if (ok + fail == total) finish();
+    };
+    getRequest.onerror = function getRequest_onerror() {
+     fail++;
+     if (ok + fail == total) finish();
+    };
+   });
+   transaction.onerror = onerror;
+  };
+  openRequest.onerror = onerror;
+ },
+ mmapAlloc: function(size) {
+  var alignedSize = alignMemory(size, 16384);
+  var ptr = _malloc(alignedSize);
+  while (size < alignedSize) HEAP8[ptr + size++ >>> 0] = 0;
+  return ptr;
+ }
+};
+
+var SYSCALLS = {
+ mappings: {},
+ DEFAULT_POLLMASK: 5,
+ umask: 511,
+ calculateAt: function(dirfd, path) {
+  if (path[0] !== "/") {
+   var dir;
+   if (dirfd === -100) {
+    dir = FS.cwd();
+   } else {
+    var dirstream = FS.getStream(dirfd);
+    if (!dirstream) throw new FS.ErrnoError(8);
+    dir = dirstream.path;
+   }
+   path = PATH.join2(dir, path);
+  }
+  return path;
+ },
+ doStat: function(func, path, buf) {
+  try {
+   var stat = func(path);
+  } catch (e) {
+   if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) {
+    return -54;
+   }
+   throw e;
+  }
+  HEAP32[buf >>> 2] = stat.dev;
+  HEAP32[buf + 4 >>> 2] = 0;
+  HEAP32[buf + 8 >>> 2] = stat.ino;
+  HEAP32[buf + 12 >>> 2] = stat.mode;
+  HEAP32[buf + 16 >>> 2] = stat.nlink;
+  HEAP32[buf + 20 >>> 2] = stat.uid;
+  HEAP32[buf + 24 >>> 2] = stat.gid;
+  HEAP32[buf + 28 >>> 2] = stat.rdev;
+  HEAP32[buf + 32 >>> 2] = 0;
+  tempI64 = [ stat.size >>> 0, (tempDouble = stat.size, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], 
+  HEAP32[buf + 40 >>> 2] = tempI64[0], HEAP32[buf + 44 >>> 2] = tempI64[1];
+  HEAP32[buf + 48 >>> 2] = 4096;
+  HEAP32[buf + 52 >>> 2] = stat.blocks;
+  HEAP32[buf + 56 >>> 2] = stat.atime.getTime() / 1e3 | 0;
+  HEAP32[buf + 60 >>> 2] = 0;
+  HEAP32[buf + 64 >>> 2] = stat.mtime.getTime() / 1e3 | 0;
+  HEAP32[buf + 68 >>> 2] = 0;
+  HEAP32[buf + 72 >>> 2] = stat.ctime.getTime() / 1e3 | 0;
+  HEAP32[buf + 76 >>> 2] = 0;
+  tempI64 = [ stat.ino >>> 0, (tempDouble = stat.ino, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], 
+  HEAP32[buf + 80 >>> 2] = tempI64[0], HEAP32[buf + 84 >>> 2] = tempI64[1];
+  return 0;
+ },
+ doMsync: function(addr, stream, len, flags, offset) {
+  var buffer = HEAPU8.slice(addr, addr + len);
+  FS.msync(stream, buffer, offset, len, flags);
+ },
+ doMkdir: function(path, mode) {
+  path = PATH.normalize(path);
+  if (path[path.length - 1] === "/") path = path.substr(0, path.length - 1);
+  FS.mkdir(path, mode, 0);
+  return 0;
+ },
+ doMknod: function(path, mode, dev) {
+  switch (mode & 61440) {
+  case 32768:
+  case 8192:
+  case 24576:
+  case 4096:
+  case 49152:
+   break;
+
+  default:
+   return -28;
+  }
+  FS.mknod(path, mode, dev);
+  return 0;
+ },
+ doReadlink: function(path, buf, bufsize) {
+  if (bufsize <= 0) return -28;
+  var ret = FS.readlink(path);
+  var len = Math.min(bufsize, lengthBytesUTF8(ret));
+  var endChar = HEAP8[buf + len >>> 0];
+  stringToUTF8(ret, buf, bufsize + 1);
+  HEAP8[buf + len >>> 0] = endChar;
+  return len;
+ },
+ doAccess: function(path, amode) {
+  if (amode & ~7) {
+   return -28;
+  }
+  var node;
+  var lookup = FS.lookupPath(path, {
+   follow: true
+  });
+  node = lookup.node;
+  if (!node) {
+   return -44;
+  }
+  var perms = "";
+  if (amode & 4) perms += "r";
+  if (amode & 2) perms += "w";
+  if (amode & 1) perms += "x";
+  if (perms && FS.nodePermissions(node, perms)) {
+   return -2;
+  }
+  return 0;
+ },
+ doDup: function(path, flags, suggestFD) {
+  var suggest = FS.getStream(suggestFD);
+  if (suggest) FS.close(suggest);
+  return FS.open(path, flags, 0, suggestFD, suggestFD).fd;
+ },
+ doReadv: function(stream, iov, iovcnt, offset) {
+  var ret = 0;
+  for (var i = 0; i < iovcnt; i++) {
+   var ptr = HEAP32[iov + i * 8 >>> 2];
+   var len = HEAP32[iov + (i * 8 + 4) >>> 2];
+   var curr = FS.read(stream, HEAP8, ptr, len, offset);
+   if (curr < 0) return -1;
+   ret += curr;
+   if (curr < len) break;
+  }
+  return ret;
+ },
+ doWritev: function(stream, iov, iovcnt, offset) {
+  var ret = 0;
+  for (var i = 0; i < iovcnt; i++) {
+   var ptr = HEAP32[iov + i * 8 >>> 2];
+   var len = HEAP32[iov + (i * 8 + 4) >>> 2];
+   var curr = FS.write(stream, HEAP8, ptr, len, offset);
+   if (curr < 0) return -1;
+   ret += curr;
+  }
+  return ret;
+ },
+ varargs: undefined,
+ get: function() {
+  SYSCALLS.varargs += 4;
+  var ret = HEAP32[SYSCALLS.varargs - 4 >>> 2];
+  return ret;
+ },
+ getStr: function(ptr) {
+  var ret = UTF8ToString(ptr);
+  return ret;
+ },
+ getStreamFromFD: function(fd) {
+  var stream = FS.getStream(fd);
+  if (!stream) throw new FS.ErrnoError(8);
+  return stream;
+ },
+ get64: function(low, high) {
+  return low;
+ }
+};
+
+function syscallMunmap(addr, len) {
+ addr >>>= 0;
+ if ((addr | 0) === -1 || len === 0) {
+  return -28;
+ }
+ var info = SYSCALLS.mappings[addr];
+ if (!info) return 0;
+ if (len === info.len) {
+  var stream = FS.getStream(info.fd);
+  if (info.prot & 2) {
+   SYSCALLS.doMsync(addr, stream, len, info.flags, info.offset);
+  }
+  FS.munmap(stream);
+  SYSCALLS.mappings[addr] = null;
+  if (info.allocated) {
+   _free(info.malloc);
+  }
+ }
+ return 0;
+}
+
+function ___sys_munmap(addr, len) {
+ try {
+  return syscallMunmap(addr, len);
+ } catch (e) {
+  if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
+  return -e.errno;
+ }
+}
+
+var structRegistrations = {};
+
+function runDestructors(destructors) {
+ while (destructors.length) {
+  var ptr = destructors.pop();
+  var del = destructors.pop();
+  del(ptr);
+ }
+}
+
+function simpleReadValueFromPointer(pointer) {
+ return this["fromWireType"](HEAPU32[pointer >>> 2]);
+}
+
+var awaitingDependencies = {};
+
+var registeredTypes = {};
+
+var typeDependencies = {};
+
+var char_0 = 48;
+
+var char_9 = 57;
+
+function makeLegalFunctionName(name) {
+ if (undefined === name) {
+  return "_unknown";
+ }
+ name = name.replace(/[^a-zA-Z0-9_]/g, "$");
+ var f = name.charCodeAt(0);
+ if (f >= char_0 && f <= char_9) {
+  return "_" + name;
+ } else {
+  return name;
+ }
+}
+
+function createNamedFunction(name, body) {
+ name = makeLegalFunctionName(name);
+ return new Function("body", "return function " + name + "() {\n" + '    "use strict";' + "    return body.apply(this, arguments);\n" + "};\n")(body);
+}
+
+function extendError(baseErrorType, errorName) {
+ var errorClass = createNamedFunction(errorName, function(message) {
+  this.name = errorName;
+  this.message = message;
+  var stack = new Error(message).stack;
+  if (stack !== undefined) {
+   this.stack = this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, "");
+  }
+ });
+ errorClass.prototype = Object.create(baseErrorType.prototype);
+ errorClass.prototype.constructor = errorClass;
+ errorClass.prototype.toString = function() {
+  if (this.message === undefined) {
+   return this.name;
+  } else {
+   return this.name + ": " + this.message;
+  }
+ };
+ return errorClass;
+}
+
+var InternalError = undefined;
+
+function throwInternalError(message) {
+ throw new InternalError(message);
+}
+
+function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {
+ myTypes.forEach(function(type) {
+  typeDependencies[type] = dependentTypes;
+ });
+ function onComplete(typeConverters) {
+  var myTypeConverters = getTypeConverters(typeConverters);
+  if (myTypeConverters.length !== myTypes.length) {
+   throwInternalError("Mismatched type converter count");
+  }
+  for (var i = 0; i < myTypes.length; ++i) {
+   registerType(myTypes[i], myTypeConverters[i]);
+  }
+ }
+ var typeConverters = new Array(dependentTypes.length);
+ var unregisteredTypes = [];
+ var registered = 0;
+ dependentTypes.forEach(function(dt, i) {
+  if (registeredTypes.hasOwnProperty(dt)) {
+   typeConverters[i] = registeredTypes[dt];
+  } else {
+   unregisteredTypes.push(dt);
+   if (!awaitingDependencies.hasOwnProperty(dt)) {
+    awaitingDependencies[dt] = [];
+   }
+   awaitingDependencies[dt].push(function() {
+    typeConverters[i] = registeredTypes[dt];
+    ++registered;
+    if (registered === unregisteredTypes.length) {
+     onComplete(typeConverters);
+    }
+   });
+  }
+ });
+ if (0 === unregisteredTypes.length) {
+  onComplete(typeConverters);
+ }
+}
+
+function __embind_finalize_value_object(structType) {
+ var reg = structRegistrations[structType];
+ delete structRegistrations[structType];
+ var rawConstructor = reg.rawConstructor;
+ var rawDestructor = reg.rawDestructor;
+ var fieldRecords = reg.fields;
+ var fieldTypes = fieldRecords.map(function(field) {
+  return field.getterReturnType;
+ }).concat(fieldRecords.map(function(field) {
+  return field.setterArgumentType;
+ }));
+ whenDependentTypesAreResolved([ structType ], fieldTypes, function(fieldTypes) {
+  var fields = {};
+  fieldRecords.forEach(function(field, i) {
+   var fieldName = field.fieldName;
+   var getterReturnType = fieldTypes[i];
+   var getter = field.getter;
+   var getterContext = field.getterContext;
+   var setterArgumentType = fieldTypes[i + fieldRecords.length];
+   var setter = field.setter;
+   var setterContext = field.setterContext;
+   fields[fieldName] = {
+    read: function(ptr) {
+     return getterReturnType["fromWireType"](getter(getterContext, ptr));
+    },
+    write: function(ptr, o) {
+     var destructors = [];
+     setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o));
+     runDestructors(destructors);
+    }
+   };
+  });
+  return [ {
+   name: reg.name,
+   "fromWireType": function(ptr) {
+    var rv = {};
+    for (var i in fields) {
+     rv[i] = fields[i].read(ptr);
+    }
+    rawDestructor(ptr);
+    return rv;
+   },
+   "toWireType": function(destructors, o) {
+    for (var fieldName in fields) {
+     if (!(fieldName in o)) {
+      throw new TypeError('Missing field:  "' + fieldName + '"');
+     }
+    }
+    var ptr = rawConstructor();
+    for (fieldName in fields) {
+     fields[fieldName].write(ptr, o[fieldName]);
+    }
+    if (destructors !== null) {
+     destructors.push(rawDestructor, ptr);
+    }
+    return ptr;
+   },
+   "argPackAdvance": 8,
+   "readValueFromPointer": simpleReadValueFromPointer,
+   destructorFunction: rawDestructor
+  } ];
+ });
+}
+
+function getShiftFromSize(size) {
+ switch (size) {
+ case 1:
+  return 0;
+
+ case 2:
+  return 1;
+
+ case 4:
+  return 2;
+
+ case 8:
+  return 3;
+
+ default:
+  throw new TypeError("Unknown type size: " + size);
+ }
+}
+
+function embind_init_charCodes() {
+ var codes = new Array(256);
+ for (var i = 0; i < 256; ++i) {
+  codes[i] = String.fromCharCode(i);
+ }
+ embind_charCodes = codes;
+}
+
+var embind_charCodes = undefined;
+
+function readLatin1String(ptr) {
+ var ret = "";
+ var c = ptr;
+ while (HEAPU8[c >>> 0]) {
+  ret += embind_charCodes[HEAPU8[c++ >>> 0]];
+ }
+ return ret;
+}
+
+var BindingError = undefined;
+
+function throwBindingError(message) {
+ throw new BindingError(message);
+}
+
+function registerType(rawType, registeredInstance, options) {
+ options = options || {};
+ if (!("argPackAdvance" in registeredInstance)) {
+  throw new TypeError("registerType registeredInstance requires argPackAdvance");
+ }
+ var name = registeredInstance.name;
+ if (!rawType) {
+  throwBindingError('type "' + name + '" must have a positive integer typeid pointer');
+ }
+ if (registeredTypes.hasOwnProperty(rawType)) {
+  if (options.ignoreDuplicateRegistrations) {
+   return;
+  } else {
+   throwBindingError("Cannot register type '" + name + "' twice");
+  }
+ }
+ registeredTypes[rawType] = registeredInstance;
+ delete typeDependencies[rawType];
+ if (awaitingDependencies.hasOwnProperty(rawType)) {
+  var callbacks = awaitingDependencies[rawType];
+  delete awaitingDependencies[rawType];
+  callbacks.forEach(function(cb) {
+   cb();
+  });
+ }
+}
+
+function __embind_register_bool(rawType, name, size, trueValue, falseValue) {
+ var shift = getShiftFromSize(size);
+ name = readLatin1String(name);
+ registerType(rawType, {
+  name: name,
+  "fromWireType": function(wt) {
+   return !!wt;
+  },
+  "toWireType": function(destructors, o) {
+   return o ? trueValue : falseValue;
+  },
+  "argPackAdvance": 8,
+  "readValueFromPointer": function(pointer) {
+   var heap;
+   if (size === 1) {
+    heap = HEAP8;
+   } else if (size === 2) {
+    heap = HEAP16;
+   } else if (size === 4) {
+    heap = HEAP32;
+   } else {
+    throw new TypeError("Unknown boolean type size: " + name);
+   }
+   return this["fromWireType"](heap[pointer >>> shift]);
+  },
+  destructorFunction: null
+ });
+}
+
+var emval_free_list = [];
+
+var emval_handle_array = [ {}, {
+ value: undefined
+}, {
+ value: null
+}, {
+ value: true
+}, {
+ value: false
+} ];
+
+function __emval_decref(handle) {
+ if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
+  emval_handle_array[handle] = undefined;
+  emval_free_list.push(handle);
+ }
+}
+
+function count_emval_handles() {
+ var count = 0;
+ for (var i = 5; i < emval_handle_array.length; ++i) {
+  if (emval_handle_array[i] !== undefined) {
+   ++count;
+  }
+ }
+ return count;
+}
+
+function get_first_emval() {
+ for (var i = 5; i < emval_handle_array.length; ++i) {
+  if (emval_handle_array[i] !== undefined) {
+   return emval_handle_array[i];
+  }
+ }
+ return null;
+}
+
+function init_emval() {
+ Module["count_emval_handles"] = count_emval_handles;
+ Module["get_first_emval"] = get_first_emval;
+}
+
+function __emval_register(value) {
+ switch (value) {
+ case undefined:
+  {
+   return 1;
+  }
+
+ case null:
+  {
+   return 2;
+  }
+
+ case true:
+  {
+   return 3;
+  }
+
+ case false:
+  {
+   return 4;
+  }
+
+ default:
+  {
+   var handle = emval_free_list.length ? emval_free_list.pop() : emval_handle_array.length;
+   emval_handle_array[handle] = {
+    refcount: 1,
+    value: value
+   };
+   return handle;
+  }
+ }
+}
+
+function __embind_register_emval(rawType, name) {
+ name = readLatin1String(name);
+ registerType(rawType, {
+  name: name,
+  "fromWireType": function(handle) {
+   var rv = emval_handle_array[handle].value;
+   __emval_decref(handle);
+   return rv;
+  },
+  "toWireType": function(destructors, value) {
+   return __emval_register(value);
+  },
+  "argPackAdvance": 8,
+  "readValueFromPointer": simpleReadValueFromPointer,
+  destructorFunction: null
+ });
+}
+
+function _embind_repr(v) {
+ if (v === null) {
+  return "null";
+ }
+ var t = typeof v;
+ if (t === "object" || t === "array" || t === "function") {
+  return v.toString();
+ } else {
+  return "" + v;
+ }
+}
+
+function floatReadValueFromPointer(name, shift) {
+ switch (shift) {
+ case 2:
+  return function(pointer) {
+   return this["fromWireType"](HEAPF32[pointer >>> 2]);
+  };
+
+ case 3:
+  return function(pointer) {
+   return this["fromWireType"](HEAPF64[pointer >>> 3]);
+  };
+
+ default:
+  throw new TypeError("Unknown float type: " + name);
+ }
+}
+
+function __embind_register_float(rawType, name, size) {
+ var shift = getShiftFromSize(size);
+ name = readLatin1String(name);
+ registerType(rawType, {
+  name: name,
+  "fromWireType": function(value) {
+   return value;
+  },
+  "toWireType": function(destructors, value) {
+   if (typeof value !== "number" && typeof value !== "boolean") {
+    throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);
+   }
+   return value;
+  },
+  "argPackAdvance": 8,
+  "readValueFromPointer": floatReadValueFromPointer(name, shift),
+  destructorFunction: null
+ });
+}
+
+function new_(constructor, argumentList) {
+ if (!(constructor instanceof Function)) {
+  throw new TypeError("new_ called with constructor type " + typeof constructor + " which is not a function");
+ }
+ var dummy = createNamedFunction(constructor.name || "unknownFunctionName", function() {});
+ dummy.prototype = constructor.prototype;
+ var obj = new dummy();
+ var r = constructor.apply(obj, argumentList);
+ return r instanceof Object ? r : obj;
+}
+
+function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc) {
+ var argCount = argTypes.length;
+ if (argCount < 2) {
+  throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
+ }
+ var isClassMethodFunc = argTypes[1] !== null && classType !== null;
+ var needsDestructorStack = false;
+ for (var i = 1; i < argTypes.length; ++i) {
+  if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
+   needsDestructorStack = true;
+   break;
+  }
+ }
+ var returns = argTypes[0].name !== "void";
+ var argsList = "";
+ var argsListWired = "";
+ for (var i = 0; i < argCount - 2; ++i) {
+  argsList += (i !== 0 ? ", " : "") + "arg" + i;
+  argsListWired += (i !== 0 ? ", " : "") + "arg" + i + "Wired";
+ }
+ var invokerFnBody = "return function " + makeLegalFunctionName(humanName) + "(" + argsList + ") {\n" + "if (arguments.length !== " + (argCount - 2) + ") {\n" + "throwBindingError('function " + humanName + " called with ' + arguments.length + ' arguments, expected " + (argCount - 2) + " args!');\n" + "}\n";
+ if (needsDestructorStack) {
+  invokerFnBody += "var destructors = [];\n";
+ }
+ var dtorStack = needsDestructorStack ? "destructors" : "null";
+ var args1 = [ "throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam" ];
+ var args2 = [ throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1] ];
+ if (isClassMethodFunc) {
+  invokerFnBody += "var thisWired = classParam.toWireType(" + dtorStack + ", this);\n";
+ }
+ for (var i = 0; i < argCount - 2; ++i) {
+  invokerFnBody += "var arg" + i + "Wired = argType" + i + ".toWireType(" + dtorStack + ", arg" + i + "); // " + argTypes[i + 2].name + "\n";
+  args1.push("argType" + i);
+  args2.push(argTypes[i + 2]);
+ }
+ if (isClassMethodFunc) {
+  argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired;
+ }
+ invokerFnBody += (returns ? "var rv = " : "") + "invoker(fn" + (argsListWired.length > 0 ? ", " : "") + argsListWired + ");\n";
+ if (needsDestructorStack) {
+  invokerFnBody += "runDestructors(destructors);\n";
+ } else {
+  for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
+   var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
+   if (argTypes[i].destructorFunction !== null) {
+    invokerFnBody += paramName + "_dtor(" + paramName + "); // " + argTypes[i].name + "\n";
+    args1.push(paramName + "_dtor");
+    args2.push(argTypes[i].destructorFunction);
+   }
+  }
+ }
+ if (returns) {
+  invokerFnBody += "var ret = retType.fromWireType(rv);\n" + "return ret;\n";
+ } else {}
+ invokerFnBody += "}\n";
+ args1.push(invokerFnBody);
+ var invokerFunction = new_(Function, args1).apply(null, args2);
+ return invokerFunction;
+}
+
+function ensureOverloadTable(proto, methodName, humanName) {
+ if (undefined === proto[methodName].overloadTable) {
+  var prevFunc = proto[methodName];
+  proto[methodName] = function() {
+   if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
+    throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + arguments.length + ") - expects one of (" + proto[methodName].overloadTable + ")!");
+   }
+   return proto[methodName].overloadTable[arguments.length].apply(this, arguments);
+  };
+  proto[methodName].overloadTable = [];
+  proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
+ }
+}
+
+function exposePublicSymbol(name, value, numArguments) {
+ if (Module.hasOwnProperty(name)) {
+  if (undefined === numArguments || undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments]) {
+   throwBindingError("Cannot register public name '" + name + "' twice");
+  }
+  ensureOverloadTable(Module, name, name);
+  if (Module.hasOwnProperty(numArguments)) {
+   throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!");
+  }
+  Module[name].overloadTable[numArguments] = value;
+ } else {
+  Module[name] = value;
+  if (undefined !== numArguments) {
+   Module[name].numArguments = numArguments;
+  }
+ }
+}
+
+function heap32VectorToArray(count, firstElement) {
+ var array = [];
+ for (var i = 0; i < count; i++) {
+  array.push(HEAP32[(firstElement >> 2) + i >>> 0]);
+ }
+ return array;
+}
+
+function replacePublicSymbol(name, value, numArguments) {
+ if (!Module.hasOwnProperty(name)) {
+  throwInternalError("Replacing nonexistant public symbol");
+ }
+ if (undefined !== Module[name].overloadTable && undefined !== numArguments) {
+  Module[name].overloadTable[numArguments] = value;
+ } else {
+  Module[name] = value;
+  Module[name].argCount = numArguments;
+ }
+}
+
+function embind__requireFunction(signature, rawFunction) {
+ signature = readLatin1String(signature);
+ function makeDynCaller(dynCall) {
+  var args = [];
+  for (var i = 1; i < signature.length; ++i) {
+   args.push("a" + i);
+  }
+  var name = "dynCall_" + signature + "_" + rawFunction;
+  var body = "return function " + name + "(" + args.join(", ") + ") {\n";
+  body += "    return dynCall(rawFunction" + (args.length ? ", " : "") + args.join(", ") + ");\n";
+  body += "};\n";
+  return new Function("dynCall", "rawFunction", body)(dynCall, rawFunction);
+ }
+ var dc = Module["dynCall_" + signature];
+ var fp = makeDynCaller(dc);
+ if (typeof fp !== "function") {
+  throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction);
+ }
+ return fp;
+}
+
+var UnboundTypeError = undefined;
+
+function getTypeName(type) {
+ var ptr = ___getTypeName(type);
+ var rv = readLatin1String(ptr);
+ _free(ptr);
+ return rv;
+}
+
+function throwUnboundTypeError(message, types) {
+ var unboundTypes = [];
+ var seen = {};
+ function visit(type) {
+  if (seen[type]) {
+   return;
+  }
+  if (registeredTypes[type]) {
+   return;
+  }
+  if (typeDependencies[type]) {
+   typeDependencies[type].forEach(visit);
+   return;
+  }
+  unboundTypes.push(type);
+  seen[type] = true;
+ }
+ types.forEach(visit);
+ throw new UnboundTypeError(message + ": " + unboundTypes.map(getTypeName).join([ ", " ]));
+}
+
+function __embind_register_function(name, argCount, rawArgTypesAddr, signature, rawInvoker, fn) {
+ var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+ name = readLatin1String(name);
+ rawInvoker = embind__requireFunction(signature, rawInvoker);
+ exposePublicSymbol(name, function() {
+  throwUnboundTypeError("Cannot call " + name + " due to unbound types", argTypes);
+ }, argCount - 1);
+ whenDependentTypesAreResolved([], argTypes, function(argTypes) {
+  var invokerArgsArray = [ argTypes[0], null ].concat(argTypes.slice(1));
+  replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn), argCount - 1);
+  return [];
+ });
+}
+
+function integerReadValueFromPointer(name, shift, signed) {
+ switch (shift) {
+ case 0:
+  return signed ? function readS8FromPointer(pointer) {
+   return HEAP8[pointer >>> 0];
+  } : function readU8FromPointer(pointer) {
+   return HEAPU8[pointer >>> 0];
+  };
+
+ case 1:
+  return signed ? function readS16FromPointer(pointer) {
+   return HEAP16[pointer >>> 1];
+  } : function readU16FromPointer(pointer) {
+   return HEAPU16[pointer >>> 1];
+  };
+
+ case 2:
+  return signed ? function readS32FromPointer(pointer) {
+   return HEAP32[pointer >>> 2];
+  } : function readU32FromPointer(pointer) {
+   return HEAPU32[pointer >>> 2];
+  };
+
+ default:
+  throw new TypeError("Unknown integer type: " + name);
+ }
+}
+
+function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
+ name = readLatin1String(name);
+ if (maxRange === -1) {
+  maxRange = 4294967295;
+ }
+ var shift = getShiftFromSize(size);
+ var fromWireType = function(value) {
+  return value;
+ };
+ if (minRange === 0) {
+  var bitshift = 32 - 8 * size;
+  fromWireType = function(value) {
+   return value << bitshift >>> bitshift;
+  };
+ }
+ var isUnsignedType = name.indexOf("unsigned") != -1;
+ registerType(primitiveType, {
+  name: name,
+  "fromWireType": fromWireType,
+  "toWireType": function(destructors, value) {
+   if (typeof value !== "number" && typeof value !== "boolean") {
+    throw new TypeError('Cannot convert "' + _embind_repr(value) + '" to ' + this.name);
+   }
+   if (value < minRange || value > maxRange) {
+    throw new TypeError('Passing a number "' + _embind_repr(value) + '" from JS side to C/C++ side to an argument of type "' + name + '", which is outside the valid range [' + minRange + ", " + maxRange + "]!");
+   }
+   return isUnsignedType ? value >>> 0 : value | 0;
+  },
+  "argPackAdvance": 8,
+  "readValueFromPointer": integerReadValueFromPointer(name, shift, minRange !== 0),
+  destructorFunction: null
+ });
+}
+
+function __embind_register_memory_view(rawType, dataTypeIndex, name) {
+ var typeMapping = [ Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array ];
+ var TA = typeMapping[dataTypeIndex];
+ function decodeMemoryView(handle) {
+  handle = handle >> 2;
+  var heap = HEAPU32;
+  var size = heap[handle >>> 0];
+  var data = heap[handle + 1 >>> 0];
+  return new TA(buffer, data, size);
+ }
+ name = readLatin1String(name);
+ registerType(rawType, {
+  name: name,
+  "fromWireType": decodeMemoryView,
+  "argPackAdvance": 8,
+  "readValueFromPointer": decodeMemoryView
+ }, {
+  ignoreDuplicateRegistrations: true
+ });
+}
+
+function __embind_register_std_string(rawType, name) {
+ name = readLatin1String(name);
+ var stdStringIsUTF8 = name === "std::string";
+ registerType(rawType, {
+  name: name,
+  "fromWireType": function(value) {
+   var length = HEAPU32[value >>> 2];
+   var str;
+   if (stdStringIsUTF8) {
+    var decodeStartPtr = value + 4;
+    for (var i = 0; i <= length; ++i) {
+     var currentBytePtr = value + 4 + i;
+     if (i == length || HEAPU8[currentBytePtr >>> 0] == 0) {
+      var maxRead = currentBytePtr - decodeStartPtr;
+      var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
+      if (str === undefined) {
+       str = stringSegment;
+      } else {
+       str += String.fromCharCode(0);
+       str += stringSegment;
+      }
+      decodeStartPtr = currentBytePtr + 1;
+     }
+    }
+   } else {
+    var a = new Array(length);
+    for (var i = 0; i < length; ++i) {
+     a[i] = String.fromCharCode(HEAPU8[value + 4 + i >>> 0]);
+    }
+    str = a.join("");
+   }
+   _free(value);
+   return str;
+  },
+  "toWireType": function(destructors, value) {
+   if (value instanceof ArrayBuffer) {
+    value = new Uint8Array(value);
+   }
+   var getLength;
+   var valueIsOfTypeString = typeof value === "string";
+   if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) {
+    throwBindingError("Cannot pass non-string to std::string");
+   }
+   if (stdStringIsUTF8 && valueIsOfTypeString) {
+    getLength = function() {
+     return lengthBytesUTF8(value);
+    };
+   } else {
+    getLength = function() {
+     return value.length;
+    };
+   }
+   var length = getLength();
+   var ptr = _malloc(4 + length + 1);
+   ptr >>>= 0;
+   HEAPU32[ptr >>> 2] = length;
+   if (stdStringIsUTF8 && valueIsOfTypeString) {
+    stringToUTF8(value, ptr + 4, length + 1);
+   } else {
+    if (valueIsOfTypeString) {
+     for (var i = 0; i < length; ++i) {
+      var charCode = value.charCodeAt(i);
+      if (charCode > 255) {
+       _free(ptr);
+       throwBindingError("String has UTF-16 code units that do not fit in 8 bits");
+      }
+      HEAPU8[ptr + 4 + i >>> 0] = charCode;
+     }
+    } else {
+     for (var i = 0; i < length; ++i) {
+      HEAPU8[ptr + 4 + i >>> 0] = value[i];
+     }
+    }
+   }
+   if (destructors !== null) {
+    destructors.push(_free, ptr);
+   }
+   return ptr;
+  },
+  "argPackAdvance": 8,
+  "readValueFromPointer": simpleReadValueFromPointer,
+  destructorFunction: function(ptr) {
+   _free(ptr);
+  }
+ });
+}
+
+function __embind_register_std_wstring(rawType, charSize, name) {
+ name = readLatin1String(name);
+ var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
+ if (charSize === 2) {
+  decodeString = UTF16ToString;
+  encodeString = stringToUTF16;
+  lengthBytesUTF = lengthBytesUTF16;
+  getHeap = function() {
+   return HEAPU16;
+  };
+  shift = 1;
+ } else if (charSize === 4) {
+  decodeString = UTF32ToString;
+  encodeString = stringToUTF32;
+  lengthBytesUTF = lengthBytesUTF32;
+  getHeap = function() {
+   return HEAPU32;
+  };
+  shift = 2;
+ }
+ registerType(rawType, {
+  name: name,
+  "fromWireType": function(value) {
+   var length = HEAPU32[value >>> 2];
+   var HEAP = getHeap();
+   var str;
+   var decodeStartPtr = value + 4;
+   for (var i = 0; i <= length; ++i) {
+    var currentBytePtr = value + 4 + i * charSize;
+    if (i == length || HEAP[currentBytePtr >>> shift] == 0) {
+     var maxReadBytes = currentBytePtr - decodeStartPtr;
+     var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
+     if (str === undefined) {
+      str = stringSegment;
+     } else {
+      str += String.fromCharCode(0);
+      str += stringSegment;
+     }
+     decodeStartPtr = currentBytePtr + charSize;
+    }
+   }
+   _free(value);
+   return str;
+  },
+  "toWireType": function(destructors, value) {
+   if (!(typeof value === "string")) {
+    throwBindingError("Cannot pass non-string to C++ string type " + name);
+   }
+   var length = lengthBytesUTF(value);
+   var ptr = _malloc(4 + length + charSize);
+   ptr >>>= 0;
+   HEAPU32[ptr >>> 2] = length >> shift;
+   encodeString(value, ptr + 4, length + charSize);
+   if (destructors !== null) {
+    destructors.push(_free, ptr);
+   }
+   return ptr;
+  },
+  "argPackAdvance": 8,
+  "readValueFromPointer": simpleReadValueFromPointer,
+  destructorFunction: function(ptr) {
+   _free(ptr);
+  }
+ });
+}
+
+function __embind_register_value_object(rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) {
+ structRegistrations[rawType] = {
+  name: readLatin1String(name),
+  rawConstructor: embind__requireFunction(constructorSignature, rawConstructor),
+  rawDestructor: embind__requireFunction(destructorSignature, rawDestructor),
+  fields: []
+ };
+}
+
+function __embind_register_value_object_field(structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) {
+ structRegistrations[structType].fields.push({
+  fieldName: readLatin1String(fieldName),
+  getterReturnType: getterReturnType,
+  getter: embind__requireFunction(getterSignature, getter),
+  getterContext: getterContext,
+  setterArgumentType: setterArgumentType,
+  setter: embind__requireFunction(setterSignature, setter),
+  setterContext: setterContext
+ });
+}
+
+function __embind_register_void(rawType, name) {
+ name = readLatin1String(name);
+ registerType(rawType, {
+  isVoid: true,
+  name: name,
+  "argPackAdvance": 0,
+  "fromWireType": function() {
+   return undefined;
+  },
+  "toWireType": function(destructors, o) {
+   return undefined;
+  }
+ });
+}
+
+var emval_symbols = {};
+
+function getStringOrSymbol(address) {
+ var symbol = emval_symbols[address];
+ if (symbol === undefined) {
+  return readLatin1String(address);
+ } else {
+  return symbol;
+ }
+}
+
+function emval_get_global() {
+ if (typeof globalThis === "object") {
+  return globalThis;
+ }
+ return function() {
+  return Function;
+ }()("return this")();
+}
+
+function __emval_get_global(name) {
+ if (name === 0) {
+  return __emval_register(emval_get_global());
+ } else {
+  name = getStringOrSymbol(name);
+  return __emval_register(emval_get_global()[name]);
+ }
+}
+
+function __emval_incref(handle) {
+ if (handle > 4) {
+  emval_handle_array[handle].refcount += 1;
+ }
+}
+
+function requireRegisteredType(rawType, humanName) {
+ var impl = registeredTypes[rawType];
+ if (undefined === impl) {
+  throwBindingError(humanName + " has unknown type " + getTypeName(rawType));
+ }
+ return impl;
+}
+
+function craftEmvalAllocator(argCount) {
+ var argsList = "";
+ for (var i = 0; i < argCount; ++i) {
+  argsList += (i !== 0 ? ", " : "") + "arg" + i;
+ }
+ var functionBody = "return function emval_allocator_" + argCount + "(constructor, argTypes, args) {\n";
+ for (var i = 0; i < argCount; ++i) {
+  functionBody += "var argType" + i + " = requireRegisteredType(Module['HEAP32'][(argTypes >>> 2) + " + i + '], "parameter ' + i + '");\n' + "var arg" + i + " = argType" + i + ".readValueFromPointer(args);\n" + "args += argType" + i + "['argPackAdvance'];\n";
+ }
+ functionBody += "var obj = new constructor(" + argsList + ");\n" + "return __emval_register(obj);\n" + "}\n";
+ return new Function("requireRegisteredType", "Module", "__emval_register", functionBody)(requireRegisteredType, Module, __emval_register);
+}
+
+var emval_newers = {};
+
+function requireHandle(handle) {
+ if (!handle) {
+  throwBindingError("Cannot use deleted val. handle = " + handle);
+ }
+ return emval_handle_array[handle].value;
+}
+
+function __emval_new(handle, argCount, argTypes, args) {
+ handle = requireHandle(handle);
+ var newer = emval_newers[argCount];
+ if (!newer) {
+  newer = craftEmvalAllocator(argCount);
+  emval_newers[argCount] = newer;
+ }
+ return newer(handle, argTypes, args);
+}
+
+function _abort() {
+ abort();
+}
+
+function _emscripten_memcpy_big(dest, src, num) {
+ HEAPU8.copyWithin(dest >>> 0, src >>> 0, src + num >>> 0);
+}
+
+function _emscripten_get_heap_size() {
+ return HEAPU8.length;
+}
+
+function emscripten_realloc_buffer(size) {
+ try {
+  wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);
+  updateGlobalBufferAndViews(wasmMemory.buffer);
+  return 1;
+ } catch (e) {}
+}
+
+function _emscripten_resize_heap(requestedSize) {
+ requestedSize = requestedSize >>> 0;
+ var oldSize = _emscripten_get_heap_size();
+ var PAGE_MULTIPLE = 65536;
+ var maxHeapSize = 4294967296;
+ if (requestedSize > maxHeapSize) {
+  return false;
+ }
+ var minHeapSize = 16777216;
+ for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+  var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+  overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+  var newSize = Math.min(maxHeapSize, alignUp(Math.max(minHeapSize, requestedSize, overGrownHeapSize), PAGE_MULTIPLE));
+  var replacement = emscripten_realloc_buffer(newSize);
+  if (replacement) {
+   return true;
+  }
+ }
+ return false;
+}
+
+var ENV = {};
+
+function getExecutableName() {
+ return thisProgram || "./this.program";
+}
+
+function getEnvStrings() {
+ if (!getEnvStrings.strings) {
+  var lang = (typeof navigator === "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8";
+  var env = {
+   "USER": "web_user",
+   "LOGNAME": "web_user",
+   "PATH": "/",
+   "PWD": "/",
+   "HOME": "/home/web_user",
+   "LANG": lang,
+   "_": getExecutableName()
+  };
+  for (var x in ENV) {
+   env[x] = ENV[x];
+  }
+  var strings = [];
+  for (var x in env) {
+   strings.push(x + "=" + env[x]);
+  }
+  getEnvStrings.strings = strings;
+ }
+ return getEnvStrings.strings;
+}
+
+function _environ_get(__environ, environ_buf) {
+ var bufSize = 0;
+ getEnvStrings().forEach(function(string, i) {
+  var ptr = environ_buf + bufSize;
+  HEAP32[__environ + i * 4 >>> 2] = ptr;
+  writeAsciiToMemory(string, ptr);
+  bufSize += string.length + 1;
+ });
+ return 0;
+}
+
+function _environ_sizes_get(penviron_count, penviron_buf_size) {
+ var strings = getEnvStrings();
+ HEAP32[penviron_count >>> 2] = strings.length;
+ var bufSize = 0;
+ strings.forEach(function(string) {
+  bufSize += string.length + 1;
+ });
+ HEAP32[penviron_buf_size >>> 2] = bufSize;
+ return 0;
+}
+
+function _fd_close(fd) {
+ try {
+  var stream = SYSCALLS.getStreamFromFD(fd);
+  FS.close(stream);
+  return 0;
+ } catch (e) {
+  if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
+  return e.errno;
+ }
+}
+
+function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
+ try {
+  var stream = SYSCALLS.getStreamFromFD(fd);
+  var HIGH_OFFSET = 4294967296;
+  var offset = offset_high * HIGH_OFFSET + (offset_low >>> 0);
+  var DOUBLE_LIMIT = 9007199254740992;
+  if (offset <= -DOUBLE_LIMIT || offset >= DOUBLE_LIMIT) {
+   return -61;
+  }
+  FS.llseek(stream, offset, whence);
+  tempI64 = [ stream.position >>> 0, (tempDouble = stream.position, +Math_abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math_min(+Math_floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math_ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], 
+  HEAP32[newOffset >>> 2] = tempI64[0], HEAP32[newOffset + 4 >>> 2] = tempI64[1];
+  if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
+  return 0;
+ } catch (e) {
+  if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
+  return e.errno;
+ }
+}
+
+function _fd_write(fd, iov, iovcnt, pnum) {
+ try {
+  var stream = SYSCALLS.getStreamFromFD(fd);
+  var num = SYSCALLS.doWritev(stream, iov, iovcnt);
+  HEAP32[pnum >>> 2] = num;
+  return 0;
+ } catch (e) {
+  if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError)) abort(e);
+  return e.errno;
+ }
+}
+
+function _round(d) {
+ d = +d;
+ return d >= +0 ? +Math_floor(d + +.5) : +Math_ceil(d - +.5);
+}
+
+function _roundf(d) {
+ d = +d;
+ return d >= +0 ? +Math_floor(d + +.5) : +Math_ceil(d - +.5);
+}
+
+function _setTempRet0($i) {
+ setTempRet0($i | 0);
+}
+
+function __isLeapYear(year) {
+ return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+
+function __arraySum(array, index) {
+ var sum = 0;
+ for (var i = 0; i <= index; sum += array[i++]) {}
+ return sum;
+}
+
+var __MONTH_DAYS_LEAP = [ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ];
+
+var __MONTH_DAYS_REGULAR = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ];
+
+function __addDays(date, days) {
+ var newDate = new Date(date.getTime());
+ while (days > 0) {
+  var leap = __isLeapYear(newDate.getFullYear());
+  var currentMonth = newDate.getMonth();
+  var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth];
+  if (days > daysInCurrentMonth - newDate.getDate()) {
+   days -= daysInCurrentMonth - newDate.getDate() + 1;
+   newDate.setDate(1);
+   if (currentMonth < 11) {
+    newDate.setMonth(currentMonth + 1);
+   } else {
+    newDate.setMonth(0);
+    newDate.setFullYear(newDate.getFullYear() + 1);
+   }
+  } else {
+   newDate.setDate(newDate.getDate() + days);
+   return newDate;
+  }
+ }
+ return newDate;
+}
+
+function _strftime(s, maxsize, format, tm) {
+ var tm_zone = HEAP32[tm + 40 >>> 2];
+ var date = {
+  tm_sec: HEAP32[tm >>> 2],
+  tm_min: HEAP32[tm + 4 >>> 2],
+  tm_hour: HEAP32[tm + 8 >>> 2],
+  tm_mday: HEAP32[tm + 12 >>> 2],
+  tm_mon: HEAP32[tm + 16 >>> 2],
+  tm_year: HEAP32[tm + 20 >>> 2],
+  tm_wday: HEAP32[tm + 24 >>> 2],
+  tm_yday: HEAP32[tm + 28 >>> 2],
+  tm_isdst: HEAP32[tm + 32 >>> 2],
+  tm_gmtoff: HEAP32[tm + 36 >>> 2],
+  tm_zone: tm_zone ? UTF8ToString(tm_zone) : ""
+ };
+ var pattern = UTF8ToString(format);
+ var EXPANSION_RULES_1 = {
+  "%c": "%a %b %d %H:%M:%S %Y",
+  "%D": "%m/%d/%y",
+  "%F": "%Y-%m-%d",
+  "%h": "%b",
+  "%r": "%I:%M:%S %p",
+  "%R": "%H:%M",
+  "%T": "%H:%M:%S",
+  "%x": "%m/%d/%y",
+  "%X": "%H:%M:%S",
+  "%Ec": "%c",
+  "%EC": "%C",
+  "%Ex": "%m/%d/%y",
+  "%EX": "%H:%M:%S",
+  "%Ey": "%y",
+  "%EY": "%Y",
+  "%Od": "%d",
+  "%Oe": "%e",
+  "%OH": "%H",
+  "%OI": "%I",
+  "%Om": "%m",
+  "%OM": "%M",
+  "%OS": "%S",
+  "%Ou": "%u",
+  "%OU": "%U",
+  "%OV": "%V",
+  "%Ow": "%w",
+  "%OW": "%W",
+  "%Oy": "%y"
+ };
+ for (var rule in EXPANSION_RULES_1) {
+  pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]);
+ }
+ var WEEKDAYS = [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ];
+ var MONTHS = [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ];
+ function leadingSomething(value, digits, character) {
+  var str = typeof value === "number" ? value.toString() : value || "";
+  while (str.length < digits) {
+   str = character[0] + str;
+  }
+  return str;
+ }
+ function leadingNulls(value, digits) {
+  return leadingSomething(value, digits, "0");
+ }
+ function compareByDay(date1, date2) {
+  function sgn(value) {
+   return value < 0 ? -1 : value > 0 ? 1 : 0;
+  }
+  var compare;
+  if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
+   if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
+    compare = sgn(date1.getDate() - date2.getDate());
+   }
+  }
+  return compare;
+ }
+ function getFirstWeekStartDate(janFourth) {
+  switch (janFourth.getDay()) {
+  case 0:
+   return new Date(janFourth.getFullYear() - 1, 11, 29);
+
+  case 1:
+   return janFourth;
+
+  case 2:
+   return new Date(janFourth.getFullYear(), 0, 3);
+
+  case 3:
+   return new Date(janFourth.getFullYear(), 0, 2);
+
+  case 4:
+   return new Date(janFourth.getFullYear(), 0, 1);
+
+  case 5:
+   return new Date(janFourth.getFullYear() - 1, 11, 31);
+
+  case 6:
+   return new Date(janFourth.getFullYear() - 1, 11, 30);
+  }
+ }
+ function getWeekBasedYear(date) {
+  var thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
+  var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
+  var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
+  var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
+  var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
+  if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
+   if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
+    return thisDate.getFullYear() + 1;
+   } else {
+    return thisDate.getFullYear();
+   }
+  } else {
+   return thisDate.getFullYear() - 1;
+  }
+ }
+ var EXPANSION_RULES_2 = {
+  "%a": function(date) {
+   return WEEKDAYS[date.tm_wday].substring(0, 3);
+  },
+  "%A": function(date) {
+   return WEEKDAYS[date.tm_wday];
+  },
+  "%b": function(date) {
+   return MONTHS[date.tm_mon].substring(0, 3);
+  },
+  "%B": function(date) {
+   return MONTHS[date.tm_mon];
+  },
+  "%C": function(date) {
+   var year = date.tm_year + 1900;
+   return leadingNulls(year / 100 | 0, 2);
+  },
+  "%d": function(date) {
+   return leadingNulls(date.tm_mday, 2);
+  },
+  "%e": function(date) {
+   return leadingSomething(date.tm_mday, 2, " ");
+  },
+  "%g": function(date) {
+   return getWeekBasedYear(date).toString().substring(2);
+  },
+  "%G": function(date) {
+   return getWeekBasedYear(date);
+  },
+  "%H": function(date) {
+   return leadingNulls(date.tm_hour, 2);
+  },
+  "%I": function(date) {
+   var twelveHour = date.tm_hour;
+   if (twelveHour == 0) twelveHour = 12; else if (twelveHour > 12) twelveHour -= 12;
+   return leadingNulls(twelveHour, 2);
+  },
+  "%j": function(date) {
+   return leadingNulls(date.tm_mday + __arraySum(__isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon - 1), 3);
+  },
+  "%m": function(date) {
+   return leadingNulls(date.tm_mon + 1, 2);
+  },
+  "%M": function(date) {
+   return leadingNulls(date.tm_min, 2);
+  },
+  "%n": function() {
+   return "\n";
+  },
+  "%p": function(date) {
+   if (date.tm_hour >= 0 && date.tm_hour < 12) {
+    return "AM";
+   } else {
+    return "PM";
+   }
+  },
+  "%S": function(date) {
+   return leadingNulls(date.tm_sec, 2);
+  },
+  "%t": function() {
+   return "\t";
+  },
+  "%u": function(date) {
+   return date.tm_wday || 7;
+  },
+  "%U": function(date) {
+   var janFirst = new Date(date.tm_year + 1900, 0, 1);
+   var firstSunday = janFirst.getDay() === 0 ? janFirst : __addDays(janFirst, 7 - janFirst.getDay());
+   var endDate = new Date(date.tm_year + 1900, date.tm_mon, date.tm_mday);
+   if (compareByDay(firstSunday, endDate) < 0) {
+    var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth() - 1) - 31;
+    var firstSundayUntilEndJanuary = 31 - firstSunday.getDate();
+    var days = firstSundayUntilEndJanuary + februaryFirstUntilEndMonth + endDate.getDate();
+    return leadingNulls(Math.ceil(days / 7), 2);
+   }
+   return compareByDay(firstSunday, janFirst) === 0 ? "01" : "00";
+  },
+  "%V": function(date) {
+   var janFourthThisYear = new Date(date.tm_year + 1900, 0, 4);
+   var janFourthNextYear = new Date(date.tm_year + 1901, 0, 4);
+   var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
+   var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
+   var endDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday);
+   if (compareByDay(endDate, firstWeekStartThisYear) < 0) {
+    return "53";
+   }
+   if (compareByDay(firstWeekStartNextYear, endDate) <= 0) {
+    return "01";
+   }
+   var daysDifference;
+   if (firstWeekStartThisYear.getFullYear() < date.tm_year + 1900) {
+    daysDifference = date.tm_yday + 32 - firstWeekStartThisYear.getDate();
+   } else {
+    daysDifference = date.tm_yday + 1 - firstWeekStartThisYear.getDate();
+   }
+   return leadingNulls(Math.ceil(daysDifference / 7), 2);
+  },
+  "%w": function(date) {
+   return date.tm_wday;
+  },
+  "%W": function(date) {
+   var janFirst = new Date(date.tm_year, 0, 1);
+   var firstMonday = janFirst.getDay() === 1 ? janFirst : __addDays(janFirst, janFirst.getDay() === 0 ? 1 : 7 - janFirst.getDay() + 1);
+   var endDate = new Date(date.tm_year + 1900, date.tm_mon, date.tm_mday);
+   if (compareByDay(firstMonday, endDate) < 0) {
+    var februaryFirstUntilEndMonth = __arraySum(__isLeapYear(endDate.getFullYear()) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, endDate.getMonth() - 1) - 31;
+    var firstMondayUntilEndJanuary = 31 - firstMonday.getDate();
+    var days = firstMondayUntilEndJanuary + februaryFirstUntilEndMonth + endDate.getDate();
+    return leadingNulls(Math.ceil(days / 7), 2);
+   }
+   return compareByDay(firstMonday, janFirst) === 0 ? "01" : "00";
+  },
+  "%y": function(date) {
+   return (date.tm_year + 1900).toString().substring(2);
+  },
+  "%Y": function(date) {
+   return date.tm_year + 1900;
+  },
+  "%z": function(date) {
+   var off = date.tm_gmtoff;
+   var ahead = off >= 0;
+   off = Math.abs(off) / 60;
+   off = off / 60 * 100 + off % 60;
+   return (ahead ? "+" : "-") + String("0000" + off).slice(-4);
+  },
+  "%Z": function(date) {
+   return date.tm_zone;
+  },
+  "%%": function() {
+   return "%";
+  }
+ };
+ for (var rule in EXPANSION_RULES_2) {
+  if (pattern.indexOf(rule) >= 0) {
+   pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date));
+  }
+ }
+ var bytes = intArrayFromString(pattern, false);
+ if (bytes.length > maxsize) {
+  return 0;
+ }
+ writeArrayToMemory(bytes, s);
+ return bytes.length - 1;
+}
+
+function _strftime_l(s, maxsize, format, tm) {
+ return _strftime(s, maxsize, format, tm);
+}
+
+var FSNode = function(parent, name, mode, rdev) {
+ if (!parent) {
+  parent = this;
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.mounted = null;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.node_ops = {};
+ this.stream_ops = {};
+ this.rdev = rdev;
+};
+
+var readMode = 292 | 73;
+
+var writeMode = 146;
+
+Object.defineProperties(FSNode.prototype, {
+ read: {
+  get: function() {
+   return (this.mode & readMode) === readMode;
+  },
+  set: function(val) {
+   val ? this.mode |= readMode : this.mode &= ~readMode;
+  }
+ },
+ write: {
+  get: function() {
+   return (this.mode & writeMode) === writeMode;
+  },
+  set: function(val) {
+   val ? this.mode |= writeMode : this.mode &= ~writeMode;
+  }
+ },
+ isFolder: {
+  get: function() {
+   return FS.isDir(this.mode);
+  }
+ },
+ isDevice: {
+  get: function() {
+   return FS.isChrdev(this.mode);
+  }
+ }
+});
+
+FS.FSNode = FSNode;
+
+FS.staticInit();
+
+InternalError = Module["InternalError"] = extendError(Error, "InternalError");
+
+embind_init_charCodes();
+
+BindingError = Module["BindingError"] = extendError(Error, "BindingError");
+
+init_emval();
+
+UnboundTypeError = Module["UnboundTypeError"] = extendError(Error, "UnboundTypeError");
+
+function intArrayFromString(stringy, dontAddNull, length) {
+ var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
+ var u8array = new Array(len);
+ var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
+ if (dontAddNull) u8array.length = numBytesWritten;
+ return u8array;
+}
+
+var asmLibraryArg = {
+ "G": ___cxa_allocate_exception,
+ "F": ___cxa_thread_atexit,
+ "E": ___cxa_throw,
+ "D": ___map_file,
+ "C": ___sys_munmap,
+ "y": __embind_finalize_value_object,
+ "x": __embind_register_bool,
+ "w": __embind_register_emval,
+ "k": __embind_register_float,
+ "v": __embind_register_function,
+ "b": __embind_register_integer,
+ "a": __embind_register_memory_view,
+ "j": __embind_register_std_string,
+ "g": __embind_register_std_wstring,
+ "u": __embind_register_value_object,
+ "i": __embind_register_value_object_field,
+ "t": __embind_register_void,
+ "h": __emval_decref,
+ "s": __emval_get_global,
+ "r": __emval_incref,
+ "q": __emval_new,
+ "f": _abort,
+ "p": _emscripten_memcpy_big,
+ "d": _emscripten_resize_heap,
+ "B": _environ_get,
+ "A": _environ_sizes_get,
+ "z": _fd_close,
+ "o": _fd_seek,
+ "l": _fd_write,
+ "memory": wasmMemory,
+ "e": _round,
+ "c": _roundf,
+ "n": _setTempRet0,
+ "m": _strftime_l,
+ "table": wasmTable
+};
+
+var asm = createWasm();
+
+var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() {
+ return (___wasm_call_ctors = Module["___wasm_call_ctors"] = Module["asm"]["H"]).apply(null, arguments);
+};
+
+var _malloc = Module["_malloc"] = function() {
+ return (_malloc = Module["_malloc"] = Module["asm"]["I"]).apply(null, arguments);
+};
+
+var _free = Module["_free"] = function() {
+ return (_free = Module["_free"] = Module["asm"]["J"]).apply(null, arguments);
+};
+
+var ___errno_location = Module["___errno_location"] = function() {
+ return (___errno_location = Module["___errno_location"] = Module["asm"]["K"]).apply(null, arguments);
+};
+
+var ___getTypeName = Module["___getTypeName"] = function() {
+ return (___getTypeName = Module["___getTypeName"] = Module["asm"]["L"]).apply(null, arguments);
+};
+
+var ___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = function() {
+ return (___embind_register_native_and_builtin_types = Module["___embind_register_native_and_builtin_types"] = Module["asm"]["M"]).apply(null, arguments);
+};
+
+var dynCall_i = Module["dynCall_i"] = function() {
+ return (dynCall_i = Module["dynCall_i"] = Module["asm"]["N"]).apply(null, arguments);
+};
+
+var dynCall_vi = Module["dynCall_vi"] = function() {
+ return (dynCall_vi = Module["dynCall_vi"] = Module["asm"]["O"]).apply(null, arguments);
+};
+
+var dynCall_iii = Module["dynCall_iii"] = function() {
+ return (dynCall_iii = Module["dynCall_iii"] = Module["asm"]["P"]).apply(null, arguments);
+};
+
+var dynCall_viii = Module["dynCall_viii"] = function() {
+ return (dynCall_viii = Module["dynCall_viii"] = Module["asm"]["Q"]).apply(null, arguments);
+};
+
+var dynCall_fii = Module["dynCall_fii"] = function() {
+ return (dynCall_fii = Module["dynCall_fii"] = Module["asm"]["R"]).apply(null, arguments);
+};
+
+var dynCall_viif = Module["dynCall_viif"] = function() {
+ return (dynCall_viif = Module["dynCall_viif"] = Module["asm"]["S"]).apply(null, arguments);
+};
+
+var dynCall_iiiiii = Module["dynCall_iiiiii"] = function() {
+ return (dynCall_iiiiii = Module["dynCall_iiiiii"] = Module["asm"]["T"]).apply(null, arguments);
+};
+
+var dynCall_viiiii = Module["dynCall_viiiii"] = function() {
+ return (dynCall_viiiii = Module["dynCall_viiiii"] = Module["asm"]["U"]).apply(null, arguments);
+};
+
+var dynCall_ii = Module["dynCall_ii"] = function() {
+ return (dynCall_ii = Module["dynCall_ii"] = Module["asm"]["V"]).apply(null, arguments);
+};
+
+var dynCall_iidiiii = Module["dynCall_iidiiii"] = function() {
+ return (dynCall_iidiiii = Module["dynCall_iidiiii"] = Module["asm"]["W"]).apply(null, arguments);
+};
+
+var dynCall_vii = Module["dynCall_vii"] = function() {
+ return (dynCall_vii = Module["dynCall_vii"] = Module["asm"]["X"]).apply(null, arguments);
+};
+
+var dynCall_iiiiiii = Module["dynCall_iiiiiii"] = function() {
+ return (dynCall_iiiiiii = Module["dynCall_iiiiiii"] = Module["asm"]["Y"]).apply(null, arguments);
+};
+
+var dynCall_iiii = Module["dynCall_iiii"] = function() {
+ return (dynCall_iiii = Module["dynCall_iiii"] = Module["asm"]["Z"]).apply(null, arguments);
+};
+
+var dynCall_v = Module["dynCall_v"] = function() {
+ return (dynCall_v = Module["dynCall_v"] = Module["asm"]["_"]).apply(null, arguments);
+};
+
+var dynCall_viiiiiii = Module["dynCall_viiiiiii"] = function() {
+ return (dynCall_viiiiiii = Module["dynCall_viiiiiii"] = Module["asm"]["$"]).apply(null, arguments);
+};
+
+var dynCall_viijii = Module["dynCall_viijii"] = function() {
+ return (dynCall_viijii = Module["dynCall_viijii"] = Module["asm"]["aa"]).apply(null, arguments);
+};
+
+var dynCall_viiii = Module["dynCall_viiii"] = function() {
+ return (dynCall_viiii = Module["dynCall_viiii"] = Module["asm"]["ba"]).apply(null, arguments);
+};
+
+var dynCall_iiiii = Module["dynCall_iiiii"] = function() {
+ return (dynCall_iiiii = Module["dynCall_iiiii"] = Module["asm"]["ca"]).apply(null, arguments);
+};
+
+var dynCall_fi = Module["dynCall_fi"] = function() {
+ return (dynCall_fi = Module["dynCall_fi"] = Module["asm"]["da"]).apply(null, arguments);
+};
+
+var dynCall_iiji = Module["dynCall_iiji"] = function() {
+ return (dynCall_iiji = Module["dynCall_iiji"] = Module["asm"]["ea"]).apply(null, arguments);
+};
+
+var dynCall_iifi = Module["dynCall_iifi"] = function() {
+ return (dynCall_iifi = Module["dynCall_iifi"] = Module["asm"]["fa"]).apply(null, arguments);
+};
+
+var dynCall_jiji = Module["dynCall_jiji"] = function() {
+ return (dynCall_jiji = Module["dynCall_jiji"] = Module["asm"]["ga"]).apply(null, arguments);
+};
+
+var dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = function() {
+ return (dynCall_iiiiiiiii = Module["dynCall_iiiiiiiii"] = Module["asm"]["ha"]).apply(null, arguments);
+};
+
+var dynCall_viiiiii = Module["dynCall_viiiiii"] = function() {
+ return (dynCall_viiiiii = Module["dynCall_viiiiii"] = Module["asm"]["ia"]).apply(null, arguments);
+};
+
+var dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = function() {
+ return (dynCall_iiiiiiii = Module["dynCall_iiiiiiii"] = Module["asm"]["ja"]).apply(null, arguments);
+};
+
+var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = function() {
+ return (dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = Module["asm"]["ka"]).apply(null, arguments);
+};
+
+var dynCall_iiiiij = Module["dynCall_iiiiij"] = function() {
+ return (dynCall_iiiiij = Module["dynCall_iiiiij"] = Module["asm"]["la"]).apply(null, arguments);
+};
+
+var dynCall_iiiiid = Module["dynCall_iiiiid"] = function() {
+ return (dynCall_iiiiid = Module["dynCall_iiiiid"] = Module["asm"]["ma"]).apply(null, arguments);
+};
+
+var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = function() {
+ return (dynCall_iiiiijj = Module["dynCall_iiiiijj"] = Module["asm"]["na"]).apply(null, arguments);
+};
+
+var calledRun;
+
+function ExitStatus(status) {
+ this.name = "ExitStatus";
+ this.message = "Program terminated with exit(" + status + ")";
+ this.status = status;
+}
+
+dependenciesFulfilled = function runCaller() {
+ if (!calledRun) run();
+ if (!calledRun) dependenciesFulfilled = runCaller;
+};
+
+function run(args) {
+ args = args || arguments_;
+ if (runDependencies > 0) {
+  return;
+ }
+ preRun();
+ if (runDependencies > 0) return;
+ function doRun() {
+  if (calledRun) return;
+  calledRun = true;
+  Module["calledRun"] = true;
+  if (ABORT) return;
+  initRuntime();
+  preMain();
+  readyPromiseResolve(Module);
+  if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
+  postRun();
+ }
+ if (Module["setStatus"]) {
+  Module["setStatus"]("Running...");
+  setTimeout(function() {
+   setTimeout(function() {
+    Module["setStatus"]("");
+   }, 1);
+   doRun();
+  }, 1);
+ } else {
+  doRun();
+ }
+}
+
+Module["run"] = run;
+
+if (Module["preInit"]) {
+ if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
+ while (Module["preInit"].length > 0) {
+  Module["preInit"].pop()();
+ }
+}
+
+noExitRuntime = true;
+
+run();
 
 
   return jxl_enc.ready
diff --git a/codecs/jxl/enc/jxl_enc.wasm b/codecs/jxl/enc/jxl_enc.wasm
index df1c2179..3f6b66d7 100644
Binary files a/codecs/jxl/enc/jxl_enc.wasm and b/codecs/jxl/enc/jxl_enc.wasm differ