!function (e,t) {
 "object" == typeof exports && "undefined" != typeof module ? t(exports) : "function" == typeof define && define.amd ? define(["exports"],t) : t(e.dat={});
}(this,function (e) {
 "use strict";

 function t(e,t) {
 var n=e.__state.conversionName.toString(),o=Math.round(e.r),i=Math.round(e.g),r=Math.round(e.b),
 s=e.a,a=Math.round(e.h),l=e.s.toFixed(1),d=e.v.toFixed(1);
 if (t || "THREE_CHAR_HEX" === n || "SIX_CHAR_HEX" === n) {
 for (var c=e.hex.toString(16); c.length < 6;) c="0" + c;
 return "#" + c;
 }
 return "CSS_RGB" === n ? "rgb(" + o + "," + i + "," + r + ")" : "CSS_RGBA" === n ? "rgba(" + o + "," + i + "," + r + "," + s + ")" : "HEX" === n ? "0x" + e.hex.toString(16) : "RGB_ARRAY" === n ? "[" + o + "," + i + "," + r + "]" : "RGBA_ARRAY" === n ? "[" + o + "," + i + "," + r + "," + s + "]" : "RGB_OBJ" === n ? "{r:" + o + ",g:" + i + ",b:" + r + "}" : "RGBA_OBJ" === n ? "{r:" + o + ",g:" + i + ",b:" + r + ",a:" + s + "}" : "HSV_OBJ" === n ? "{h:" + a + ",s:" + l + ",v:" + d + "}" : "HSVA_OBJ" === n ? "{h:" + a + ",s:" + l + ",v:" + d + ",a:" + s + "}" : "unknown format";
 }

 function n(e,t,n) {
 Object.defineProperty(e,t,{
 get: function () {
 return "RGB" === this.__state.space ? this.__state[t] : (I.recalculateRGB(this,t,n),this.__state[t]);
 },set: function (e) {
 "RGB" !== this.__state.space && (I.recalculateRGB(this,t,n),this.__state.space="RGB"),this.__state[t]=e;
 }
 });
 }

 function o(e,t) {
 Object.defineProperty(e,t,{
 get: function () {
 return "HSV" === this.__state.space ? this.__state[t] : (I.recalculateHSV(this),this.__state[t]);
 },set: function (e) {
 "HSV" !== this.__state.space && (I.recalculateHSV(this),this.__state.space="HSV"),this.__state[t]=e;
 }
 });
 }

 function i(e) {
 if ("0" === e || S.isUndefined(e)) return 0;
 var t=e.match(U);
 return S.isNull(t) ? 0 : parseFloat(t[1]);
 }

 function r(e) {
 var t=e.toString();
 return t.indexOf(".") > -1 ? t.length - t.indexOf(".") - 1 : 0;
 }

 function s(e,t) {
 var n=Math.pow(10,t);
 return Math.round(e * n) / n;
 }

 function a(e,t,n,o,i) {
 return o + (e - t) / (n - t) * (i - o);
 }

 function l(e,t,n,o) {
 e.style.background="",S.each(ee,function (i) {
 e.style.cssText += "background: " + i + "linear-gradient(" + t + "," + n + " 0%," + o + " 100%); ";
 });
 }

 function d(e) {
 e.style.background="",e.style.cssText += "background: -moz-linear-gradient(top,#ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);",e.style.cssText += "background: -webkit-linear-gradient(top,#ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);",e.style.cssText += "background: -o-linear-gradient(top,#ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);",e.style.cssText += "background: -ms-linear-gradient(top,#ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);",e.style.cssText += "background: linear-gradient(top,#ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);";
 }

 function c(e,t,n) {
 var o=document.createElement("li");
 return t && o.appendChild(t),n ? e.__ul.insertBefore(o,n) : e.__ul.appendChild(o),e.onResize(),o;
 }

 function u(e) {
 X.unbind(window,"resize",e.__resizeHandler),e.saveToLocalStorageIfPossible && X.unbind(window,"unload",e.saveToLocalStorageIfPossible);
 }

 function _(e,t) {
 var n=e.__preset_select[e.__preset_select.selectedIndex];
 n.innerHTML=t ? n.value + "*" : n.value;
 }

 function h(e,t,n) {
 if (n.__li=t,n.__gui=e,S.extend(n,{
 options: function (t) {
 if (arguments.length > 1) {
 var o=n.__li.nextElementSibling;
 return n.remove(),f(e,n.object,n.property,{before: o,factoryArgs: [S.toArray(arguments)]});
 }
 if (S.isArray(t) || S.isObject(t)) {
 var i=n.__li.nextElementSibling;
 return n.remove(),f(e,n.object,n.property,{before: i,factoryArgs: [t]});
 }
 },name: function (e) {
 return n.__li.firstElementChild.firstElementChild.innerHTML=e,n;
 },listen: function () {
 return n.__gui.listen(n),n;
 },remove: function () {
 return n.__gui.remove(n),n;
 }
 }),n instanceof q) {
 var o=new Q(n.object,n.property,{min: n.__min,max: n.__max,step: n.__step});
 S.each(["updateDisplay","onChange","onFinishChange","step"],function (e) {
 var t=n[e],i=o[e];
 n[e]=o[e]=function () {
 var e=Array.prototype.slice.call(arguments);
 return i.apply(o,e),t.apply(n,e);
 };
 }),X.addClass(t,"has-slider"),n.domElement.insertBefore(o.domElement,n.domElement.firstElementChild);
 } else if (n instanceof Q) {
 var i=function (t) {
 if (S.isNumber(n.__min) && S.isNumber(n.__max)) {
 var o=n.__li.firstElementChild.firstElementChild.innerHTML,
 i=n.__gui.__listening.indexOf(n) > -1;
 n.remove();
 var r=f(e,n.object,n.property,{
 before: n.__li.nextElementSibling,
 factoryArgs: [n.__min,n.__max,n.__step]
 });
 return r.name(o),i && r.listen(),r;
 }
 return t;
 };
 n.min=S.compose(i,n.min),n.max=S.compose(i,n.max);
 } else n instanceof K ? (X.bind(t,"click",function () {
 X.fakeEvent(n.__checkbox,"click");
 }),X.bind(n.__checkbox,"click",function (e) {
 e.stopPropagation();
 })) : n instanceof Z ? (X.bind(t,"click",function () {
 X.fakeEvent(n.__button,"click");
 }),X.bind(t,"mouseover",function () {
 X.addClass(n.__button,"hover");
 }),X.bind(t,"mouseout",function () {
 X.removeClass(n.__button,"hover");
 })) : n instanceof $ && (X.addClass(t,"color"),n.updateDisplay=S.compose(function (e) {
 return t.style.borderLeftColor=n.__color.toString(),e;
 },n.updateDisplay),n.updateDisplay());
 n.setValue=S.compose(function (t) {
 return e.getRoot().__preset_select && n.isModified() && _(e.getRoot(),!0),t;
 },n.setValue);
 }

 function p(e,t) {
 var n=e.getRoot(),o=n.__rememberedObjects.indexOf(t.object);
 if (-1 !== o) {
 var i=n.__rememberedObjectIndecesToControllers[o];
 if (void 0 === i && (i={},n.__rememberedObjectIndecesToControllers[o]=i),i[t.property]=t,n.load && n.load.remembered) {
 var r=n.load.remembered,s=void 0;
 if (r[e.preset]) s=r[e.preset]; else {
 if (!r[se]) return;
 s=r[se];
 }
 if (s[o] && void 0 !== s[o][t.property]) {
 var a=s[o][t.property];
 t.initialValue=a,t.setValue(a);
 }
 }
 }
 }

 function f(e,t,n,o) {
 if (void 0 === t[n]) throw new Error('Object "' + t + '" has no property "' + n + '"');
 var i=void 0;
 if (o.color) i=new $(t,n); else {
 var r=[t,n].concat(o.factoryArgs);
 i=ne.apply(e,r);
 }
 o.before instanceof z && (o.before=o.before.__li),p(e,i),X.addClass(i.domElement,"c");
 var s=document.createElement("span");
 X.addClass(s,"property-name"),s.innerHTML=i.property;
 var a=document.createElement("div");
 a.appendChild(s),a.appendChild(i.domElement);
 var l=c(e,a,o.before);
 return X.addClass(l,he.CLASS_CONTROLLER_ROW),i instanceof $ ? X.addClass(l,"color") : X.addClass(l,H(i.getValue())),h(e,l,i),e.__controllers.push(i),i;
 }

 function m(e,t) {
 return document.location.href + "." + t;
 }

 function g(e,t,n) {
 var o=document.createElement("option");
 o.innerHTML=t,o.value=t,e.__preset_select.appendChild(o),n && (e.__preset_select.selectedIndex=e.__preset_select.length - 1);
 }

 function b(e,t) {
 t.style.display=e.useLocalStorage ? "block" : "none";
 }

 function v(e) {
 var t=e.__save_row=document.createElement("li");
 X.addClass(e.domElement,"has-save"),e.__ul.insertBefore(t,e.__ul.firstChild),X.addClass(t,"save-row");
 var n=document.createElement("span");
 n.innerHTML="&nbsp;",X.addClass(n,"button gears");
 var o=document.createElement("span");
 o.innerHTML="Save",X.addClass(o,"button"),X.addClass(o,"save");
 var i=document.createElement("span");
 i.innerHTML="New",X.addClass(i,"button"),X.addClass(i,"save-as");
 var r=document.createElement("span");
 r.innerHTML="Revert",X.addClass(r,"button"),X.addClass(r,"revert");
 var s=e.__preset_select=document.createElement("select");
 if (e.load && e.load.remembered ? S.each(e.load.remembered,function (t,n) {
 g(e,n,n === e.preset);
 }) : g(e,se,!1),X.bind(s,"change",function () {
 for (var t=0; t < e.__preset_select.length; t++) e.__preset_select[t].innerHTML=e.__preset_select[t].value;
 e.preset=this.value;
 }),t.appendChild(s),t.appendChild(n),t.appendChild(o),t.appendChild(i),t.appendChild(r),ae) {
 var a=document.getElementById("dg-local-explain"),l=document.getElementById("dg-local-storage");
 document.getElementById("dg-save-locally").style.display="block","true" === localStorage.getItem(m(e,"isLocal")) && l.setAttribute("checked","checked"),b(e,a),X.bind(l,"change",function () {
 e.useLocalStorage=!e.useLocalStorage,b(e,a);
 });
 }
 var d=document.getElementById("dg-new-constructor");
 X.bind(d,"keydown",function (e) {
 !e.metaKey || 67 !== e.which && 67 !== e.keyCode || le.hide();
 }),X.bind(n,"click",function () {
 d.innerHTML=JSON.stringify(e.getSaveObject(),void 0,2),le.show(),d.focus(),d.select();
 }),X.bind(o,"click",function () {
 e.save();
 }),X.bind(i,"click",function () {
 var t=prompt("Enter a new preset name.");
 t && e.saveAs(t);
 }),X.bind(r,"click",function () {
 e.revert();
 });
 }

 function y(e) {
 function t(t) {
 return t.preventDefault(),e.width += i - t.clientX,e.onResize(),i=t.clientX,!1;
 }

 function n() {
 X.removeClass(e.__closeButton,he.CLASS_DRAG),X.unbind(window,"mousemove",t),X.unbind(window,"mouseup",n);
 }

 function o(o) {
 return o.preventDefault(),i=o.clientX,X.addClass(e.__closeButton,he.CLASS_DRAG),X.bind(window,"mousemove",t),X.bind(window,"mouseup",n),!1;
 }

 var i=void 0;
 e.__resize_handle=document.createElement("div"),S.extend(e.__resize_handle.style,{
 width: "6px",marginLeft: "-3px",height: "200px",cursor: "ew-resize",position: "absolute"
 }),X.bind(e.__resize_handle,"mousedown",o),X.bind(e.__closeButton,"mousedown",o),e.domElement.insertBefore(e.__resize_handle,e.domElement.firstElementChild);
 }

 function w(e,t) {
 e.domElement.style.width=t + "px",e.__save_row && e.autoPlace && (e.__save_row.style.width=t + "px"),e.__closeButton && (e.__closeButton.style.width=t + "px");
 }

 function x(e,t) {
 var n={};
 return S.each(e.__rememberedObjects,function (o,i) {
 var r={},s=e.__rememberedObjectIndecesToControllers[i];
 S.each(s,function (e,n) {
 r[n]=t ? e.initialValue : e.getValue();
 }),n[i]=r;
 }),n;
 }

 function E(e) {
 for (var t=0; t < e.__preset_select.length; t++) e.__preset_select[t].value === e.preset && (e.__preset_select.selectedIndex=t);
 }

 function C(e) {
 0 !== e.length && oe.call(window,function () {
 C(e);
 }),S.each(e,function (e) {
 e.updateDisplay();
 });
 }

 var A=Array.prototype.forEach,k=Array.prototype.slice,S={
 BREAK: {},extend: function (e) {
 return this.each(k.call(arguments,1),function (t) {
 (this.isObject(t) ? Object.keys(t) : []).forEach(function (n) {
 this.isUndefined(t[n]) || (e[n]=t[n]);
 }.bind(this));
 },this),e;
 },defaults: function (e) {
 return this.each(k.call(arguments,1),function (t) {
 (this.isObject(t) ? Object.keys(t) : []).forEach(function (n) {
 this.isUndefined(e[n]) && (e[n]=t[n]);
 }.bind(this));
 },this),e;
 },compose: function () {
 var e=k.call(arguments);
 return function () {
 for (var t=k.call(arguments),n=e.length - 1; n >= 0; n--) t=[e[n].apply(this,t)];
 return t[0];
 };
 },each: function (e,t,n) {
 if (e) if (A && e.forEach && e.forEach === A) e.forEach(t,n); else if (e.length === e.length + 0) {
 var o=void 0,i=void 0;
 for (o=0,i=e.length; o < i; o++) if (o in e && t.call(n,e[o],o) === this.BREAK) return;
 } else for (var r in e) if (t.call(n,e[r],r) === this.BREAK) return;
 },defer: function (e) {
 setTimeout(e,0);
 },debounce: function (e,t,n) {
 var o=void 0;
 return function () {
 var i=this,r=arguments,s=n || !o;
 clearTimeout(o),o=setTimeout(function () {
 o=null,n || e.apply(i,r);
 },t),s && e.apply(i,r);
 };
 },toArray: function (e) {
 return e.toArray ? e.toArray() : k.call(e);
 },isUndefined: function (e) {
 return void 0 === e;
 },isNull: function (e) {
 return null === e;
 },isNaN: function (e) {
 function t(t) {
 return e.apply(this,arguments);
 }

 return t.toString=function () {
 return e.toString();
 },t;
 }(function (e) {
 return isNaN(e);
 }),isArray: Array.isArray || function (e) {
 return e.constructor === Array;
 },isObject: function (e) {
 return e === Object(e);
 },isNumber: function (e) {
 return e === e + 0;
 },isString: function (e) {
 return e === e + "";
 },isBoolean: function (e) {
 return !1 === e || !0 === e;
 },isFunction: function (e) {
 return "[object Function]" === Object.prototype.toString.call(e);
 }
 },O=[{
 litmus: S.isString,conversions: {
 THREE_CHAR_HEX: {
 read: function (e) {
 var t=e.match(/^#([A-F0-9])([A-F0-9])([A-F0-9])$/i);
 return null !== t && {
 space: "HEX",
 hex: parseInt("0x" + t[1].toString() + t[1].toString() + t[2].toString() + t[2].toString() + t[3].toString() + t[3].toString(),0)
 };
 },write: t
 },SIX_CHAR_HEX: {
 read: function (e) {
 var t=e.match(/^#([A-F0-9]{6})$/i);
 return null !== t && {space: "HEX",hex: parseInt("0x" + t[1].toString(),0)};
 },write: t
 },CSS_RGB: {
 read: function (e) {
 var t=e.match(/^rgb\(\s*(.+)\s*,\s*(.+)\s*,\s*(.+)\s*\)/);
 return null !== t && {space: "RGB",r: parseFloat(t[1]),g: parseFloat(t[2]),b: parseFloat(t[3])};
 },write: t
 },CSS_RGBA: {
 read: function (e) {
 var t=e.match(/^rgba\(\s*(.+)\s*,\s*(.+)\s*,\s*(.+)\s*,\s*(.+)\s*\)/);
 return null !== t && {
 space: "RGB",
 r: parseFloat(t[1]),
 g: parseFloat(t[2]),
 b: parseFloat(t[3]),
 a: parseFloat(t[4])
 };
 },write: t
 }
 }
 },{
 litmus: S.isNumber,conversions: {
 HEX: {
 read: function (e) {
 return {space: "HEX",hex: e,conversionName: "HEX"};
 },write: function (e) {
 return e.hex;
 }
 }
 }
 },{
 litmus: S.isArray,conversions: {
 RGB_ARRAY: {
 read: function (e) {
 return 3 === e.length && {space: "RGB",r: e[0],g: e[1],b: e[2]};
 },write: function (e) {
 return [e.r,e.g,e.b];
 }
 },RGBA_ARRAY: {
 read: function (e) {
 return 4 === e.length && {space: "RGB",r: e[0],g: e[1],b: e[2],a: e[3]};
 },write: function (e) {
 return [e.r,e.g,e.b,e.a];
 }
 }
 }
 },{
 litmus: S.isObject,conversions: {
 RGBA_OBJ: {
 read: function (e) {
 return !!(S.isNumber(e.r) && S.isNumber(e.g) && S.isNumber(e.b) && S.isNumber(e.a)) && {
 space: "RGB",r: e.r,g: e.g,b: e.b,a: e.a
 };
 },write: function (e) {
 return {r: e.r,g: e.g,b: e.b,a: e.a};
 }
 },RGB_OBJ: {
 read: function (e) {
 return !!(S.isNumber(e.r) && S.isNumber(e.g) && S.isNumber(e.b)) && {
 space: "RGB",
 r: e.r,
 g: e.g,
 b: e.b
 };
 },write: function (e) {
 return {r: e.r,g: e.g,b: e.b};
 }
 },HSVA_OBJ: {
 read: function (e) {
 return !!(S.isNumber(e.h) && S.isNumber(e.s) && S.isNumber(e.v) && S.isNumber(e.a)) && {
 space: "HSV",h: e.h,s: e.s,v: e.v,a: e.a
 };
 },write: function (e) {
 return {h: e.h,s: e.s,v: e.v,a: e.a};
 }
 },HSV_OBJ: {
 read: function (e) {
 return !!(S.isNumber(e.h) && S.isNumber(e.s) && S.isNumber(e.v)) && {
 space: "HSV",
 h: e.h,
 s: e.s,
 v: e.v
 };
 },write: function (e) {
 return {h: e.h,s: e.s,v: e.v};
 }
 }
 }
 }],T=void 0,L=void 0,R=function () {
 L=!1;
 var e=arguments.length > 1 ? S.toArray(arguments) : arguments[0];
 return S.each(O,function (t) {
 if (t.litmus(e)) return S.each(t.conversions,function (t,n) {
 if (T=t.read(e),!1 === L && !1 !== T) return L=T,T.conversionName=n,T.conversion=t,S.BREAK;
 }),S.BREAK;
 }),L;
 },B=void 0,N={
 hsv_to_rgb: function (e,t,n) {
 var o=Math.floor(e / 60) % 6,i=e / 60 - Math.floor(e / 60),r=n * (1 - t),s=n * (1 - i * t),
 a=n * (1 - (1 - i) * t),l=[[n,a,r],[s,n,r],[r,n,a],[r,s,n],[a,r,n],[n,r,s]][o];
 return {r: 255 * l[0],g: 255 * l[1],b: 255 * l[2]};
 },rgb_to_hsv: function (e,t,n) {
 var o=Math.min(e,t,n),i=Math.max(e,t,n),r=i - o,s=void 0,a=void 0;
 return 0 === i ? {
 h: NaN,
 s: 0,
 v: 0
 } : (a=r / i,s=e === i ? (t - n) / r : t === i ? 2 + (n - e) / r : 4 + (e - t) / r,(s /= 6) < 0 && (s += 1),{
 h: 360 * s,s: a,v: i / 255
 });
 },rgb_to_hex: function (e,t,n) {
 var o=this.hex_with_component(0,2,e);
 return o=this.hex_with_component(o,1,t),o=this.hex_with_component(o,0,n);
 },component_from_hex: function (e,t) {
 return e >> 8 * t & 255;
 },hex_with_component: function (e,t,n) {
 return n << (B=8 * t) | e & ~(255 << B);
 }
 },H="function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (e) {
 return typeof e;
 } : function (e) {
 return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
 },F=function (e,t) {
 if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
 },P=function () {
 function e(e,t) {
 for (var n=0; n < t.length; n++) {
 var o=t[n];
 o.enumerable=o.enumerable || !1,o.configurable=!0,"value" in o && (o.writable=!0),Object.defineProperty(e,o.key,o);
 }
 }

 return function (t,n,o) {
 return n && e(t.prototype,n),o && e(t,o),t;
 };
 }(),j=function e(t,n,o) {
 null === t && (t=Function.prototype);
 var i=Object.getOwnPropertyDescriptor(t,n);
 if (void 0 === i) {
 var r=Object.getPrototypeOf(t);
 return null === r ? void 0 : e(r,n,o);
 }
 if ("value" in i) return i.value;
 var s=i.get;
 if (void 0 !== s) return s.call(o);
 },D=function (e,t) {
 if ("function" != typeof t && null !== t) throw new TypeError("Super expression must either be null or a function,not " + typeof t);
 e.prototype=Object.create(t && t.prototype,{
 constructor: {
 value: e,enumerable: !1,writable: !0,configurable: !0
 }
 }),t && (Object.setPrototypeOf ? Object.setPrototypeOf(e,t) : e.__proto__=t);
 },V=function (e,t) {
 if (!e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
 return !t || "object" != typeof t && "function" != typeof t ? e : t;
 },I=function () {
 function e() {
 if (F(this,e),this.__state=R.apply(this,arguments),!1 === this.__state) throw new Error("Failed to interpret color arguments");
 this.__state.a=this.__state.a || 1;
 }

 return P(e,[{
 key: "toString",value: function () {
 return t(this);
 }
 },{
 key: "toHexString",value: function () {
 return t(this,!0);
 }
 },{
 key: "toOriginal",value: function () {
 return this.__state.conversion.write(this);
 }
 }]),e;
 }();
 I.recalculateRGB=function (e,t,n) {
 if ("HEX" === e.__state.space) e.__state[t]=N.component_from_hex(e.__state.hex,n); else {
 if ("HSV" !== e.__state.space) throw new Error("Corrupted color state");
 S.extend(e.__state,N.hsv_to_rgb(e.__state.h,e.__state.s,e.__state.v));
 }
 },I.recalculateHSV=function (e) {
 var t=N.rgb_to_hsv(e.r,e.g,e.b);
 S.extend(e.__state,{
 s: t.s,
 v: t.v
 }),S.isNaN(t.h) ? S.isUndefined(e.__state.h) && (e.__state.h=0) : e.__state.h=t.h;
 },I.COMPONENTS=["r","g","b","h","s","v","hex","a"],n(I.prototype,"r",2),n(I.prototype,"g",1),n(I.prototype,"b",0),o(I.prototype,"h"),o(I.prototype,"s"),o(I.prototype,"v"),Object.defineProperty(I.prototype,"a",{
 get: function () {
 return this.__state.a;
 },set: function (e) {
 this.__state.a=e;
 }
 }),Object.defineProperty(I.prototype,"hex",{
 get: function () {
 return "HEX" !== !this.__state.space && (this.__state.hex=N.rgb_to_hex(this.r,this.g,this.b)),this.__state.hex;
 },set: function (e) {
 this.__state.space="HEX",this.__state.hex=e;
 }
 });
 var z=function () {
 function e(t,n) {
 F(this,e),this.initialValue=t[n],this.domElement=document.createElement("div"),this.object=t,this.property=n,this.__onChange=void 0,this.__onFinishChange=void 0;
 }

 return P(e,[{
 key: "onChange",value: function (e) {
 return this.__onChange=e,this;
 }
 },{
 key: "onFinishChange",value: function (e) {
 return this.__onFinishChange=e,this;
 }
 },{
 key: "setValue",value: function (e) {
 return this.object[this.property]=e,this.__onChange && this.__onChange.call(this,e),this.updateDisplay(),this;
 }
 },{
 key: "getValue",value: function () {
 return this.object[this.property];
 }
 },{
 key: "updateDisplay",value: function () {
 return this;
 }
 },{
 key: "isModified",value: function () {
 return this.initialValue !== this.getValue();
 }
 }]),e;
 }(),M={
 HTMLEvents: ["change"],
 MouseEvents: ["click","mousemove","mousedown","mouseup","mouseover"],
 KeyboardEvents: ["keydown"]
 },G={};
 S.each(M,function (e,t) {
 S.each(e,function (e) {
 G[e]=t;
 });
 });
 var U=/(\d+(\.\d+)?)px/,X={
 makeSelectable: function (e,t) {
 void 0 !== e && void 0 !== e.style && (e.onselectstart=t ? function () {
 return !1;
 } : function () {
 },e.style.MozUserSelect=t ? "auto" : "none",e.style.KhtmlUserSelect=t ? "auto" : "none",e.unselectable=t ? "on" : "off");
 },makeFullscreen: function (e,t,n) {
 var o=n,i=t;
 S.isUndefined(i) && (i=!0),S.isUndefined(o) && (o=!0),e.style.position="absolute",i && (e.style.left=0,e.style.right=0),o && (e.style.top=0,e.style.bottom=0);
 },fakeEvent: function (e,t,n,o) {
 var i=n || {},r=G[t];
 if (!r) throw new Error("Event type " + t + " not supported.");
 var s=document.createEvent(r);
 switch (r) {
 case"MouseEvents":
 var a=i.x || i.clientX || 0,l=i.y || i.clientY || 0;
 s.initMouseEvent(t,i.bubbles || !1,i.cancelable || !0,window,i.clickCount || 1,0,0,a,l,!1,!1,!1,!1,0,null);
 break;
 case"KeyboardEvents":
 var d=s.initKeyboardEvent || s.initKeyEvent;
 S.defaults(i,{
 cancelable: !0,
 ctrlKey: !1,
 altKey: !1,
 shiftKey: !1,
 metaKey: !1,
 keyCode: void 0,
 charCode: void 0
 }),d(t,i.bubbles || !1,i.cancelable,window,i.ctrlKey,i.altKey,i.shiftKey,i.metaKey,i.keyCode,i.charCode);
 break;
 default:
 s.initEvent(t,i.bubbles || !1,i.cancelable || !0);
 }
 S.defaults(s,o),e.dispatchEvent(s);
 },bind: function (e,t,n,o) {
 var i=o || !1;
 return e.addEventListener ? e.addEventListener(t,n,i) : e.attachEvent && e.attachEvent("on" + t,n),X;
 },unbind: function (e,t,n,o) {
 var i=o || !1;
 return e.removeEventListener ? e.removeEventListener(t,n,i) : e.detachEvent && e.detachEvent("on" + t,n),X;
 },addClass: function (e,t) {
 if (void 0 === e.className) e.className=t; else if (e.className !== t) {
 var n=e.className.split(/ +/);
 -1 === n.indexOf(t) && (n.push(t),e.className=n.join(" ").replace(/^\s+/,"").replace(/\s+$/,""));
 }
 return X;
 },removeClass: function (e,t) {
 if (t) if (e.className === t) e.removeAttribute("class"); else {
 var n=e.className.split(/ +/),o=n.indexOf(t);
 -1 !== o && (n.splice(o,1),e.className=n.join(" "));
 } else e.className=void 0;
 return X;
 },hasClass: function (e,t) {
 return new RegExp("(?:^|\\s+)" + t + "(?:\\s+|$)").test(e.className) || !1;
 },getWidth: function (e) {
 var t=getComputedStyle(e);
 return i(t["border-left-width"]) + i(t["border-right-width"]) + i(t["padding-left"]) + i(t["padding-right"]) + i(t.width);
 },getHeight: function (e) {
 var t=getComputedStyle(e);
 return i(t["border-top-width"]) + i(t["border-bottom-width"]) + i(t["padding-top"]) + i(t["padding-bottom"]) + i(t.height);
 },getOffset: function (e) {
 var t=e,n={left: 0,top: 0};
 if (t.offsetParent) do {
 n.left += t.offsetLeft,n.top += t.offsetTop,t=t.offsetParent;
 } while (t);
 return n;
 },isActive: function (e) {
 return e === document.activeElement && (e.type || e.href);
 }
 },K=function (e) {
 function t(e,n) {
 F(this,t);
 var o=V(this,(t.__proto__ || Object.getPrototypeOf(t)).call(this,e,n)),i=o;
 return o.__prev=o.getValue(),o.__checkbox=document.createElement("input"),o.__checkbox.setAttribute("type","checkbox"),X.bind(o.__checkbox,"change",function () {
 i.setValue(!i.__prev);
 },!1),o.domElement.appendChild(o.__checkbox),o.updateDisplay(),o;
 }

 return D(t,z),P(t,[{
 key: "setValue",value: function (e) {
 var n=j(t.prototype.__proto__ || Object.getPrototypeOf(t.prototype),"setValue",this).call(this,e);
 return this.__onFinishChange && this.__onFinishChange.call(this,this.getValue()),this.__prev=this.getValue(),n;
 }
 },{
 key: "updateDisplay",value: function () {
 return !0 === this.getValue() ? (this.__checkbox.setAttribute("checked","checked"),this.__checkbox.checked=!0,this.__prev=!0) : (this.__checkbox.checked=!1,this.__prev=!1),j(t.prototype.__proto__ || Object.getPrototypeOf(t.prototype),"updateDisplay",this).call(this);
 }
 }]),t;
 }(),Y=function (e) {
 function t(e,n,o) {
 F(this,t);
 var i=V(this,(t.__proto__ || Object.getPrototypeOf(t)).call(this,e,n)),r=o,s=i;
 if (i.__select=document.createElement("select"),S.isArray(r)) {
 var a={};
 S.each(r,function (e) {
 a[e]=e;
 }),r=a;
 }
 return S.each(r,function (e,t) {
 var n=document.createElement("option");
 n.innerHTML=t,n.setAttribute("value",e),s.__select.appendChild(n);
 }),i.updateDisplay(),X.bind(i.__select,"change",function () {
 var e=this.options[this.selectedIndex].value;
 s.setValue(e);
 }),i.domElement.appendChild(i.__select),i;
 }

 return D(t,z),P(t,[{
 key: "setValue",value: function (e) {
 var n=j(t.prototype.__proto__ || Object.getPrototypeOf(t.prototype),"setValue",this).call(this,e);
 return this.__onFinishChange && this.__onFinishChange.call(this,this.getValue()),n;
 }
 },{
 key: "updateDisplay",value: function () {
 return X.isActive(this.__select) ? this : (this.__select.value=this.getValue(),j(t.prototype.__proto__ || Object.getPrototypeOf(t.prototype),"updateDisplay",this).call(this));
 }
 }]),t;
 }(),J=function (e) {
 function t(e,n) {
 function o() {
 r.setValue(r.__input.value);
 }

 F(this,t);
 var i=V(this,(t.__proto__ || Object.getPrototypeOf(t)).call(this,e,n)),r=i;
 return i.__input=document.createElement("input"),i.__input.setAttribute("type","text"),X.bind(i.__input,"keyup",o),X.bind(i.__input,"change",o),X.bind(i.__input,"blur",function () {
 r.__onFinishChange && r.__onFinishChange.call(r,r.getValue());
 }),X.bind(i.__input,"keydown",function (e) {
 13 === e.keyCode && this.blur();
 }),i.updateDisplay(),i.domElement.appendChild(i.__input),i;
 }

 return D(t,z),P(t,[{
 key: "updateDisplay",value: function () {
 return X.isActive(this.__input) || (this.__input.value=this.getValue()),j(t.prototype.__proto__ || Object.getPrototypeOf(t.prototype),"updateDisplay",this).call(this);
 }
 }]),t;
 }(),W=function (e) {
 function t(e,n,o) {
 F(this,t);
 var i=V(this,(t.__proto__ || Object.getPrototypeOf(t)).call(this,e,n)),s=o || {};
 return i.__min=s.min,i.__max=s.max,i.__step=s.step,S.isUndefined(i.__step) ? 0 === i.initialValue ? i.__impliedStep=1 : i.__impliedStep=Math.pow(10,Math.floor(Math.log(Math.abs(i.initialValue)) / Math.LN10)) / 10 : i.__impliedStep=i.__step,i.__precision=r(i.__impliedStep),i;
 }

 return D(t,z),P(t,[{
 key: "setValue",value: function (e) {
 var n=e;
 return void 0 !== this.__min && n < this.__min ? n=this.__min : void 0 !== this.__max && n > this.__max && (n=this.__max),void 0 !== this.__step && n % this.__step != 0 && (n=Math.round(n / this.__step) * this.__step),j(t.prototype.__proto__ || Object.getPrototypeOf(t.prototype),"setValue",this).call(this,n);
 }
 },{
 key: "min",value: function (e) {
 return this.__min=e,this;
 }
 },{
 key: "max",value: function (e) {
 return this.__max=e,this;
 }
 },{
 key: "step",value: function (e) {
 return this.__step=e,this.__impliedStep=e,this.__precision=r(e),this;
 }
 }]),t;
 }(),Q=function (e) {
 function t(e,n,o) {
 function i() {
 l.__onFinishChange && l.__onFinishChange.call(l,l.getValue());
 }

 function r(e) {
 var t=d - e.clientY;
 l.setValue(l.getValue() + t * l.__impliedStep),d=e.clientY;
 }

 function s() {
 X.unbind(window,"mousemove",r),X.unbind(window,"mouseup",s),i();
 }

 F(this,t);
 var a=V(this,(t.__proto__ || Object.getPrototypeOf(t)).call(this,e,n,o));
 a.__truncationSuspended=!1;
 var l=a,d=void 0;
 return a.__input=document.createElement("input"),a.__input.setAttribute("type","text"),X.bind(a.__input,"change",function () {
 var e=parseFloat(l.__input.value);
 S.isNaN(e) || l.setValue(e);
 }),X.bind(a.__input,"blur",function () {
 i();
 }),X.bind(a.__input,"mousedown",function (e) {
 X.bind(window,"mousemove",r),X.bind(window,"mouseup",s),d=e.clientY;
 }),X.bind(a.__input,"keydown",function (e) {
 13 === e.keyCode && (l.__truncationSuspended=!0,this.blur(),l.__truncationSuspended=!1,i());
 }),a.updateDisplay(),a.domElement.appendChild(a.__input),a;
 }

 return D(t,W),P(t,[{
 key: "updateDisplay",value: function () {
 return this.__input.value=this.__truncationSuspended ? this.getValue() : s(this.getValue(),this.__precision),j(t.prototype.__proto__ || Object.getPrototypeOf(t.prototype),"updateDisplay",this).call(this);
 }
 }]),t;
 }(),q=function (e) {
 function t(e,n,o,i,r) {
 function s(e) {
 e.preventDefault();
 var t=_.__background.getBoundingClientRect();
 return _.setValue(a(e.clientX,t.left,t.right,_.__min,_.__max)),!1;
 }

 function l() {
 X.unbind(window,"mousemove",s),X.unbind(window,"mouseup",l),_.__onFinishChange && _.__onFinishChange.call(_,_.getValue());
 }

 function d(e) {
 var t=e.touches[0].clientX,n=_.__background.getBoundingClientRect();
 _.setValue(a(t,n.left,n.right,_.__min,_.__max));
 }

 function c() {
 X.unbind(window,"touchmove",d),X.unbind(window,"touchend",c),_.__onFinishChange && _.__onFinishChange.call(_,_.getValue());
 }

 F(this,t);
 var u=V(this,(t.__proto__ || Object.getPrototypeOf(t)).call(this,e,n,{min: o,max: i,step: r})),
 _=u;
 return u.__background=document.createElement("div"),u.__foreground=document.createElement("div"),X.bind(u.__background,"mousedown",function (e) {
 document.activeElement.blur(),X.bind(window,"mousemove",s),X.bind(window,"mouseup",l),s(e);
 }),X.bind(u.__background,"touchstart",function (e) {
 1 === e.touches.length && (X.bind(window,"touchmove",d),X.bind(window,"touchend",c),d(e));
 }),X.addClass(u.__background,"slider"),X.addClass(u.__foreground,"slider-fg"),u.updateDisplay(),u.__background.appendChild(u.__foreground),u.domElement.appendChild(u.__background),u;
 }

 return D(t,W),P(t,[{
 key: "updateDisplay",value: function () {
 var e=(this.getValue() - this.__min) / (this.__max - this.__min);
 return this.__foreground.style.width=100 * e + "%",j(t.prototype.__proto__ || Object.getPrototypeOf(t.prototype),"updateDisplay",this).call(this);
 }
 }]),t;
 }(),Z=function (e) {
 function t(e,n,o) {
 F(this,t);
 var i=V(this,(t.__proto__ || Object.getPrototypeOf(t)).call(this,e,n)),r=i;
 return i.__button=document.createElement("div"),i.__button.innerHTML=void 0 === o ? "Fire" : o,X.bind(i.__button,"click",function (e) {
 return e.preventDefault(),r.fire(),!1;
 }),X.addClass(i.__button,"button"),i.domElement.appendChild(i.__button),i;
 }

 return D(t,z),P(t,[{
 key: "fire",value: function () {
 this.__onChange && this.__onChange.call(this),this.getValue().call(this.object),this.__onFinishChange && this.__onFinishChange.call(this,this.getValue());
 }
 }]),t;
 }(),$=function (e) {
 function t(e,n) {
 function o(e) {
 u(e),X.bind(window,"mousemove",u),X.bind(window,"touchmove",u),X.bind(window,"mouseup",r),X.bind(window,"touchend",r);
 }

 function i(e) {
 _(e),X.bind(window,"mousemove",_),X.bind(window,"touchmove",_),X.bind(window,"mouseup",s),X.bind(window,"touchend",s);
 }

 function r() {
 X.unbind(window,"mousemove",u),X.unbind(window,"touchmove",u),X.unbind(window,"mouseup",r),X.unbind(window,"touchend",r),c();
 }

 function s() {
 X.unbind(window,"mousemove",_),X.unbind(window,"touchmove",_),X.unbind(window,"mouseup",s),X.unbind(window,"touchend",s),c();
 }

 function a() {
 var e=R(this.value);
 !1 !== e ? (p.__color.__state=e,p.setValue(p.__color.toOriginal())) : this.value=p.__color.toString();
 }

 function c() {
 p.__onFinishChange && p.__onFinishChange.call(p,p.__color.toOriginal());
 }

 function u(e) {
 -1 === e.type.indexOf("touch") && e.preventDefault();
 var t=p.__saturation_field.getBoundingClientRect(),n=e.touches && e.touches[0] || e,o=n.clientX,
 i=n.clientY,r=(o - t.left) / (t.right - t.left),s=1 - (i - t.top) / (t.bottom - t.top);
 return s > 1 ? s=1 : s < 0 && (s=0),r > 1 ? r=1 : r < 0 && (r=0),p.__color.v=s,p.__color.s=r,p.setValue(p.__color.toOriginal()),!1;
 }

 function _(e) {
 -1 === e.type.indexOf("touch") && e.preventDefault();
 var t=p.__hue_field.getBoundingClientRect(),
 n=1 - ((e.touches && e.touches[0] || e).clientY - t.top) / (t.bottom - t.top);
 return n > 1 ? n=1 : n < 0 && (n=0),p.__color.h=360 * n,p.setValue(p.__color.toOriginal()),!1;
 }

 F(this,t);
 var h=V(this,(t.__proto__ || Object.getPrototypeOf(t)).call(this,e,n));
 h.__color=new I(h.getValue()),h.__temp=new I(0);
 var p=h;
 h.domElement=document.createElement("div"),X.makeSelectable(h.domElement,!1),h.__selector=document.createElement("div"),h.__selector.className="selector",h.__saturation_field=document.createElement("div"),h.__saturation_field.className="saturation-field",h.__field_knob=document.createElement("div"),h.__field_knob.className="field-knob",h.__field_knob_border="2px solid ",h.__hue_knob=document.createElement("div"),h.__hue_knob.className="hue-knob",h.__hue_field=document.createElement("div"),h.__hue_field.className="hue-field",h.__input=document.createElement("input"),h.__input.type="text",h.__input_textShadow="0 1px 1px ",X.bind(h.__input,"keydown",function (e) {
 13 === e.keyCode && a.call(this);
 }),X.bind(h.__input,"blur",a),X.bind(h.__selector,"mousedown",function () {
 X.addClass(this,"drag").bind(window,"mouseup",function () {
 X.removeClass(p.__selector,"drag");
 });
 }),X.bind(h.__selector,"touchstart",function () {
 X.addClass(this,"drag").bind(window,"touchend",function () {
 X.removeClass(p.__selector,"drag");
 });
 });
 var f=document.createElement("div");
 return S.extend(h.__selector.style,{
 width: "122px",
 height: "102px",
 padding: "3px",
 backgroundColor: "#222222",
 boxShadow: "0px 1px 3px rgba(0,0,0,0.3)"
 }),S.extend(h.__field_knob.style,{
 position: "absolute",
 width: "12px",
 height: "12px",
 border: h.__field_knob_border + (h.__color.v < .5 ? "#FFFFFF" : "#000000"),
 boxShadow: "0px 1px 3px rgba(0,0,0,0.5)",
 borderRadius: "12px",
 zIndex: 1
 }),S.extend(h.__hue_knob.style,{
 position: "absolute",width: "15px",height: "2px",borderRight: "4px solid #fff",zIndex: 1
 }),S.extend(h.__saturation_field.style,{
 width: "100px",
 height: "100px",
 border: "1px solid #555",
 marginRight: "3px",
 display: "inline-block",
 cursor: "pointer"
 }),S.extend(f.style,{
 width: "100%",height: "100%",background: "none"
 }),l(f,"top","rgba(0,0,0,0)","#000000"),S.extend(h.__hue_field.style,{
 width: "15px",
 height: "100px",
 border: "1px solid #555",
 cursor: "ns-resize",
 position: "absolute",
 top: "3px",
 right: "3px"
 }),d(h.__hue_field),S.extend(h.__input.style,{
 outline: "none",
 textAlign: "center",
 color: "#FFFFFF",
 border: 0,
 fontWeight: "bold",
 textShadow: h.__input_textShadow + "rgba(0,0,0,0.7)"
 }),X.bind(h.__saturation_field,"mousedown",o),X.bind(h.__saturation_field,"touchstart",o),X.bind(h.__field_knob,"mousedown",o),X.bind(h.__field_knob,"touchstart",o),X.bind(h.__hue_field,"mousedown",i),X.bind(h.__hue_field,"touchstart",i),h.__saturation_field.appendChild(f),h.__selector.appendChild(h.__field_knob),h.__selector.appendChild(h.__saturation_field),h.__selector.appendChild(h.__hue_field),h.__hue_field.appendChild(h.__hue_knob),h.domElement.appendChild(h.__input),h.domElement.appendChild(h.__selector),h.updateDisplay(),h;
 }

 return D(t,z),P(t,[{
 key: "updateDisplay",value: function () {
 var e=R(this.getValue());
 if (!1 !== e) {
 var t=!1;
 S.each(I.COMPONENTS,function (n) {
 if (!S.isUndefined(e[n]) && !S.isUndefined(this.__color.__state[n]) && e[n] !== this.__color.__state[n]) return t=!0,{};
 },this),t && S.extend(this.__color.__state,e);
 }
 S.extend(this.__temp.__state,this.__color.__state),this.__temp.a=1;
 var n=this.__color.v < .5 || this.__color.s > .5 ? 255 : 0,o=255 - n;
 S.extend(this.__field_knob.style,{
 marginLeft: 100 * this.__color.s - 7 + "px",
 marginTop: 100 * (1 - this.__color.v) - 7 + "px",
 backgroundColor: this.__temp.toHexString(),
 border: this.__field_knob_border + "rgb(" + n + "," + n + "," + n + ")"
 }),this.__hue_knob.style.marginTop=100 * (1 - this.__color.h / 360) + "px",this.__temp.s=1,this.__temp.v=1,l(this.__saturation_field,"left","#FFFFFF",this.__temp.toHexString()),this.__input.value=this.__color.toString(),S.extend(this.__input.style,{
 backgroundColor: this.__color.toHexString(),
 color: "rgb(" + n + "," + n + "," + n + ")",
 textShadow: this.__input_textShadow + "rgba(" + o + "," + o + "," + o + ",.7)"
 });
 }
 }]),t;
 }(),ee=["-moz-","-o-","-webkit-","-ms-",""],te={
 load: function (e,t) {
 var n=t || document,o=n.createElement("link");
 o.type="text/css",o.rel="stylesheet",o.href=e,n.getElementsByTagName("head")[0].appendChild(o);
 },inject: function (e,t) {
 var n=t || document,o=document.createElement("style");
 o.type="text/css",o.innerHTML=e;
 var i=n.getElementsByTagName("head")[0];
 try {
 i.appendChild(o);
 } catch (e) {
 }
 }
 },ne=function (e,t) {
 var n=e[t];
 return S.isArray(arguments[2]) || S.isObject(arguments[2]) ? new Y(e,t,arguments[2]) : S.isNumber(n) ? S.isNumber(arguments[2]) && S.isNumber(arguments[3]) ? S.isNumber(arguments[4]) ? new q(e,t,arguments[2],arguments[3],arguments[4]) : new q(e,t,arguments[2],arguments[3]) : S.isNumber(arguments[4]) ? new Q(e,t,{
 min: arguments[2],max: arguments[3],step: arguments[4]
 }) : new Q(e,t,{
 min: arguments[2],max: arguments[3]
 }) : S.isString(n) ? new J(e,t) : S.isFunction(n) ? new Z(e,t,"") : S.isBoolean(n) ? new K(e,t) : null;
 },
 oe=window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function (e) {
 setTimeout(e,1e3 / 60);
 },ie=function () {
 function e() {
 F(this,e),this.backgroundElement=document.createElement("div"),S.extend(this.backgroundElement.style,{
 backgroundColor: "rgba(0,0,0,0.8)",
 top: 0,
 left: 0,
 display: "none",
 zIndex: "1000",
 opacity: 0,
 WebkitTransition: "opacity 0.2s linear",
 transition: "opacity 0.2s linear"
 }),X.makeFullscreen(this.backgroundElement),this.backgroundElement.style.position="fixed",this.domElement=document.createElement("div"),S.extend(this.domElement.style,{
 position: "fixed",
 display: "none",
 zIndex: "1001",
 opacity: 0,
 WebkitTransition: "-webkit-transform 0.2s ease-out,opacity 0.2s linear",
 transition: "transform 0.2s ease-out,opacity 0.2s linear"
 }),document.body.appendChild(this.backgroundElement),document.body.appendChild(this.domElement);
 var t=this;
 X.bind(this.backgroundElement,"click",function () {
 t.hide();
 });
 }

 return P(e,[{
 key: "show",value: function () {
 var e=this;
 this.backgroundElement.style.display="block",this.domElement.style.display="block",this.domElement.style.opacity=0,this.domElement.style.webkitTransform="scale(1.1)",this.layout(),S.defer(function () {
 e.backgroundElement.style.opacity=1,e.domElement.style.opacity=1,e.domElement.style.webkitTransform="scale(1)";
 });
 }
 },{
 key: "hide",value: function () {
 var e=this,t=function t() {
 e.domElement.style.display="none",e.backgroundElement.style.display="none",X.unbind(e.domElement,"webkitTransitionEnd",t),X.unbind(e.domElement,"transitionend",t),X.unbind(e.domElement,"oTransitionEnd",t);
 };
 X.bind(this.domElement,"webkitTransitionEnd",t),X.bind(this.domElement,"transitionend",t),X.bind(this.domElement,"oTransitionEnd",t),this.backgroundElement.style.opacity=0,this.domElement.style.opacity=0,this.domElement.style.webkitTransform="scale(1.1)";
 }
 },{
 key: "layout",value: function () {
 this.domElement.style.left=window.innerWidth / 2 - X.getWidth(this.domElement) / 2 + "px",this.domElement.style.top=window.innerHeight / 2 - X.getHeight(this.domElement) / 2 + "px";
 }
 }]),e;
 }(),re=function (e) {
 if (e && "undefined" != typeof window) {
 var t=document.createElement("style");
 return t.setAttribute("type","text/css"),t.innerHTML=e,document.head.appendChild(t),e;
 }
 }(".dg ul{list-style:none;margin:0;padding:0;width:100%;clear:both}.dg.ac{position:fixed;top:0;left:0;right:0;height:0;z-index:0}.dg:not(.ac) .main{overflow:hidden}.dg.main{-webkit-transition:opacity .1s linear;-o-transition:opacity .1s linear;-moz-transition:opacity .1s linear;transition:opacity .1s linear}.dg.main.taller-than-window{overflow-y:auto}.dg.main.taller-than-window .close-button{opacity:1;margin-top:-1px;border-top:1px solid #2c2c2c}.dg.main ul.closed .close-button{opacity:1 !important}.dg.main:hover .close-button,.dg.main .close-button.drag{opacity:1}.dg.main .close-button{-webkit-transition:opacity .1s linear;-o-transition:opacity .1s linear;-moz-transition:opacity .1s linear;transition:opacity .1s linear;border:0;line-height:19px;height:20px;cursor:pointer;text-align:center;background-color:#000}.dg.main .close-button.close-top{position:relative}.dg.main .close-button.close-bottom{position:absolute}.dg.main .close-button:hover{background-color:#111}.dg.a{float:right;margin-right:15px;overflow-y:visible}.dg.a.has-save>ul.close-top{margin-top:0}.dg.a.has-save>ul.close-bottom{margin-top:27px}.dg.a.has-save>ul.closed{margin-top:0}.dg.a .save-row{top:0;z-index:1002}.dg.a .save-row.close-top{position:relative}.dg.a .save-row.close-bottom{position:fixed}.dg li{-webkit-transition:height .1s ease-out;-o-transition:height .1s ease-out;-moz-transition:height .1s ease-out;transition:height .1s ease-out;-webkit-transition:overflow .1s linear;-o-transition:overflow .1s linear;-moz-transition:overflow .1s linear;transition:overflow .1s linear}.dg li:not(.folder){cursor:auto;height:27px;line-height:27px;padding:0 4px 0 5px}.dg li.folder{padding:0;border-left:4px solid rgba(0,0,0,0)}.dg li.title{cursor:pointer;margin-left:-4px}.dg .closed li:not(.title),.dg .closed ul li,.dg .closed ul li>*{height:0;overflow:hidden;border:0}.dg .cr{clear:both;padding-left:3px;height:27px;overflow:hidden}.dg .property-name{cursor:default;float:left;clear:left;width:40%;overflow:hidden;text-overflow:ellipsis}.dg .c{float:left;width:60%;position:relative}.dg .c input[type=text]{border:0;margin-top:4px;padding:3px;width:100%;float:right}.dg .has-slider input[type=text]{width:30%;margin-left:0}.dg .slider{float:left;width:66%;margin-left:-5px;margin-right:0;height:19px;margin-top:4px}.dg .slider-fg{height:100%}.dg .c input[type=checkbox]{margin-top:7px}.dg .c select{margin-top:5px}.dg .cr.function,.dg .cr.function .property-name,.dg .cr.function *,.dg .cr.boolean,.dg .cr.boolean *{cursor:pointer}.dg .cr.color{overflow:visible}.dg .selector{display:none;position:absolute;margin-left:-9px;margin-top:23px;z-index:10}.dg .c:hover .selector,.dg .selector.drag{display:block}.dg li.save-row{padding:0}.dg li.save-row .button{display:inline-block;padding:0px 6px}.dg.dialogue{background-color:#222;width:460px;padding:15px;font-size:13px;line-height:15px}#dg-new-constructor{padding:10px;color:#222;font-family:Monaco,monospace;font-size:10px;border:0;resize:none;box-shadow:inset 1px 1px 1px #888;word-wrap:break-word;margin:12px 0;display:block;width:440px;overflow-y:scroll;height:100px;position:relative}#dg-local-explain{display:none;font-size:11px;line-height:17px;border-radius:3px;background-color:#333;padding:8px;margin-top:10px}#dg-local-explain code{font-size:10px}#dat-gui-save-locally{display:none}.dg{color:#eee;font:11px 'Lucida Grande',sans-serif;text-shadow:0 -1px 0 #111}.dg.main::-webkit-scrollbar{width:5px;background:#1a1a1a}.dg.main::-webkit-scrollbar-corner{height:0;display:none}.dg.main::-webkit-scrollbar-thumb{border-radius:5px;background:#676767}.dg li:not(.folder){background:#1a1a1a;border-bottom:1px solid #2c2c2c}.dg li.save-row{line-height:25px;background:#dad5cb;border:0}.dg li.save-row select{margin-left:5px;width:108px}.dg li.save-row .button{margin-left:5px;margin-top:1px;border-radius:2px;font-size:9px;line-height:7px;padding:4px 4px 5px 4px;background:#c5bdad;color:#fff;text-shadow:0 1px 0 #b0a58f;box-shadow:0 -1px 0 #b0a58f;cursor:pointer}.dg li.save-row .button.gears{background:#c5bdad url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAsAAAANCAYAAAB/9ZQ7AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAQJJREFUeNpiYKAU/P//PwGIC/ApCABiBSAW+I8AClAcgKxQ4T9hoMAEUrxx2QSGN6+egDX+/vWT4e7N82AMYoPAx/evwWoYoSYbACX2s7KxCxzcsezDh3evFoDEBYTEEqycggWAzA9AuUSQQgeYPa9fPv6/YWm/Acx5IPb7ty/fw+QZblw67vDs8R0YHyQhgObx+yAJkBqmG5dPPDh1aPOGR/eugW0G4vlIoTIfyFcA+QekhhHJhPdQxbiAIguMBTQZrPD7108M6roWYDFQiIAAv6Aow/1bFwXgis+f2LUAynwoIaNcz8XNx3Dl7MEJUDGQpx9gtQ8YCueB+D26OECAAQDadt7e46D42QAAAABJRU5ErkJggg==) 2px 1px no-repeat;height:7px;width:8px}.dg li.save-row .button:hover{background-color:#bab19e;box-shadow:0 -1px 0 #b0a58f}.dg li.folder{border-bottom:0}.dg li.title{padding-left:16px;background:#000 url(data:image/gif;base64,R0lGODlhBQAFAJEAAP////Pz8////////yH5BAEAAAIALAAAAAAFAAUAAAIIlI+hKgFxoCgAOw==) 6px 10px no-repeat;cursor:pointer;border-bottom:1px solid rgba(255,255,255,0.2)}.dg .closed li.title{background-image:url(data:image/gif;base64,R0lGODlhBQAFAJEAAP////Pz8////////yH5BAEAAAIALAAAAAAFAAUAAAIIlGIWqMCbWAEAOw==)}.dg .cr.boolean{border-left:3px solid #806787}.dg .cr.color{border-left:3px solid}.dg .cr.function{border-left:3px solid #e61d5f}.dg .cr.number{border-left:3px solid #2FA1D6}.dg .cr.number input[type=text]{color:#2FA1D6}.dg .cr.string{border-left:3px solid #1ed36f}.dg .cr.string input[type=text]{color:#1ed36f}.dg .cr.function:hover,.dg .cr.boolean:hover{background:#111}.dg .c input[type=text]{background:#303030;outline:none}.dg .c input[type=text]:hover{background:#3c3c3c}.dg .c input[type=text]:focus{background:#494949;color:#fff}.dg .c .slider{background:#303030;cursor:ew-resize}.dg .c .slider-fg{background:#2FA1D6;max-width:100%}.dg .c .slider:hover{background:#3c3c3c}.dg .c .slider:hover .slider-fg{background:#44abda}\n");
 te.inject(re);
 var se="Default",ae=function () {
 try {
 return !!window.localStorage;
 } catch (e) {
 return !1;
 }
 }(),le=void 0,de=!0,ce=void 0,ue=!1,_e=[],he=function e(t) {
 var n=this,o=t || {};
 this.domElement=document.createElement("div"),this.__ul=document.createElement("ul"),this.domElement.appendChild(this.__ul),X.addClass(this.domElement,"dg"),this.__folders={},this.__controllers=[],this.__rememberedObjects=[],this.__rememberedObjectIndecesToControllers=[],this.__listening=[],o=S.defaults(o,{
 closeOnTop: !1,autoPlace: !0,width: e.DEFAULT_WIDTH
 }),o=S.defaults(o,{
 resizable: o.autoPlace,hideable: o.autoPlace
 }),S.isUndefined(o.load) ? o.load={preset: se} : o.preset && (o.load.preset=o.preset),S.isUndefined(o.parent) && o.hideable && _e.push(this),o.resizable=S.isUndefined(o.parent) && o.resizable,o.autoPlace && S.isUndefined(o.scrollable) && (o.scrollable=!0);
 var i=ae && "true" === localStorage.getItem(m(this,"isLocal")),r=void 0,s=void 0;
 if (Object.defineProperties(this,{
 parent: {
 get: function () {
 return o.parent;
 }
 },scrollable: {
 get: function () {
 return o.scrollable;
 }
 },autoPlace: {
 get: function () {
 return o.autoPlace;
 }
 },closeOnTop: {
 get: function () {
 return o.closeOnTop;
 }
 },preset: {
 get: function () {
 return n.parent ? n.getRoot().preset : o.load.preset;
 },set: function (e) {
 n.parent ? n.getRoot().preset=e : o.load.preset=e,E(this),n.revert();
 }
 },width: {
 get: function () {
 return o.width;
 },set: function (e) {
 o.width=e,w(n,e);
 }
 },name: {
 get: function () {
 return o.name;
 },set: function (e) {
 o.name=e,s && (s.innerHTML=o.name);
 }
 },closed: {
 get: function () {
 return o.closed;
 },set: function (t) {
 o.closed=t,o.closed ? X.addClass(n.__ul,e.CLASS_CLOSED) : X.removeClass(n.__ul,e.CLASS_CLOSED),this.onResize(),n.__closeButton && (n.__closeButton.innerHTML=t ? e.TEXT_OPEN : e.TEXT_CLOSED);
 }
 },load: {
 get: function () {
 return o.load;
 }
 },useLocalStorage: {
 get: function () {
 return i;
 },set: function (e) {
 ae && (i=e,e ? X.bind(window,"unload",r) : X.unbind(window,"unload",r),localStorage.setItem(m(n,"isLocal"),e));
 }
 }
 }),S.isUndefined(o.parent)) {
 if (o.closed=!1,X.addClass(this.domElement,e.CLASS_MAIN),X.makeSelectable(this.domElement,!1),ae && i) {
 n.useLocalStorage=!0;
 var a=localStorage.getItem(m(this,"gui"));
 a && (o.load=JSON.parse(a));
 }
 this.__closeButton=document.createElement("div"),this.__closeButton.innerHTML=e.TEXT_CLOSED,X.addClass(this.__closeButton,e.CLASS_CLOSE_BUTTON),o.closeOnTop ? (X.addClass(this.__closeButton,e.CLASS_CLOSE_TOP),this.domElement.insertBefore(this.__closeButton,this.domElement.childNodes[0])) : (X.addClass(this.__closeButton,e.CLASS_CLOSE_BOTTOM),this.domElement.appendChild(this.__closeButton)),X.bind(this.__closeButton,"click",function () {
 n.closed=!n.closed;
 });
 } else {
 void 0 === o.closed && (o.closed=!0);
 var l=document.createTextNode(o.name);
 X.addClass(l,"controller-name"),s=c(n,l);
 X.addClass(this.__ul,e.CLASS_CLOSED),X.addClass(s,"title"),X.bind(s,"click",function (e) {
 return e.preventDefault(),n.closed=!n.closed,!1;
 }),o.closed || (this.closed=!1);
 }
 o.autoPlace && (S.isUndefined(o.parent) && (de && (ce=document.createElement("div"),X.addClass(ce,"dg"),X.addClass(ce,e.CLASS_AUTO_PLACE_CONTAINER),document.body.appendChild(ce),de=!1),ce.appendChild(this.domElement),X.addClass(this.domElement,e.CLASS_AUTO_PLACE)),this.parent || w(n,o.width)),this.__resizeHandler=function () {
 n.onResizeDebounced();
 },X.bind(window,"resize",this.__resizeHandler),X.bind(this.__ul,"webkitTransitionEnd",this.__resizeHandler),X.bind(this.__ul,"transitionend",this.__resizeHandler),X.bind(this.__ul,"oTransitionEnd",this.__resizeHandler),this.onResize(),o.resizable && y(this),r=function () {
 ae && "true" === localStorage.getItem(m(n,"isLocal")) && localStorage.setItem(m(n,"gui"),JSON.stringify(n.getSaveObject()));
 },this.saveToLocalStorageIfPossible=r,o.parent || function () {
 var e=n.getRoot();
 e.width += 1,S.defer(function () {
 e.width -= 1;
 });
 }();
 };
 he.toggleHide=function () {
 ue=!ue,S.each(_e,function (e) {
 e.domElement.style.display=ue ? "none" : "";
 });
 },he.CLASS_AUTO_PLACE="a",he.CLASS_AUTO_PLACE_CONTAINER="ac",he.CLASS_MAIN="main",he.CLASS_CONTROLLER_ROW="cr",he.CLASS_TOO_TALL="taller-than-window",he.CLASS_CLOSED="closed",he.CLASS_CLOSE_BUTTON="close-button",he.CLASS_CLOSE_TOP="close-top",he.CLASS_CLOSE_BOTTOM="close-bottom",he.CLASS_DRAG="drag",he.DEFAULT_WIDTH=245,he.TEXT_CLOSED="Close Controls",he.TEXT_OPEN="Open Controls",he._keydownHandler=function (e) {
 "text" === document.activeElement.type || 72 !== e.which && 72 !== e.keyCode || he.toggleHide();
 },X.bind(window,"keydown",he._keydownHandler,!1),S.extend(he.prototype,{
 add: function (e,t) {
 return f(this,e,t,{factoryArgs: Array.prototype.slice.call(arguments,2)});
 },addColor: function (e,t) {
 return f(this,e,t,{color: !0});
 },remove: function (e) {
 this.__ul.removeChild(e.__li),this.__controllers.splice(this.__controllers.indexOf(e),1);
 var t=this;
 S.defer(function () {
 t.onResize();
 });
 },destroy: function () {
 if (this.parent) throw new Error("Only the root GUI should be removed with .destroy(). For subfolders,use gui.removeFolder(folder) instead.");
 this.autoPlace && ce.removeChild(this.domElement);
 var e=this;
 S.each(this.__folders,function (t) {
 e.removeFolder(t);
 }),X.unbind(window,"keydown",he._keydownHandler,!1),u(this);
 },addFolder: function (e) {
 if (void 0 !== this.__folders[e]) throw new Error('You already have a folder in this GUI by the name "' + e + '"');
 var t={name: e,parent: this};
 t.autoPlace=this.autoPlace,this.load && this.load.folders && this.load.folders[e] && (t.closed=this.load.folders[e].closed,t.load=this.load.folders[e]);
 var n=new he(t);
 this.__folders[e]=n;
 var o=c(this,n.domElement);
 return X.addClass(o,"folder"),n;
 },removeFolder: function (e) {
 this.__ul.removeChild(e.domElement.parentElement),delete this.__folders[e.name],this.load && this.load.folders && this.load.folders[e.name] && delete this.load.folders[e.name],u(e);
 var t=this;
 S.each(e.__folders,function (t) {
 e.removeFolder(t);
 }),S.defer(function () {
 t.onResize();
 });
 },open: function () {
 this.closed=!1;
 },close: function () {
 this.closed=!0;
 },onResize: function () {
 var e=this.getRoot();
 if (e.scrollable) {
 var t=X.getOffset(e.__ul).top,n=0;
 S.each(e.__ul.childNodes,function (t) {
 e.autoPlace && t === e.__save_row || (n += X.getHeight(t));
 }),window.innerHeight - t - 20 < n ? (X.addClass(e.domElement,he.CLASS_TOO_TALL),e.__ul.style.height=window.innerHeight - t - 20 + "px") : (X.removeClass(e.domElement,he.CLASS_TOO_TALL),e.__ul.style.height="auto");
 }
 e.__resize_handle && S.defer(function () {
 e.__resize_handle.style.height=e.__ul.offsetHeight + "px";
 }),e.__closeButton && (e.__closeButton.style.width=e.width + "px");
 },onResizeDebounced: S.debounce(function () {
 this.onResize();
 },50),remember: function () {
 if (S.isUndefined(le) && ((le=new ie).domElement.innerHTML='<div id="dg-save" class="dg dialogue">\n\n Here\'s the new load parameter for your <code>GUI</code>\'s constructor:\n\n <textarea id="dg-new-constructor"></textarea>\n\n <div id="dg-save-locally">\n\n <input id="dg-local-storage" type="checkbox"/> Automatically save\n values to <code>localStorage</code> on exit.\n\n <div id="dg-local-explain">The values saved to <code>localStorage</code> will\n override those passed to <code>dat.GUI</code>\'s constructor. This makes it\n easier to work incrementally,but <code>localStorage</code> is fragile,\n and your friends may not see the same values you do.\n\n </div>\n\n </div>\n\n</div>'),this.parent) throw new Error("You can only call remember on a top level GUI.");
 var e=this;
 S.each(Array.prototype.slice.call(arguments),function (t) {
 0 === e.__rememberedObjects.length && v(e),-1 === e.__rememberedObjects.indexOf(t) && e.__rememberedObjects.push(t);
 }),this.autoPlace && w(this,this.width);
 },getRoot: function () {
 for (var e=this; e.parent;) e=e.parent;
 return e;
 },getSaveObject: function () {
 var e=this.load;
 return e.closed=this.closed,this.__rememberedObjects.length > 0 && (e.preset=this.preset,e.remembered || (e.remembered={}),e.remembered[this.preset]=x(this)),e.folders={},S.each(this.__folders,function (t,n) {
 e.folders[n]=t.getSaveObject();
 }),e;
 },save: function () {
 this.load.remembered || (this.load.remembered={}),this.load.remembered[this.preset]=x(this),_(this,!1),this.saveToLocalStorageIfPossible();
 },saveAs: function (e) {
 this.load.remembered || (this.load.remembered={},this.load.remembered[se]=x(this,!0)),this.load.remembered[e]=x(this),this.preset=e,g(this,e,!0),this.saveToLocalStorageIfPossible();
 },revert: function (e) {
 S.each(this.__controllers,function (t) {
 this.getRoot().load.remembered ? p(e || this.getRoot(),t) : t.setValue(t.initialValue),t.__onFinishChange && t.__onFinishChange.call(t,t.getValue());
 },this),S.each(this.__folders,function (e) {
 e.revert(e);
 }),e || _(this.getRoot(),!1);
 },listen: function (e) {
 var t=0 === this.__listening.length;
 this.__listening.push(e),t && C(this.__listening);
 },updateDisplay: function () {
 S.each(this.__controllers,function (e) {
 e.updateDisplay();
 }),S.each(this.__folders,function (e) {
 e.updateDisplay();
 });
 }
 });
 var pe={Color: I,math: N,interpret: R},fe={
 Controller: z,
 BooleanController: K,
 OptionController: Y,
 StringController: J,
 NumberController: W,
 NumberControllerBox: Q,
 NumberControllerSlider: q,
 FunctionController: Z,
 ColorController: $
 },me={dom: X},ge={GUI: he},be=he,ve={color: pe,controllers: fe,dom: me,gui: ge,GUI: be};
 e.color=pe,e.controllers=fe,e.dom=me,e.gui=ge,e.GUI=be,e.default=ve,Object.defineProperty(e,"__esModule",{value: !0});
});

'use strict';
const promoPopup=document.getElementsByClassName('promo')[0];
const promoPopupClose=document.getElementsByClassName('promo-close')[0];
if(isMobile()){
 setTimeout(() => {
 promoPopup.style.display='table';
 },20000);
}
var appleLink=document.getElementById('apple_link');
var googleLink=document.getElementById('google_link');

// const canvas=document.getElementsByTagName('canvas')[0];
var canvas=document.getElementById('acanvas');

resizeCanvas();
let config={
 SIM_RESOLUTION:256,DYE_RESOLUTION:1024,CAPTURE_RESOLUTION:512,DENSITY_DISSIPATION:1,VELOCITY_DISSIPATION:0.2,PRESSURE:0.8,PRESSURE_ITERATIONS:20,CURL:30,SPLAT_RADIUS:0.25,SPLAT_FORCE:6000,SHADING:true,COLORFUL:false,COLOR_UPDATE_SPEED:10,PAUSED:false,BACK_COLOR:{r:0,g:0,b:0},TRANSPARENT:true,BLOOM:false,BLOOM_ITERATIONS:8,BLOOM_RESOLUTION:512,BLOOM_INTENSITY:0.3,BLOOM_THRESHOLD:0.8,BLOOM_SOFT_KNEE:0.7,SUNRAYS:false,SUNRAYS_RESOLUTION:196,SUNRAYS_WEIGHT:1.0
};
function pointerPrototype(){
 this.id= -1;
 this.texcoordX=0;
 this.texcoordY=0;
 this.prevTexcoordX=0;
 this.prevTexcoordY=0;
 this.deltaX=0;
 this.deltaY=0;
 this.down=false;
 this.moved=false;
 this.color=[30,0,300];
}
let pointers=[];
let splatStack=[];
pointers.push(new pointerPrototype());
const {gl,ext}=getWebGLContext(canvas);
if(isMobile()){
 config.DYE_RESOLUTION=512;
}
if(!ext.supportLinearFiltering){
 config.DYE_RESOLUTION=512;
 config.SHADING=false;
 config.BLOOM=false;
 config.SUNRAYS=false;
}
startGUI();
function getWebGLContext(canvas){
 // colorSpace:'display-p3'
const params={colorSpace:'srgb',alpha:true,imageSmoothingEnabled:true,premultipliedAlpha:false,depth:true,stencil:true,antialias:true,preserveDrawingBuffer:false,desynchronized:false,lowLatency:true,powerPreference:'high-performance'};
let gl=canvas.getContext('webgl2',{colorSpace:'srgb',imageSmoothingEnabled:true,preserveDrawingBuffer:false,antialias:true,stencil:true,premultipliedAlpha:false,alpha:true,depth:true,desynchronized:false,lowLatency:true,powerPreference:'high-performance'});
 const isWebGL2=!!gl;
 if(!isWebGL2) gl=canvas.getContext('webgl',params) || canvas.getContext('experimental-webgl',params);
 let halfFloat;
 let supportLinearFiltering;
 if(isWebGL2){
 gl.getExtension('EXT_color_buffer_float');
 supportLinearFiltering=gl.getExtension('OES_texture_float_linear');
 }else{
 halfFloat=gl.getExtension('OES_texture_half_float');
 supportLinearFiltering=gl.getExtension('OES_texture_half_float_linear');
 }
 gl.clearColor(Math.random(),Math.random(),Math.random(),1.0);
 const halfFloatTexType=isWebGL2?gl.FLOAT:halfFloat.FLOAT_OES;
 let formatRGBA;
 let formatRG;
 let formatR;
 if(isWebGL2){
 formatRGBA=getSupportedFormat(gl,gl.RGBA32F,gl.RGBA,halfFloatTexType);
 formatRG=getSupportedFormat(gl,gl.RG32F,gl.RG,halfFloatTexType);
 formatR=getSupportedFormat(gl,gl.R32F,gl.RED,halfFloatTexType);
 }else{
 formatRGBA=getSupportedFormat(gl,gl.RGBA,gl.RGBA,halfFloatTexType);
 formatRG=getSupportedFormat(gl,gl.RGBA,gl.RGBA,halfFloatTexType);
 formatR=getSupportedFormat(gl,gl.RGBA,gl.RGBA,halfFloatTexType);
 }
 return {
 gl,ext:{
 formatRGBA,formatRG,formatR,halfFloatTexType,supportLinearFiltering
 }
 };
}
function getSupportedFormat(gl,internalFormat,format,type){
 if(!supportRenderTextureFormat(gl,internalFormat,format,type)){
 switch(internalFormat){
 case gl.R32F:
 return getSupportedFormat(gl,gl.RG32F,gl.RG,type);
 case gl.RG32F:
 return getSupportedFormat(gl,gl.RGBA32F,gl.RGBA,type);
 default:
 return null;
 }
 }
 return {
 internalFormat,format
 };
}
function supportRenderTextureFormat(gl,internalFormat,format,type){
 let texture=gl.createTexture();
 gl.bindTexture(gl.TEXTURE_2D,texture);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.NEAREST);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.NEAREST);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.CLAMP_TO_EDGE);
 gl.texImage2D(gl.TEXTURE_2D,0,internalFormat,4,4,0,format,type,null);
 let fbo=gl.createFramebuffer();
 gl.bindFramebuffer(gl.FRAMEBUFFER,fbo);
 gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,texture,0);
 let status=gl.checkFramebufferStatus(gl.FRAMEBUFFER);
 return status == gl.FRAMEBUFFER_COMPLETE;
}
function startGUI(){
 var ww=window.innerWidth;
 var gui=new dat.GUI({width:ww});
 gui.add(config,'DYE_RESOLUTION',{
 'high':1024,'medium':512,'low':256,'very low':128
 }).name('quality').onFinishChange(initFramebuffers);
 gui.add(config,'SIM_RESOLUTION',{
 '32':32,'64':64,'128':128,'256':256
 }).name('sim resolution').onFinishChange(initFramebuffers);
 gui.add(config,'DENSITY_DISSIPATION',0,4.0).name('density diffusion');
 gui.add(config,'VELOCITY_DISSIPATION',0,4.0).name('velocity diffusion');
 gui.add(config,'PRESSURE',0.0,1.0).name('pressure');
 gui.add(config,'CURL',0,50).name('vorticity').step(1);
 gui.add(config,'SPLAT_RADIUS',0.01,1.0).name('splat radius');
 gui.add(config,'SHADING').name('shading').onFinishChange(updateKeywords);
 gui.add(config,'COLORFUL').name('colorful');
 gui.add(config,'PAUSED').name('paused').listen();
 gui.add({
 fun:() => {
 splatStack.push(parseInt(Math.random()*20)+5);
 }
 },'fun').name('Random splats');
 let bloomFolder=gui.addFolder('Bloom');
 bloomFolder.add(config,'BLOOM').name('enabled').onFinishChange(updateKeywords);
 bloomFolder.add(config,'BLOOM_INTENSITY',0.1,2.0).name('intensity');
 bloomFolder.add(config,'BLOOM_THRESHOLD',0.0,1.0).name('threshold');
 let sunraysFolder=gui.addFolder('Sunrays');
 sunraysFolder.add(config,'SUNRAYS').name('enabled').onFinishChange(updateKeywords);
 sunraysFolder.add(config,'SUNRAYS_WEIGHT',0.3,1.0).name('weight');
 let captureFolder=gui.addFolder('Capture');
 captureFolder.addColor(config,'BACK_COLOR').name('background color');
 captureFolder.add(config,'TRANSPARENT').name('transparent');
 captureFolder.add({fun:captureScreenshot},'fun').name('take screenshot');
 let github=gui.add({
 fun:() => {
 window.open('https://github.com/PavelDoGreat/WebGL-Fluid-Simulation');
 ga('send','event','link button','github');
 }
 },'fun').name('Github');
 github.__li.className='cr function bigFont';
 github.__li.style.borderLeft='3px solid #8C8C8C';
 let githubIcon=document.createElement('span');
 github.domElement.parentElement.appendChild(githubIcon);
 githubIcon.className='icon github';
 let twitter=gui.add({
 fun:() => {
 ga('send','event','link button','twitter');
 window.open('https://twitter.com/PavelDoGreat');
 }
 },'fun').name('Twitter');
 twitter.__li.className='cr function bigFont';
 twitter.__li.style.borderLeft='3px solid #8C8C8C';
 let twitterIcon=document.createElement('span');
 twitter.domElement.parentElement.appendChild(twitterIcon);
 twitterIcon.className='icon twitter';
 let discord=gui.add({
 fun:() => {
 ga('send','event','link button','discord');
 window.open('https://discordapp.com/invite/CeqZDDE');
 }
 },'fun').name('Discord');
 discord.__li.className='cr function bigFont';
 discord.__li.style.borderLeft='3px solid #8C8C8C';
 let discordIcon=document.createElement('span');
 discord.domElement.parentElement.appendChild(discordIcon);
 discordIcon.className='icon discord';
 let app=gui.add({
 fun:() => {
 ga('send','event','link button','app');
 window.open('http://onelink.to/5b58bn');
 }
 },'fun').name('Check out mobile app');
 app.__li.className='cr function appBigFont';
 app.__li.style.borderLeft='3px solid #00FF7F';
 let appIcon=document.createElement('span');
 app.domElement.parentElement.appendChild(appIcon);
 appIcon.className='icon app';
 if(isMobile()) gui.close();
}
function isMobile(){
 return /Mobi|Android/i.test(navigator.userAgent);
}
function captureScreenshot(){
 let res=getResolution(config.CAPTURE_RESOLUTION);
 let target=createFBO(res.width,res.height,ext.formatRGBA.internalFormat,ext.formatRGBA.format,ext.halfFloatTexType,gl.NEAREST);
 render(target);
 let texture=framebufferToTexture(target);
 texture=normalizeTexture(texture,target.width,target.height);
 let captureCanvas=textureToCanvas(texture,target.width,target.height);
 let datauri=captureCanvas.toDataURL();
 downloadURI('fluid.png',datauri);
 URL.revokeObjectURL(datauri);
}
function framebufferToTexture(target){
 gl.bindFramebuffer(gl.FRAMEBUFFER,target.fbo);
 let length=target.width*target.height*4;
 let texture=new Float32Array(length);
 gl.readPixels(0,0,target.width,target.height,gl.RGBA,gl.FLOAT,texture);
 return texture;
}
function normalizeTexture(texture,width,height){
 let result=new Uint8Array(texture.length);
 let id=0;
 for(let i=height-1; i>=0; i--){
 for(let j=0; j<width; j++){
 let nid=i*width*4+j*4;
 result[nid+0]=clamp01(texture[id+0])*255;
 result[nid+1]=clamp01(texture[id+1])*255;
 result[nid+2]=clamp01(texture[id+2])*255;
 result[nid+3]=clamp01(texture[id+3])*255;
 id+=4;
 }
 }
 return result;
}
function clamp01(input){
 return Math.min(Math.max(input,0),1);
}
function textureToCanvas(texture,width,height){
 let captureCanvas=document.createElement('canvas');
 let ctx=captureCanvas.getContext('2d');
 captureCanvas.width=width;
 captureCanvas.height=height;
 let imageData=ctx.createImageData(width,height);
 imageData.data.set(texture);
 ctx.putImageData(imageData,0,0);
 return captureCanvas;
}
function downloadURI(filename,uri){
 let link=document.createElement('a');
 link.download=filename;
 link.href=uri;
 document.body.appendChild(link);
 link.click();
 document.body.removeChild(link);
}
class Material{
 constructor(vertexShader,fragmentShaderSource){
 this.vertexShader=vertexShader;
 this.fragmentShaderSource=fragmentShaderSource;
 this.programs=[];
 this.activeProgram=null;
 this.uniforms=[];
 }
 setKeywords(keywords){
 let hash=0;
 for(let i=0; i<keywords.length; i++) hash+=hashCode(keywords[i]);
 let program=this.programs[hash];
 if(program == null){
 let fragmentShader=compileShader(gl.FRAGMENT_SHADER,this.fragmentShaderSource,keywords);
 program=createProgram(this.vertexShader,fragmentShader);
 this.programs[hash]=program;
 }
 if(program == this.activeProgram) return;
 this.uniforms=getUniforms(program);
 this.activeProgram=program;
 }
 bind(){
 gl.useProgram(this.activeProgram);
 }
}
class Program{
 constructor(vertexShader,fragmentShader){
 this.uniforms={};
 this.program=createProgram(vertexShader,fragmentShader);
 this.uniforms=getUniforms(this.program);
 }
 bind(){
 gl.useProgram(this.program);
 }
}
function createProgram(vertexShader,fragmentShader){
 let program=gl.createProgram();
 gl.attachShader(program,vertexShader);
 gl.attachShader(program,fragmentShader);
 gl.linkProgram(program);
 if(!gl.getProgramParameter(program,gl.LINK_STATUS)) console.trace(gl.getProgramInfoLog(program));
 return program;
}
function getUniforms(program){
 let uniforms=[];
 let uniformCount=gl.getProgramParameter(program,gl.ACTIVE_UNIFORMS);
 for(let i=0; i<uniformCount; i++){
 let uniformName=gl.getActiveUniform(program,i).name;
 uniforms[uniformName]=gl.getUniformLocation(program,uniformName);
 }
 return uniforms;
}
function compileShader(type,source,keywords){
 source=addKeywords(source,keywords);
 const shader=gl.createShader(type);
 gl.shaderSource(shader,source);
 gl.compileShader(shader);
 if(!gl.getShaderParameter(shader,gl.COMPILE_STATUS)) console.trace(gl.getShaderInfoLog(shader));
 return shader;
};
function addKeywords(source,keywords){
 if(keywords == null) return source;
 let keywordsString='';
 keywords.forEach(keyword => {
 keywordsString+='#define '+keyword+'\n';
 });
 return keywordsString+source;
}
const baseVertexShader=compileShader(gl.VERTEX_SHADER,`
 precision highp float;
 attribute vec2 aPosition;
 varying vec2 vUv;
 varying vec2 vL;
 varying vec2 vR;
 varying vec2 vT;
 varying vec2 vB;
 uniform vec2 texelSize;
 void main () {
 vUv=aPosition * 0.5 + 0.5;
 vL=vUv - vec2(texelSize.x,0.0);
 vR=vUv + vec2(texelSize.x,0.0);
 vT=vUv + vec2(0.0,texelSize.y);
 vB=vUv - vec2(0.0,texelSize.y);
 gl_Position=vec4(aPosition,0.0,1.0);
 }
`);
const blurVertexShader=compileShader(gl.VERTEX_SHADER,`
 precision highp float;
 attribute vec2 aPosition;
 varying vec2 vUv;
 varying vec2 vL;
 varying vec2 vR;
 uniform vec2 texelSize;
 void main () {
 vUv=aPosition * 0.5 + 0.5;
 float offset=1.33333333;
 vL=vUv - texelSize * offset;
 vR=vUv + texelSize * offset;
 gl_Position=vec4(aPosition,0.0,1.0);
 }
`);
const blurShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying vec2 vUv;
 varying vec2 vL;
 varying vec2 vR;
 uniform sampler2D uTexture;
 void main () {
 vec4 sum=texture2D(uTexture,vUv) * 0.29411764;
 sum += texture2D(uTexture,vL) * 0.35294117;
 sum += texture2D(uTexture,vR) * 0.35294117;
 gl_FragColor=sum;
 }
`);
const copyShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying highp vec2 vUv;
 uniform sampler2D uTexture;
 void main () {
 gl_FragColor=texture2D(uTexture,vUv);
 }
`);
const clearShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying highp vec2 vUv;
 uniform sampler2D uTexture;
 uniform float value;
 void main () {
 gl_FragColor=value * texture2D(uTexture,vUv);
 }
`);
const colorShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 uniform vec4 color;
 void main () {
 gl_FragColor=color;
 }
`);
const checkerboardShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying vec2 vUv;
 uniform sampler2D uTexture;
 uniform float aspectRatio;
 #define SCALE 25.0
 void main () {
 vec2 uv=floor(vUv * SCALE * vec2(aspectRatio,1.0));
 float v=mod(uv.x + uv.y,2.0);
 v=v * 0.1 + 0.8;
 gl_FragColor=vec4(vec3(v),1.0);
 }
`);
const displayShaderSource=`
 precision highp float;
 precision highp sampler2D;
 varying vec2 vUv;
 varying vec2 vL;
 varying vec2 vR;
 varying vec2 vT;
 varying vec2 vB;
 uniform sampler2D uTexture;
 uniform sampler2D uBloom;
 uniform sampler2D uSunrays;
 uniform sampler2D uDithering;
 uniform vec2 ditherScale;
 uniform vec2 texelSize;
 vec3 linearToGamma (vec3 color) {
 color=max(color,vec3(0));
 return max(1.055 * pow(color,vec3(0.416666667)) - 0.055,vec3(0));
 }
 void main () {
 vec3 c=texture2D(uTexture,vUv).rgb;
 #ifdef SHADING
 vec3 lc=texture2D(uTexture,vL).rgb;
 vec3 rc=texture2D(uTexture,vR).rgb;
 vec3 tc=texture2D(uTexture,vT).rgb;
 vec3 bc=texture2D(uTexture,vB).rgb;
 float dx=length(rc) - length(lc);
 float dy=length(tc) - length(bc);
 vec3 n=normalize(vec3(dx,dy,length(texelSize)));
 vec3 l=vec3(0.0,0.0,1.0);
 float diffuse=clamp(dot(n,l) + 0.7,0.7,1.0);
 c *= diffuse;
 #endif
 #ifdef BLOOM
 vec3 bloom=texture2D(uBloom,vUv).rgb;
 #endif
 #ifdef SUNRAYS
 float sunrays=texture2D(uSunrays,vUv).r;
 c *= sunrays;
 #ifdef BLOOM
 bloom *= sunrays;
 #endif
 #endif
 #ifdef BLOOM
 float noise=texture2D(uDithering,vUv * ditherScale).r;
 noise=noise * 2.0 - 1.0;
 bloom += noise / 255.0;
 bloom=linearToGamma(bloom);
 c += bloom;
 #endif
 float a=max(c.r,max(c.g,c.b));
 gl_FragColor=vec4(c,a);
 }
`;
const bloomPrefilterShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying vec2 vUv;
 uniform sampler2D uTexture;
 uniform vec3 curve;
 uniform float threshold;
 void main () {
 vec3 c=texture2D(uTexture,vUv).rgb;
 float br=max(c.r,max(c.g,c.b));
 float rq=clamp(br - curve.x,0.0,curve.y);
 rq=curve.z * rq * rq;
 c *= max(rq,br - threshold) / max(br,0.0001);
 gl_FragColor=vec4(c,0.0);
 }
`);
const bloomBlurShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying vec2 vL;
 varying vec2 vR;
 varying vec2 vT;
 varying vec2 vB;
 uniform sampler2D uTexture;
 void main () {
 vec4 sum=vec4(0.0);
 sum += texture2D(uTexture,vL);
 sum += texture2D(uTexture,vR);
 sum += texture2D(uTexture,vT);
 sum += texture2D(uTexture,vB);
 sum *= 0.25;
 gl_FragColor=sum;
 }
`);
const bloomFinalShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying vec2 vL;
 varying vec2 vR;
 varying vec2 vT;
 varying vec2 vB;
 uniform sampler2D uTexture;
 uniform float intensity;
 void main () {
 vec4 sum=vec4(0.0);
 sum += texture2D(uTexture,vL);
 sum += texture2D(uTexture,vR);
 sum += texture2D(uTexture,vT);
 sum += texture2D(uTexture,vB);
 sum *= 0.25;
 gl_FragColor=sum * intensity;
 }
`);
const sunraysMaskShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying vec2 vUv;
 uniform sampler2D uTexture;
 void main () {
 vec4 c=texture2D(uTexture,vUv);
 float br=max(c.r,max(c.g,c.b));
 c.a=1.0 - min(max(br * 20.0,0.0),0.8);
 gl_FragColor=c;
 }
`);
const sunraysShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying vec2 vUv;
 uniform sampler2D uTexture;
 uniform float weight;
 #define ITERATIONS 16
 void main () {
 float Density=0.3;
 float Decay=0.95;
 float Exposure=0.7;
 vec2 coord=vUv;
 vec2 dir=vUv - 0.5;
 dir *= 1.0 / float(ITERATIONS) * Density;
 float illuminationDecay=1.0;
 float color=texture2D(uTexture,vUv).a;
 for (int i=0; i < ITERATIONS; i++)
 {
 coord -= dir;
 float col=texture2D(uTexture,coord).a;
 color += col * illuminationDecay * weight;
 illuminationDecay *= Decay;
 }
 gl_FragColor=vec4(color * Exposure,0.0,0.0,1.0);
 }
`);
const splatShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying vec2 vUv;
 uniform sampler2D uTarget;
 uniform float aspectRatio;
 uniform vec3 color;
 uniform vec2 point;
 uniform float radius;
 void main () {
 vec2 p=vUv - point.xy;
 p.x *= aspectRatio;
 vec3 splat=exp(-dot(p,p) / radius) * color;
 vec3 base=texture2D(uTarget,vUv).xyz;
 gl_FragColor=vec4(base + splat,1.0);
 }
`);
const advectionShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying vec2 vUv;
 uniform sampler2D uVelocity;
 uniform sampler2D uSource;
 uniform vec2 texelSize;
 uniform vec2 dyeTexelSize;
 uniform float dt;
 uniform float dissipation;
 vec4 bilerp (sampler2D sam,vec2 uv,vec2 tsize) {
 vec2 st=uv / tsize - 0.5;
 vec2 iuv=floor(st);
 vec2 fuv=fract(st);
 vec4 a=texture2D(sam,(iuv + vec2(0.5,0.5)) * tsize);
 vec4 b=texture2D(sam,(iuv + vec2(1.5,0.5)) * tsize);
 vec4 c=texture2D(sam,(iuv + vec2(0.5,1.5)) * tsize);
 vec4 d=texture2D(sam,(iuv + vec2(1.5,1.5)) * tsize);
 return mix(mix(a,b,fuv.x),mix(c,d,fuv.x),fuv.y);
 }
 void main () {
 #ifdef MANUAL_FILTERING
 vec2 coord=vUv - dt * bilerp(uVelocity,vUv,texelSize).xy * texelSize;
 vec4 result=bilerp(uSource,coord,dyeTexelSize);
 #else
 vec2 coord=vUv - dt * texture2D(uVelocity,vUv).xy * texelSize;
 vec4 result=texture2D(uSource,coord);
 #endif
 float decay=1.0 + dissipation * dt;
 gl_FragColor=result / decay;
 }`,ext.supportLinearFiltering?null:['MANUAL_FILTERING']);
const divergenceShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying highp vec2 vUv;
 varying highp vec2 vL;
 varying highp vec2 vR;
 varying highp vec2 vT;
 varying highp vec2 vB;
 uniform sampler2D uVelocity;
 void main () {
 float L=texture2D(uVelocity,vL).x;
 float R=texture2D(uVelocity,vR).x;
 float T=texture2D(uVelocity,vT).y;
 float B=texture2D(uVelocity,vB).y;
 vec2 C=texture2D(uVelocity,vUv).xy;
 if (vL.x < 0.0) { L=-C.x; }
 if (vR.x > 1.0) { R=-C.x; }
 if (vT.y > 1.0) { T=-C.y; }
 if (vB.y < 0.0) { B=-C.y; }
 float div=0.5 * (R - L + T - B);
 gl_FragColor=vec4(div,0.0,0.0,1.0);
 }
`);
const curlShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying highp vec2 vUv;
 varying highp vec2 vL;
 varying highp vec2 vR;
 varying highp vec2 vT;
 varying highp vec2 vB;
 uniform sampler2D uVelocity;
 void main () {
 float L=texture2D(uVelocity,vL).y;
 float R=texture2D(uVelocity,vR).y;
 float T=texture2D(uVelocity,vT).x;
 float B=texture2D(uVelocity,vB).x;
 float vorticity=R - L - T + B;
 gl_FragColor=vec4(0.5 * vorticity,0.0,0.0,1.0);
 }
`);
const vorticityShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying vec2 vUv;
 varying vec2 vL;
 varying vec2 vR;
 varying vec2 vT;
 varying vec2 vB;
 uniform sampler2D uVelocity;
 uniform sampler2D uCurl;
 uniform float curl;
 uniform float dt;
 void main () {
 float L=texture2D(uCurl,vL).x;
 float R=texture2D(uCurl,vR).x;
 float T=texture2D(uCurl,vT).x;
 float B=texture2D(uCurl,vB).x;
 float C=texture2D(uCurl,vUv).x;
 vec2 force=0.5 * vec2(abs(T) - abs(B),abs(R) - abs(L));
 force /= length(force) + 0.0001;
 force *= curl * C;
 force.y *= -1.0;
 vec2 velocity=texture2D(uVelocity,vUv).xy;
 velocity += force * dt;
 velocity=min(max(velocity,-1000.0),1000.0);
 gl_FragColor=vec4(velocity,0.0,1.0);
 }
`);
const pressureShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying highp vec2 vUv;
 varying highp vec2 vL;
 varying highp vec2 vR;
 varying highp vec2 vT;
 varying highp vec2 vB;
 uniform sampler2D uPressure;
 uniform sampler2D uDivergence;
 void main () {
 float L=texture2D(uPressure,vL).x;
 float R=texture2D(uPressure,vR).x;
 float T=texture2D(uPressure,vT).x;
 float B=texture2D(uPressure,vB).x;
 float C=texture2D(uPressure,vUv).x;
 float divergence=texture2D(uDivergence,vUv).x;
 float pressure=(L + R + B + T - divergence) * 0.25;
 gl_FragColor=vec4(pressure,0.0,0.0,1.0);
 }
`);
const gradientSubtractShader=compileShader(gl.FRAGMENT_SHADER,`
 precision highp float;
 precision highp sampler2D;
 varying highp vec2 vUv;
 varying highp vec2 vL;
 varying highp vec2 vR;
 varying highp vec2 vT;
 varying highp vec2 vB;
 uniform sampler2D uPressure;
 uniform sampler2D uVelocity;
 void main () {
 float L=texture2D(uPressure,vL).x;
 float R=texture2D(uPressure,vR).x;
 float T=texture2D(uPressure,vT).x;
 float B=texture2D(uPressure,vB).x;
 vec2 velocity=texture2D(uVelocity,vUv).xy;
 velocity.xy -= vec2(R - L,T - B);
 gl_FragColor=vec4(velocity,0.0,1.0);
 }
`);
const blit=(() => {
 gl.bindBuffer(gl.ARRAY_BUFFER,gl.createBuffer());
 gl.bufferData(gl.ARRAY_BUFFER,new Float32Array([-1,-1,-1,1,1,1,1,-1]),gl.STATIC_DRAW);
 gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER,gl.createBuffer());
 gl.bufferData(gl.ELEMENT_ARRAY_BUFFER,new Uint16Array([0,1,2,0,2,3]),gl.STATIC_DRAW);
 gl.vertexAttribPointer(0,2,gl.FLOAT,false,0,0);
 gl.enableVertexAttribArray(0);
 return (target,clear=false) => {
 if(target == null){
 gl.viewport(0,0,gl.drawingBufferWidth,gl.drawingBufferHeight);
 gl.bindFramebuffer(gl.FRAMEBUFFER,null);
 }else{
 gl.viewport(0,0,target.width,target.height);
 gl.bindFramebuffer(gl.FRAMEBUFFER,target.fbo);
 }
 if(clear){
 gl.clearColor(Math.random(),Math.random(),Math.random(),1.0);
 gl.clear(gl.COLOR_BUFFER_BIT);
 }
 gl.drawElements(gl.TRIANGLES,6,gl.UNSIGNED_SHORT,0);
 };
})();
function CHECK_FRAMEBUFFER_STATUS(){
 let status=gl.checkFramebufferStatus(gl.FRAMEBUFFER);
 if(status != gl.FRAMEBUFFER_COMPLETE) console.trace("Framebuffer error: "+status);
}
let dye;
let velocity;
let divergence;
let curl;
let pressure;
let bloom;
let bloomFramebuffers=[];
let sunrays;
let sunraysTemp;
let ditheringTexture=createTextureAsync('LDR_LLL1_0.png');
const blurProgram=new Program(blurVertexShader,blurShader);
const copyProgram=new Program(baseVertexShader,copyShader);
const clearProgram=new Program(baseVertexShader,clearShader);
const colorProgram=new Program(baseVertexShader,colorShader);
const checkerboardProgram=new Program(baseVertexShader,checkerboardShader);
const bloomPrefilterProgram=new Program(baseVertexShader,bloomPrefilterShader);
const bloomBlurProgram=new Program(baseVertexShader,bloomBlurShader);
const bloomFinalProgram=new Program(baseVertexShader,bloomFinalShader);
const sunraysMaskProgram=new Program(baseVertexShader,sunraysMaskShader);
const sunraysProgram=new Program(baseVertexShader,sunraysShader);
const splatProgram=new Program(baseVertexShader,splatShader);
const advectionProgram=new Program(baseVertexShader,advectionShader);
const divergenceProgram=new Program(baseVertexShader,divergenceShader);
const curlProgram=new Program(baseVertexShader,curlShader);
const vorticityProgram=new Program(baseVertexShader,vorticityShader);
const pressureProgram=new Program(baseVertexShader,pressureShader);
const gradienSubtractProgram=new Program(baseVertexShader,gradientSubtractShader);
const displayMaterial=new Material(baseVertexShader,displayShaderSource);
function initFramebuffers(){
 let simRes=getResolution(config.SIM_RESOLUTION);
 let dyeRes=getResolution(config.DYE_RESOLUTION);
 const texType=ext.halfFloatTexType;
 const rgba=ext.formatRGBA;
 const rg=ext.formatRG;
 const r=ext.formatR;
 const filtering=ext.supportLinearFiltering?gl.LINEAR:gl.NEAREST;
 gl.disable(gl.BLEND);
 if(dye == null) dye=createDoubleFBO(dyeRes.width,dyeRes.height,rgba.internalFormat,rgba.format,texType,filtering); else dye=resizeDoubleFBO(dye,dyeRes.width,dyeRes.height,rgba.internalFormat,rgba.format,texType,filtering);
 if(velocity == null) velocity=createDoubleFBO(simRes.width,simRes.height,rg.internalFormat,rg.format,texType,filtering); else velocity=resizeDoubleFBO(velocity,simRes.width,simRes.height,rg.internalFormat,rg.format,texType,filtering);
 divergence=createFBO(simRes.width,simRes.height,r.internalFormat,r.format,texType,gl.NEAREST);
 curl=createFBO(simRes.width,simRes.height,r.internalFormat,r.format,texType,gl.NEAREST);
 pressure=createDoubleFBO(simRes.width,simRes.height,r.internalFormat,r.format,texType,gl.NEAREST);
 initBloomFramebuffers();
 initSunraysFramebuffers();
}
function initBloomFramebuffers(){
 let res=getResolution(config.BLOOM_RESOLUTION);
 const texType=ext.halfFloatTexType;
 const rgba=ext.formatRGBA;
 const filtering=ext.supportLinearFiltering?gl.LINEAR:gl.NEAREST;
 bloom=createFBO(res.width,res.height,rgba.internalFormat,rgba.format,texType,filtering);
 bloomFramebuffers.length=0;
 for(let i=0; i<config.BLOOM_ITERATIONS; i++){
 let width=res.width >> (i+1);
 let height=res.height >> (i+1);
 if(width<2 || height<2) break;
 let fbo=createFBO(width,height,rgba.internalFormat,rgba.format,texType,filtering);
 bloomFramebuffers.push(fbo);
 }
}
function initSunraysFramebuffers(){
 let res=getResolution(config.SUNRAYS_RESOLUTION);
 const texType=ext.halfFloatTexType;
 const r=ext.formatR;
 const filtering=ext.supportLinearFiltering?gl.LINEAR:gl.NEAREST;
 sunrays=createFBO(res.width,res.height,r.internalFormat,r.format,texType,filtering);
 sunraysTemp=createFBO(res.width,res.height,r.internalFormat,r.format,texType,filtering);
}
function createFBO(w,h,internalFormat,format,type,param){
 gl.activeTexture(gl.TEXTURE0);
 let texture=gl.createTexture();
 gl.bindTexture(gl.TEXTURE_2D,texture);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,param);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,param);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.CLAMP_TO_EDGE);
 gl.texImage2D(gl.TEXTURE_2D,0,internalFormat,w,h,0,format,type,null);
 let fbo=gl.createFramebuffer();
 gl.bindFramebuffer(gl.FRAMEBUFFER,fbo);
 gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,texture,0);
 gl.viewport(0,0,w,h);
 gl.clear(gl.COLOR_BUFFER_BIT);
 let texelSizeX=1.0/w;
 let texelSizeY=1.0/h;
 return {
 texture,fbo,width:w,height:h,texelSizeX,texelSizeY,attach(id){
 gl.activeTexture(gl.TEXTURE0+id);
 gl.bindTexture(gl.TEXTURE_2D,texture);
 return id;
 }
 };
}
function createDoubleFBO(w,h,internalFormat,format,type,param){
 let fbo1=createFBO(w,h,internalFormat,format,type,param);
 let fbo2=createFBO(w,h,internalFormat,format,type,param);
 return {
 width:w,height:h,texelSizeX:fbo1.texelSizeX,texelSizeY:fbo1.texelSizeY,get read(){
 return fbo1;
 },set read(value){
 fbo1=value;
 },get write(){
 return fbo2;
 },set write(value){
 fbo2=value;
 },swap(){
 let temp=fbo1;
 fbo1=fbo2;
 fbo2=temp;
 }
 };
}
function resizeFBO(target,w,h,internalFormat,format,type,param){
 let newFBO=createFBO(w,h,internalFormat,format,type,param);
 copyProgram.bind();
 gl.uniform1i(copyProgram.uniforms.uTexture,target.attach(0));
 blit(newFBO);
 return newFBO;
}
function resizeDoubleFBO(target,w,h,internalFormat,format,type,param){
 if(target.width == w && target.height == h) return target;
 target.read=resizeFBO(target.read,w,h,internalFormat,format,type,param);
 target.write=createFBO(w,h,internalFormat,format,type,param);
 target.width=w;
 target.height=h;
 target.texelSizeX=1.0/w;
 target.texelSizeY=1.0/h;
 return target;
}
function createTextureAsync(url){
 let texture=gl.createTexture();
 gl.bindTexture(gl.TEXTURE_2D,texture);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.LINEAR);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.LINEAR);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.REPEAT);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.REPEAT);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGB,1,1,0,gl.RGB,gl.UNSIGNED_BYTE,new Uint8Array([255,255,255]));
 let obj={
 texture,width:1,height:1,attach(id){
 gl.activeTexture(gl.TEXTURE0+id);
 gl.bindTexture(gl.TEXTURE_2D,texture);
 return id;
 }
 };
 let image=new Image();
 image.onload=() => {
 obj.width=image.width;
 obj.height=image.height;
 gl.bindTexture(gl.TEXTURE_2D,texture);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGB,gl.RGB,gl.UNSIGNED_BYTE,image);
 };
 image.src=url;
 return obj;
}
function updateKeywords(){
 let displayKeywords=[];
 if(config.SHADING) displayKeywords.push("SHADING");
 if(config.BLOOM) displayKeywords.push("BLOOM");
 if(config.SUNRAYS) displayKeywords.push("SUNRAYS");
 displayMaterial.setKeywords(displayKeywords);
}
updateKeywords();
initFramebuffers();
multipleSplats(parseInt(Math.random()*20)+5);
let lastUpdateTime=Date.now();
let colorUpdateTimer=0.0;
update();
function update(){
 const dt=calcDeltaTime();
 if(resizeCanvas()) initFramebuffers();
 updateColors(dt);
 applyInputs();
 if(!config.PAUSED) step(dt);
 render(null);
 requestAnimationFrame(update);
}
function calcDeltaTime(){
 let now=Date.now();
 let dt=(now-lastUpdateTime)/1000;
 dt=Math.min(dt,0.016666);
 lastUpdateTime=now;
 return dt;
}
function resizeCanvas(){
 let width=scaleByPixelRatio(canvas.clientWidth);
 let height=scaleByPixelRatio(canvas.clientHeight);
 if(canvas.width != width || canvas.height != height){
 canvas.width=width;
 canvas.height=height;
 return true;
 }
 return false;
}
function updateColors(dt){
 if(!config.COLORFUL) return;
 colorUpdateTimer+=dt*config.COLOR_UPDATE_SPEED;
 if(colorUpdateTimer>=1){
 colorUpdateTimer=wrap(colorUpdateTimer,0,1);
 pointers.forEach(p => {
 p.color=generateColor();
 });
 }
}
function applyInputs(){
 if(splatStack.length>0) multipleSplats(splatStack.pop());
 pointers.forEach(p => {
 if(p.moved){
 p.moved=false;
 splatPointer(p);
 }
 });
}
function step(dt){
 gl.disable(gl.BLEND);
 curlProgram.bind();
 gl.uniform2f(curlProgram.uniforms.texelSize,velocity.texelSizeX,velocity.texelSizeY);
 gl.uniform1i(curlProgram.uniforms.uVelocity,velocity.read.attach(0));
 blit(curl);
 vorticityProgram.bind();
 gl.uniform2f(vorticityProgram.uniforms.texelSize,velocity.texelSizeX,velocity.texelSizeY);
 gl.uniform1i(vorticityProgram.uniforms.uVelocity,velocity.read.attach(0));
 gl.uniform1i(vorticityProgram.uniforms.uCurl,curl.attach(1));
 gl.uniform1f(vorticityProgram.uniforms.curl,config.CURL);
 gl.uniform1f(vorticityProgram.uniforms.dt,dt);
 blit(velocity.write);
 velocity.swap();
 divergenceProgram.bind();
 gl.uniform2f(divergenceProgram.uniforms.texelSize,velocity.texelSizeX,velocity.texelSizeY);
 gl.uniform1i(divergenceProgram.uniforms.uVelocity,velocity.read.attach(0));
 blit(divergence);
 clearProgram.bind();
 gl.uniform1i(clearProgram.uniforms.uTexture,pressure.read.attach(0));
 gl.uniform1f(clearProgram.uniforms.value,config.PRESSURE);
 blit(pressure.write);
 pressure.swap();
 pressureProgram.bind();
 gl.uniform2f(pressureProgram.uniforms.texelSize,velocity.texelSizeX,velocity.texelSizeY);
 gl.uniform1i(pressureProgram.uniforms.uDivergence,divergence.attach(0));
 for(let i=0; i<config.PRESSURE_ITERATIONS; i++){
 gl.uniform1i(pressureProgram.uniforms.uPressure,pressure.read.attach(1));
 blit(pressure.write);
 pressure.swap();
 }
 gradienSubtractProgram.bind();
 gl.uniform2f(gradienSubtractProgram.uniforms.texelSize,velocity.texelSizeX,velocity.texelSizeY);
 gl.uniform1i(gradienSubtractProgram.uniforms.uPressure,pressure.read.attach(0));
 gl.uniform1i(gradienSubtractProgram.uniforms.uVelocity,velocity.read.attach(1));
 blit(velocity.write);
 velocity.swap();
 advectionProgram.bind();
 gl.uniform2f(advectionProgram.uniforms.texelSize,velocity.texelSizeX,velocity.texelSizeY);
 if(!ext.supportLinearFiltering) gl.uniform2f(advectionProgram.uniforms.dyeTexelSize,velocity.texelSizeX,velocity.texelSizeY);
 let velocityId=velocity.read.attach(0);
 gl.uniform1i(advectionProgram.uniforms.uVelocity,velocityId);
 gl.uniform1i(advectionProgram.uniforms.uSource,velocityId);
 gl.uniform1f(advectionProgram.uniforms.dt,dt);
 gl.uniform1f(advectionProgram.uniforms.dissipation,config.VELOCITY_DISSIPATION);
 blit(velocity.write);
 velocity.swap();
 if(!ext.supportLinearFiltering) gl.uniform2f(advectionProgram.uniforms.dyeTexelSize,dye.texelSizeX,dye.texelSizeY);
 gl.uniform1i(advectionProgram.uniforms.uVelocity,velocity.read.attach(0));
 gl.uniform1i(advectionProgram.uniforms.uSource,dye.read.attach(1));
 gl.uniform1f(advectionProgram.uniforms.dissipation,config.DENSITY_DISSIPATION);
 blit(dye.write);
 dye.swap();
}
function render(target){
 if(config.BLOOM) applyBloom(dye.read,bloom);
 if(config.SUNRAYS){
 applySunrays(dye.read,dye.write,sunrays);
 blur(sunrays,sunraysTemp,1);
 }
 if(target == null || !config.TRANSPARENT){
 gl.blendFunc(gl.ONE,gl.ONE_MINUS_SRC_ALPHA);
 gl.enable(gl.BLEND);
 }else{
 gl.disable(gl.BLEND);
 }
// if(!config.TRANSPARENT) drawColor(target,normalizeColor(config.BACK_COLOR));
 if(!config.TRANSPARENT) drawColor(target,normalizeColor(0,0,0,0));
// if(target == null && config.TRANSPARENT) drawCheckerboard(target);
 drawDisplay(target);
}
function drawColor(target,color){
 colorProgram.bind();
 gl.uniform4f(colorProgram.uniforms.color,color.r,color.g,color.b,1);
 blit(target);
}
function drawCheckerboard(target){
 checkerboardProgram.bind();
 gl.uniform1f(checkerboardProgram.uniforms.aspectRatio,canvas.width/canvas.height);
 blit(target);
}
function drawDisplay(target){
 let width=target == null?gl.drawingBufferWidth:target.width;
 let height=target == null?gl.drawingBufferHeight:target.height;
 displayMaterial.bind();
 if(config.SHADING) gl.uniform2f(displayMaterial.uniforms.texelSize,1.0/width,1.0/height);
 gl.uniform1i(displayMaterial.uniforms.uTexture,dye.read.attach(0));
 if(config.BLOOM){
 gl.uniform1i(displayMaterial.uniforms.uBloom,bloom.attach(1));
 gl.uniform1i(displayMaterial.uniforms.uDithering,ditheringTexture.attach(2));
 let scale=getTextureScale(ditheringTexture,width,height);
 gl.uniform2f(displayMaterial.uniforms.ditherScale,scale.x,scale.y);
 }
 if(config.SUNRAYS) gl.uniform1i(displayMaterial.uniforms.uSunrays,sunrays.attach(3));
 blit(target);
}
function applyBloom(source,destination){
 if(bloomFramebuffers.length<2) return;
 let last=destination;
 gl.disable(gl.BLEND);
 bloomPrefilterProgram.bind();
 let knee=config.BLOOM_THRESHOLD*config.BLOOM_SOFT_KNEE+0.0001;
 let curve0=config.BLOOM_THRESHOLD-knee;
 let curve1=knee*2;
 let curve2=0.25/knee;
 gl.uniform3f(bloomPrefilterProgram.uniforms.curve,curve0,curve1,curve2);
 gl.uniform1f(bloomPrefilterProgram.uniforms.threshold,config.BLOOM_THRESHOLD);
 gl.uniform1i(bloomPrefilterProgram.uniforms.uTexture,source.attach(0));
 blit(last);
 bloomBlurProgram.bind();
 for(let i=0; i<bloomFramebuffers.length; i++){
 let dest=bloomFramebuffers[i];
 gl.uniform2f(bloomBlurProgram.uniforms.texelSize,last.texelSizeX,last.texelSizeY);
 gl.uniform1i(bloomBlurProgram.uniforms.uTexture,last.attach(0));
 blit(dest);
 last=dest;
 }
 gl.blendFunc(gl.ONE,gl.ONE);
 gl.enable(gl.BLEND);
 for(let i=bloomFramebuffers.length-2; i>=0; i--){
 let baseTex=bloomFramebuffers[i];
 gl.uniform2f(bloomBlurProgram.uniforms.texelSize,last.texelSizeX,last.texelSizeY);
 gl.uniform1i(bloomBlurProgram.uniforms.uTexture,last.attach(0));
 gl.viewport(0,0,baseTex.width,baseTex.height);
 blit(baseTex);
 last=baseTex;
 }
 gl.disable(gl.BLEND);
 bloomFinalProgram.bind();
 gl.uniform2f(bloomFinalProgram.uniforms.texelSize,last.texelSizeX,last.texelSizeY);
 gl.uniform1i(bloomFinalProgram.uniforms.uTexture,last.attach(0));
 gl.uniform1f(bloomFinalProgram.uniforms.intensity,config.BLOOM_INTENSITY);
 blit(destination);
}
function applySunrays(source,mask,destination){
 gl.disable(gl.BLEND);
 sunraysMaskProgram.bind();
 gl.uniform1i(sunraysMaskProgram.uniforms.uTexture,source.attach(0));
 blit(mask);
 sunraysProgram.bind();
 gl.uniform1f(sunraysProgram.uniforms.weight,config.SUNRAYS_WEIGHT);
 gl.uniform1i(sunraysProgram.uniforms.uTexture,mask.attach(0));
 blit(destination);
}
function blur(target,temp,iterations){
 blurProgram.bind();
 for(let i=0; i<iterations; i++){
 gl.uniform2f(blurProgram.uniforms.texelSize,target.texelSizeX,0.0);
 gl.uniform1i(blurProgram.uniforms.uTexture,target.attach(0));
 blit(temp);
 gl.uniform2f(blurProgram.uniforms.texelSize,0.0,target.texelSizeY);
 gl.uniform1i(blurProgram.uniforms.uTexture,temp.attach(0));
 blit(target);
 }
}
function splatPointer(pointer){
 let dx=pointer.deltaX*config.SPLAT_FORCE;
 let dy=pointer.deltaY*config.SPLAT_FORCE;
 splat(pointer.texcoordX,pointer.texcoordY,dx,dy,pointer.color);
}
function multipleSplats(amount){
 for(let i=0; i<amount; i++){
 const color=generateColor();
 color.r*=10.0;
 color.g*=10.0;
 color.b*=10.0;
 const x=Math.random();
 const y=Math.random();
 const dx=1000*(Math.random()-0.5);
 const dy=1000*(Math.random()-0.5);
 splat(x,y,dx,dy,color);
 }
}
function splat(x,y,dx,dy,color){
 splatProgram.bind();
 gl.uniform1i(splatProgram.uniforms.uTarget,velocity.read.attach(0));
 gl.uniform1f(splatProgram.uniforms.aspectRatio,canvas.width/canvas.height);
 gl.uniform2f(splatProgram.uniforms.point,x,y);
 gl.uniform3f(splatProgram.uniforms.color,dx,dy,0.0);
 gl.uniform1f(splatProgram.uniforms.radius,correctRadius(config.SPLAT_RADIUS/100.0));
 blit(velocity.write);
 velocity.swap();
 gl.uniform1i(splatProgram.uniforms.uTarget,dye.read.attach(0));
 gl.uniform3f(splatProgram.uniforms.color,color.r,color.g,color.b);
 blit(dye.write);
 dye.swap();
}
function correctRadius(radius){
 let aspectRatio=canvas.width/canvas.height;
 if(aspectRatio>1) radius*=aspectRatio;
 return radius;
}
canvas.addEventListener('mousedown',e => {
 let posX=scaleByPixelRatio(e.offsetX);
 let posY=scaleByPixelRatio(e.offsetY);
 let pointer=pointers.find(p => p.id == -1);
 if(pointer == null) pointer=new pointerPrototype();
 updatePointerDownData(pointer,-1,posX,posY);
});
canvas.addEventListener('mousemove',e => {
 let pointer=pointers[0];
 if(!pointer.down) return;
 let posX=scaleByPixelRatio(e.offsetX);
 let posY=scaleByPixelRatio(e.offsetY);
 updatePointerMoveData(pointer,posX,posY);
});
window.addEventListener('mouseup',() => {
 updatePointerUpData(pointers[0]);
});
canvas.addEventListener('touchstart',e => {
 e.preventDefault();
 const touches=e.targetTouches;
 while(touches.length>=pointers.length) pointers.push(new pointerPrototype());
 for(let i=0; i<touches.length; i++){
 let posX=scaleByPixelRatio(touches[i].pageX);
 let posY=scaleByPixelRatio(touches[i].pageY);
 updatePointerDownData(pointers[i+1],touches[i].identifier,posX,posY);
 }
});
canvas.addEventListener('touchmove',e => {
 e.preventDefault();
 const touches=e.targetTouches;
 for(let i=0; i<touches.length; i++){
 let pointer=pointers[i+1];
 if(!pointer.down) continue;
 let posX=scaleByPixelRatio(touches[i].pageX);
 let posY=scaleByPixelRatio(touches[i].pageY);
 updatePointerMoveData(pointer,posX,posY);
 }
},false);
window.addEventListener('touchend',e => {
 const touches=e.changedTouches;
 for(let i=0; i<touches.length; i++){
 let pointer=pointers.find(p => p.id == touches[i].identifier);
 if(pointer == null) continue;
 updatePointerUpData(pointer);
 }
});
window.addEventListener('keydown',e => {
 if(e.code === 'KeyP') config.PAUSED= !config.PAUSED;
 if(e.key === ' ') splatStack.push(parseInt(Math.random()*20)+5);
});
function updatePointerDownData(pointer,id,posX,posY){
 pointer.id=id;
 pointer.down=true;
 pointer.moved=false;
 pointer.texcoordX=posX/canvas.width;
 pointer.texcoordY=1.0-posY/canvas.height;
 pointer.prevTexcoordX=pointer.texcoordX;
 pointer.prevTexcoordY=pointer.texcoordY;
 pointer.deltaX=0;
 pointer.deltaY=0;
 pointer.color=generateColor();
}
function updatePointerMoveData(pointer,posX,posY){
 pointer.prevTexcoordX=pointer.texcoordX;
 pointer.prevTexcoordY=pointer.texcoordY;
 pointer.texcoordX=posX/canvas.width;
 pointer.texcoordY=1.0-posY/canvas.height;
 pointer.deltaX=correctDeltaX(pointer.texcoordX-pointer.prevTexcoordX);
 pointer.deltaY=correctDeltaY(pointer.texcoordY-pointer.prevTexcoordY);
 pointer.moved=Math.abs(pointer.deltaX)>0 || Math.abs(pointer.deltaY)>0;
}
function updatePointerUpData(pointer){
 pointer.down=false;
}
function correctDeltaX(delta){
 let aspectRatio=canvas.width/canvas.height;
 if(aspectRatio<1) delta*=aspectRatio;
 return delta;
}
function correctDeltaY(delta){
 let aspectRatio=canvas.width/canvas.height;
 if(aspectRatio>1) delta/=aspectRatio;
 return delta;
}
function generateColor(){
 let c=HSVtoRGB(Math.random(),(0.25+(Math.random()*0.5)),(0.25+(Math.random()*0.5)));
 c.r*=(0.25+(Math.random()*0.5));
 c.g*=(0.25+(Math.random()*0.5));
 c.b*=(0.25+(Math.random()*0.5));
 return c;
}
function HSVtoRGB(h,s,v){
 let r,g,b,i,f,p,q,t;
 i=Math.floor(h*6);
 f=h*6-i;
 p=v*(1-s);
 q=v*(1-f*s);
 t=v*(1-(1-f)*s);
 switch(i%6){
 case 0:
 r=v,g=t,b=p;
 break;
 case 1:
 r=q,g=v,b=p;
 break;
 case 2:
 r=p,g=v,b=t;
 break;
 case 3:
 r=p,g=q,b=v;
 break;
 case 4:
 r=t,g=p,b=v;
 break;
 case 5:
 r=v,g=p,b=q;
 break;
 }
 return {
 r,g,b
 };
}
function normalizeColor(input){
 let output={
 r:input.r/255,g:input.g/255,b:input.b/255
 };
 return output;
}
function wrap(value,min,max){
 let range=max-min;
 if(range == 0) return min;
 return (value-min)%range+min;
}
function getResolution(resolution){
 let aspectRatio=gl.drawingBufferWidth/gl.drawingBufferHeight;
 if(aspectRatio<1) aspectRatio=1.0/aspectRatio;
 let min=Math.round(resolution);
 let max=Math.round(resolution*aspectRatio);
 if(gl.drawingBufferWidth>gl.drawingBufferHeight) return {width:max,height:min}; else return {width:min,height:max};
}
function getTextureScale(texture,width,height){
 return {
 x:width/texture.width,y:height/texture.height
 };
}
function scaleByPixelRatio(input){
 let pixelRatio=window.devicePixelRatio || 1;
 return Math.floor(input*pixelRatio);
}
function hashCode(s){
 if(s.length == 0) return 0;
 let hash=0;
 for(let i=0; i<s.length; i++){
 hash=(hash << 5)-hash+s.charCodeAt(i);
 hash|=0;
 }
 return hash;
};

function opn(){
setTimeout(function(){
document.getElementById("shut").innerHTML=2;
document.getElementById("circle").width=window.innerWidth;
document.getElementById("circle").height=window.innerHeight;
},350);
}
opn();


var statusElement=document.getElementById("status");
var progressElement=document.getElementById("progress");
var Module={
preRun: [],
postRun: [],
print: (function() {
var element=document.getElementById("output");
if (element)
element.value='';
return function(text) {
if (arguments.length > 1)
text=Array.prototype.slice.call(arguments).join(' ');
// console.log(text);
if (element) {
element.value += text + "\n";
element.scrollTop=element.scrollHeight;
}
};
}
)(),
printErr: function(text) {
if (arguments.length > 1)
text=Array.prototype.slice.call(arguments).join(' ');
if (0) {
dump(text + '\n');
} else {
console.error(text);
}
},
canvas: (function() {
var sscanvas=document.getElementById("bcanvas");
sscanvas.addEventListener("webglcontextlost", function(e) {
alert('WebGL context lost. You will need to reload the page.');
e.preventDefault();
}, false);
return sscanvas;
}
)(),
setStatus: function(text) {
if (!Module.setStatus.last) {
Module.setStatus.last={
time: Date.now(),
text: ''
};
}
if (text === Module.setStatus.text) {
return;
}
var m=text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/);
var now=Date.now();
if (m && now - Date.now() < 30) {
return;
}
if (m) {
text=m[1];
progressElement.value=parseInt(m[2], 10) * 100;
progressElement.max=parseInt(m[4], 10) * 100;
progressElement.hidden=false;
} else {
progressElement.value=null;
progressElement.max=null;
progressElement.hidden=true;
}
statusElement.innerHTML=text;
},
totalDependencies: 0,
monitorRunDependencies: function(left) {
this.totalDependencies=Math.max(this.totalDependencies, left);
Module.setStatus(left ? 'Preparing...(' + (this.totalDependencies - left) + '/' + this.totalDependencies + ')' : 'All downloads complete.');
}
};
Module.setStatus("|Download|");
window.onerror=function(event) {
Module.setStatus('Exception thrown,see JavaScript console');
Module.setStatus=function(text) {
if (text) {
Module.printErr("[post-exception status] " + text);
}
};
};

/**
 * gpu.js
 * http://gpu.rocks/
 *
 * GPU Accelerated JavaScript
 *
 * @version 2.15.0
 * @date Wed Jan 26 2022 17:11:45 GMT-0500 (Eastern Standard Time)
 *
 * @license MIT
 * The MIT License
 *
 * Copyright (c) 2022 gpu.js Team
 */(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.GPU=f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
 (function (global,factory) {
 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
 typeof define === 'function' && define.amd ? define(['exports'],factory) :
(global=global || self,factory(global.acorn={}));
 }(this,function (exports) { 'use strict';


 var reservedWords={
 3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",
 5: "class enum extends super const export import",
 6: "enum",
 strict: "implements interface let package private protected public static yield",
 strictBind: "eval arguments"
 };


 var ecma5AndLessKeywords="break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";

 var keywords={
 5: ecma5AndLessKeywords,
 "5module": ecma5AndLessKeywords + " export import",
 6: ecma5AndLessKeywords + " const class extends export import super"
 };

 var keywordRelationalOperator=/^in(stanceof)?$/;


 var nonASCIIidentifierStartChars="\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08bd\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fef\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7c6\ua7f7-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab67\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
 var nonASCIIidentifierChars="\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";

 var nonASCIIidentifierStart=new RegExp("[" + nonASCIIidentifierStartChars + "]");
 var nonASCIIidentifier=new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");

 nonASCIIidentifierStartChars=nonASCIIidentifierChars=null;


 var astralIdentifierStartCodes=[0,11,2,25,2,18,2,1,2,14,3,13,35,122,70,52,268,28,4,48,48,31,14,29,6,37,11,29,3,35,5,7,2,4,43,157,19,35,5,35,5,39,9,51,157,310,10,21,11,7,153,5,3,0,2,43,2,1,4,0,3,22,11,22,10,30,66,18,2,1,11,21,11,25,71,55,7,1,65,0,16,3,2,2,2,28,43,28,4,28,36,7,2,27,28,53,11,21,11,18,14,17,111,72,56,50,14,50,14,35,477,28,11,0,9,21,155,22,13,52,76,44,33,24,27,35,30,0,12,34,4,0,13,47,15,3,22,0,2,0,36,17,2,24,85,6,2,0,2,3,2,14,2,9,8,46,39,7,3,1,3,21,2,6,2,1,2,4,4,0,19,0,13,4,159,52,19,3,21,0,33,47,21,1,2,0,185,46,42,3,37,47,21,0,60,42,14,0,72,26,230,43,117,63,32,0,161,7,3,38,17,0,2,0,29,0,11,39,8,0,22,0,12,45,20,0,35,56,264,8,2,36,18,0,50,29,113,6,2,1,2,37,22,0,26,5,2,1,2,31,15,0,328,18,270,921,103,110,18,195,2749,1070,4050,582,8634,568,8,30,114,29,19,47,17,3,32,20,6,18,689,63,129,74,6,0,67,12,65,1,2,0,29,6135,9,754,9486,286,50,2,18,3,9,395,2309,106,6,12,4,8,8,9,5991,84,2,70,2,1,3,0,3,1,3,3,2,11,2,0,2,6,2,64,2,3,3,7,2,6,2,27,2,3,2,4,2,0,4,6,2,339,3,24,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,30,2,24,2,7,2357,44,11,6,17,0,370,43,1301,196,60,67,8,0,1205,3,2,26,2,1,2,0,3,0,2,9,2,3,2,0,2,0,7,0,5,0,2,0,2,0,2,2,2,1,2,0,3,0,2,0,2,0,2,0,2,0,2,1,2,0,3,3,2,6,2,3,2,3,2,0,2,9,2,16,6,2,2,4,2,16,4421,42710,42,4148,12,221,3,5761,15,7472,3104,541];

 var astralIdentifierCodes=[509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,166,1,574,3,9,9,525,10,176,2,54,14,32,9,16,3,46,10,54,9,7,2,37,13,2,9,6,1,45,0,13,2,49,13,9,3,4,9,83,11,7,0,161,11,6,9,7,3,56,1,2,6,3,1,3,2,10,0,11,1,3,6,4,4,193,17,10,9,5,0,82,19,13,9,214,6,3,8,28,1,83,16,16,9,82,12,9,9,84,14,5,9,243,14,166,9,232,6,3,6,4,0,29,9,41,6,2,3,9,0,10,10,47,15,406,7,2,7,17,9,57,21,2,13,123,5,4,0,2,1,2,6,2,0,9,9,49,4,2,1,2,4,9,9,330,3,19306,9,135,4,60,6,26,9,1014,0,2,54,8,3,19723,1,5319,4,4,5,9,7,3,6,31,3,149,2,1418,49,513,54,5,49,9,0,15,0,23,4,2,14,1361,6,2,16,3,6,2,1,2,4,262,6,10,9,419,13,1495,6,110,6,6,9,792487,239];

 function isInAstralSet(code,set) {
 var pos=0x10000;
 for (var i=0; i < set.length; i += 2) {
pos += set[i];
if (pos > code) { return false }
pos += set[i + 1];
if (pos >= code) { return true }
 }
 }


 function isIdentifierStart(code,astral) {
 if (code < 65) { return code === 36 }
 if (code < 91) { return true }
 if (code < 97) { return code === 95 }
 if (code < 123) { return true }
 if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code)) }
 if (astral === false) { return false }
 return isInAstralSet(code,astralIdentifierStartCodes)
 }


 function isIdentifierChar(code,astral) {
 if (code < 48) { return code === 36 }
 if (code < 58) { return true }
 if (code < 65) { return false }
 if (code < 91) { return true }
 if (code < 97) { return code === 95 }
 if (code < 123) { return true }
 if (code <= 0xffff) { return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code)) }
 if (astral === false) { return false }
 return isInAstralSet(code,astralIdentifierStartCodes) || isInAstralSet(code,astralIdentifierCodes)
 }





 var TokenType=function TokenType(label,conf) {
 if ( conf === void 0 ) conf={};

 this.label=label;
 this.keyword=conf.keyword;
 this.beforeExpr=!!conf.beforeExpr;
 this.startsExpr=!!conf.startsExpr;
 this.isLoop=!!conf.isLoop;
 this.isAssign=!!conf.isAssign;
 this.prefix=!!conf.prefix;
 this.postfix=!!conf.postfix;
 this.binop=conf.binop || null;
 this.updateContext=null;
 };

 function binop(name,prec) {
 return new TokenType(name,{beforeExpr: true,binop: prec})
 }
 var beforeExpr={beforeExpr: true},startsExpr={startsExpr: true};


 var keywords$1={};

 function kw(name,options) {
 if ( options === void 0 ) options={};

 options.keyword=name;
 return keywords$1[name]=new TokenType(name,options)
 }

 var types={
 num: new TokenType("num",startsExpr),
 regexp: new TokenType("regexp",startsExpr),
 string: new TokenType("string",startsExpr),
 name: new TokenType("name",startsExpr),
 eof: new TokenType("eof"),

 bracketL: new TokenType("[",{beforeExpr: true,startsExpr: true}),
 bracketR: new TokenType("]"),
 braceL: new TokenType("{",{beforeExpr: true,startsExpr: true}),
 braceR: new TokenType("}"),
 parenL: new TokenType("(",{beforeExpr: true,startsExpr: true}),
 parenR: new TokenType(")"),
 comma: new TokenType(",",beforeExpr),
 semi: new TokenType(";",beforeExpr),
 colon: new TokenType(":",beforeExpr),
 dot: new TokenType("."),
 question: new TokenType("?",beforeExpr),
 arrow: new TokenType("=>",beforeExpr),
 template: new TokenType("template"),
 invalidTemplate: new TokenType("invalidTemplate"),
 ellipsis: new TokenType("...",beforeExpr),
 backQuote: new TokenType("`",startsExpr),
 dollarBraceL: new TokenType("${",{beforeExpr: true,startsExpr: true}),


 eq: new TokenType("=",{beforeExpr: true,isAssign: true}),
 assign: new TokenType("_=",{beforeExpr: true,isAssign: true}),
 incDec: new TokenType("++/--",{prefix: true,postfix: true,startsExpr: true}),
 prefix: new TokenType("!/~",{beforeExpr: true,prefix: true,startsExpr: true}),
 logicalOR: binop("||",1),
 logicalAND: binop("&&",2),
 bitwiseOR: binop("|",3),
 bitwiseXOR: binop("^",4),
 bitwiseAND: binop("&",5),
 equality: binop("==/!=/===/!==",6),
 relational: binop("</>/<=/>=",7),
 bitShift: binop("<</>>/>>>",8),
 plusMin: new TokenType("+/-",{beforeExpr: true,binop: 9,prefix: true,startsExpr: true}),
 modulo: binop("%",10),
 star: binop("*",10),
 slash: binop("/",10),
 starstar: new TokenType("**",{beforeExpr: true}),

 _break: kw("break"),
 _case: kw("case",beforeExpr),
 _catch: kw("catch"),
 _continue: kw("continue"),
 _debugger: kw("debugger"),
 _default: kw("default",beforeExpr),
 _do: kw("do",{isLoop: true,beforeExpr: true}),
 _else: kw("else",beforeExpr),
 _finally: kw("finally"),
 _for: kw("for",{isLoop: true}),
 _function: kw("function",startsExpr),
 _if: kw("if"),
 _return: kw("return",beforeExpr),
 _switch: kw("switch"),
 _throw: kw("throw",beforeExpr),
 _try: kw("try"),
 _var: kw("var"),
 _const: kw("const"),
 _while: kw("while",{isLoop: true}),
 _with: kw("with"),
 _new: kw("new",{beforeExpr: true,startsExpr: true}),
 _this: kw("this",startsExpr),
 _super: kw("super",startsExpr),
 _class: kw("class",startsExpr),
 _extends: kw("extends",beforeExpr),
 _export: kw("export"),
 _import: kw("import",startsExpr),
 _null: kw("null",startsExpr),
 _true: kw("true",startsExpr),
 _false: kw("false",startsExpr),
 _in: kw("in",{beforeExpr: true,binop: 7}),
 _instanceof: kw("instanceof",{beforeExpr: true,binop: 7}),
 _typeof: kw("typeof",{beforeExpr: true,prefix: true,startsExpr: true}),
 _void: kw("void",{beforeExpr: true,prefix: true,startsExpr: true}),
 _delete: kw("delete",{beforeExpr: true,prefix: true,startsExpr: true})
 };


 var lineBreak=/\r\n?|\n|\u2028|\u2029/;
 var lineBreakG=new RegExp(lineBreak.source,"g");

 function isNewLine(code,ecma2019String) {
 return code === 10 || code === 13 || (!ecma2019String && (code === 0x2028 || code === 0x2029))
 }

 var nonASCIIwhitespace=/[\u1680\u2000-\u200a\u202f\u205f\u3000\ufeff]/;

 var skipWhiteSpace=/(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;

 var ref=Object.prototype;
 var hasOwnProperty=ref.hasOwnProperty;
 var toString=ref.toString;


 function has(obj,propName) {
 return hasOwnProperty.call(obj,propName)
 }

 var isArray=Array.isArray || (function (obj) { return (
 toString.call(obj) === "[object Array]"
 ); });

 function wordsRegexp(words) {
 return new RegExp("^(?:" + words.replace(/ /g,"|") + ")$")
 }


 var Position=function Position(line,col) {
 this.line=line;
 this.column=col;
 };

 Position.prototype.offset=function offset (n) {
 return new Position(this.line,this.column + n)
 };

 var SourceLocation=function SourceLocation(p,start,end) {
 this.start=start;
 this.end=end;
 if (p.sourceFile !== null) { this.source=p.sourceFile; }
 };


 function getLineInfo(input,offset) {
 for (var line=1,cur=0;;) {
lineBreakG.lastIndex=cur;
var match=lineBreakG.exec(input);
if (match && match.index < offset) {
++line;
cur=match.index + match[0].length;
} else {
return new Position(line,offset - cur)
}
 }
 }


 var defaultOptions={
 ecmaVersion: 10,
 sourceType: "script",
 onInsertedSemicolon: null,
 onTrailingComma: null,
 allowReserved: null,
 allowReturnOutsideFunction: false,
 allowImportExportEverywhere: false,
 allowAwaitOutsideFunction: false,
 allowHashBang: false,
 locations: false,
 onToken: null,
 onComment: null,
 ranges: false,
 program: null,
 sourceFile: null,
 directSourceFile: null,
 preserveParens: false
 };


 function getOptions(opts) {
 var options={};

 for (var opt in defaultOptions)
 { options[opt]=opts && has(opts,opt) ? opts[opt] : defaultOptions[opt]; }

 if (options.ecmaVersion >= 2015)
 { options.ecmaVersion -= 2009; }

 if (options.allowReserved == null)
 { options.allowReserved=options.ecmaVersion < 5; }

 if (isArray(options.onToken)) {
var tokens=options.onToken;
options.onToken=function (token) { return tokens.push(token); };
 }
 if (isArray(options.onComment))
 { options.onComment=pushComment(options,options.onComment); }

 return options
 }

 function pushComment(options,array) {
 return function(block,text,start,end,startLoc,endLoc) {
var comment={
type: block ? "Block" : "Line",
value: text,
start: start,
end: end
};
if (options.locations)
{ comment.loc=new SourceLocation(this,startLoc,endLoc); }
if (options.ranges)
{ comment.range=[start,end]; }
array.push(comment);
 }
 }

 var
 SCOPE_TOP=1,
 SCOPE_FUNCTION=2,
 SCOPE_VAR=SCOPE_TOP | SCOPE_FUNCTION,
 SCOPE_ASYNC=4,
 SCOPE_GENERATOR=8,
 SCOPE_ARROW=16,
 SCOPE_SIMPLE_CATCH=32,
 SCOPE_SUPER=64,
 SCOPE_DIRECT_SUPER=128;

 function functionFlags(async,generator) {
 return SCOPE_FUNCTION | (async ? SCOPE_ASYNC : 0) | (generator ? SCOPE_GENERATOR : 0)
 }

 var
 BIND_NONE=0,
 BIND_VAR=1,
 BIND_LEXICAL=2,
 BIND_FUNCTION=3,
 BIND_SIMPLE_CATCH=4,
 BIND_OUTSIDE=5;

 var Parser=function Parser(options,input,startPos) {
 this.options=options=getOptions(options);
 this.sourceFile=options.sourceFile;
 this.keywords=wordsRegexp(keywords[options.ecmaVersion >= 6 ? 6 : options.sourceType === "module" ? "5module" : 5]);
 var reserved="";
 if (options.allowReserved !== true) {
for (var v=options.ecmaVersion;; v--)
{ if (reserved=reservedWords[v]) { break } }
if (options.sourceType === "module") { reserved += " await"; }
 }
 this.reservedWords=wordsRegexp(reserved);
 var reservedStrict=(reserved ? reserved + " " : "") + reservedWords.strict;
 this.reservedWordsStrict=wordsRegexp(reservedStrict);
 this.reservedWordsStrictBind=wordsRegexp(reservedStrict + " " + reservedWords.strictBind);
 this.input=String(input);

 this.containsEsc=false;


 if (startPos) {
this.pos=startPos;
this.lineStart=this.input.lastIndexOf("\n",startPos - 1) + 1;
this.curLine=this.input.slice(0,this.lineStart).split(lineBreak).length;
 } else {
this.pos=this.lineStart=0;
this.curLine=1;
 }

 this.type=types.eof;
 this.value=null;
 this.start=this.end=this.pos;
 this.startLoc=this.endLoc=this.curPosition();

 this.lastTokEndLoc=this.lastTokStartLoc=null;
 this.lastTokStart=this.lastTokEnd=this.pos;

 this.context=this.initialContext();
 this.exprAllowed=true;

 this.inModule=options.sourceType === "module";
 this.strict=this.inModule || this.strictDirective(this.pos);

 this.potentialArrowAt=-1;

 this.yieldPos=this.awaitPos=this.awaitIdentPos=0;
 this.labels=[];
 this.undefinedExports={};

 if (this.pos === 0 && options.allowHashBang && this.input.slice(0,2) === "#!")
 { this.skipLineComment(2); }

 this.scopeStack=[];
 this.enterScope(SCOPE_TOP);

 this.regexpState=null;
 };

 var prototypeAccessors={ inFunction: { configurable: true },inGenerator: { configurable: true },inAsync: { configurable: true },allowSuper: { configurable: true },allowDirectSuper: { configurable: true },treatFunctionsAsVar: { configurable: true } };

 Parser.prototype.parse=function parse () {
 var node=this.options.program || this.startNode();
 this.nextToken();
 return this.parseTopLevel(node)
 };

 prototypeAccessors.inFunction.get=function () { return (this.currentVarScope().flags & SCOPE_FUNCTION) > 0 };
 prototypeAccessors.inGenerator.get=function () { return (this.currentVarScope().flags & SCOPE_GENERATOR) > 0 };
 prototypeAccessors.inAsync.get=function () { return (this.currentVarScope().flags & SCOPE_ASYNC) > 0 };
 prototypeAccessors.allowSuper.get=function () { return (this.currentThisScope().flags & SCOPE_SUPER) > 0 };
 prototypeAccessors.allowDirectSuper.get=function () { return (this.currentThisScope().flags & SCOPE_DIRECT_SUPER) > 0 };
 prototypeAccessors.treatFunctionsAsVar.get=function () { return this.treatFunctionsAsVarInScope(this.currentScope()) };

 Parser.prototype.inNonArrowFunction=function inNonArrowFunction () { return (this.currentThisScope().flags & SCOPE_FUNCTION) > 0 };

 Parser.extend=function extend () {
 var plugins=[],len=arguments.length;
 while ( len-- ) plugins[ len ]=arguments[ len ];

 var cls=this;
 for (var i=0; i < plugins.length; i++) { cls=plugins[i](cls); }
 return cls
 };

 Parser.parse=function parse (input,options) {
 return new this(options,input).parse()
 };

 Parser.parseExpressionAt=function parseExpressionAt (input,pos,options) {
 var parser=new this(options,input,pos);
 parser.nextToken();
 return parser.parseExpression()
 };

 Parser.tokenizer=function tokenizer (input,options) {
 return new this(options,input)
 };

 Object.defineProperties( Parser.prototype,prototypeAccessors );

 var pp=Parser.prototype;


 var literal=/^(?:'((?:\\.|[^'])*?)'|"((?:\\.|[^"])*?)")/;
 pp.strictDirective=function(start) {
 for (;;) {
skipWhiteSpace.lastIndex=start;
start += skipWhiteSpace.exec(this.input)[0].length;
var match=literal.exec(this.input.slice(start));
if (!match) { return false }
if ((match[1] || match[2]) === "use strict") { return true }
start += match[0].length;

skipWhiteSpace.lastIndex=start;
start += skipWhiteSpace.exec(this.input)[0].length;
if (this.input[start] === ";")
{ start++; }
 }
 };


 pp.eat=function(type) {
 if (this.type === type) {
this.next();
return true
 } else {
return false
 }
 };


 pp.isContextual=function(name) {
 return this.type === types.name && this.value === name && !this.containsEsc
 };


 pp.eatContextual=function(name) {
 if (!this.isContextual(name)) { return false }
 this.next();
 return true
 };


 pp.expectContextual=function(name) {
 if (!this.eatContextual(name)) { this.unexpected(); }
 };


 pp.canInsertSemicolon=function() {
 return this.type === types.eof ||
this.type === types.braceR ||
lineBreak.test(this.input.slice(this.lastTokEnd,this.start))
 };

 pp.insertSemicolon=function() {
 if (this.canInsertSemicolon()) {
if (this.options.onInsertedSemicolon)
{ this.options.onInsertedSemicolon(this.lastTokEnd,this.lastTokEndLoc); }
return true
 }
 };


 pp.semicolon=function() {
 if (!this.eat(types.semi) && !this.insertSemicolon()) { this.unexpected(); }
 };

 pp.afterTrailingComma=function(tokType,notNext) {
 if (this.type === tokType) {
if (this.options.onTrailingComma)
{ this.options.onTrailingComma(this.lastTokStart,this.lastTokStartLoc); }
if (!notNext)
{ this.next(); }
return true
 }
 };


 pp.expect=function(type) {
 this.eat(type) || this.unexpected();
 };


 pp.unexpected=function(pos) {
 this.raise(pos != null ? pos : this.start,"Unexpected token");
 };

 function DestructuringErrors() {
 this.shorthandAssign =
this.trailingComma =
this.parenthesizedAssign =
this.parenthesizedBind =
this.doubleProto =
 -1;
 }

 pp.checkPatternErrors=function(refDestructuringErrors,isAssign) {
 if (!refDestructuringErrors) { return }
 if (refDestructuringErrors.trailingComma > -1)
 { this.raiseRecoverable(refDestructuringErrors.trailingComma,"Comma is not permitted after the rest element"); }
 var parens=isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;
 if (parens > -1) { this.raiseRecoverable(parens,"Parenthesized pattern"); }
 };

 pp.checkExpressionErrors=function(refDestructuringErrors,andThrow) {
 if (!refDestructuringErrors) { return false }
 var shorthandAssign=refDestructuringErrors.shorthandAssign;
 var doubleProto=refDestructuringErrors.doubleProto;
 if (!andThrow) { return shorthandAssign >= 0 || doubleProto >= 0 }
 if (shorthandAssign >= 0)
 { this.raise(shorthandAssign,"Shorthand property assignments are valid only in destructuring patterns"); }
 if (doubleProto >= 0)
 { this.raiseRecoverable(doubleProto,"Redefinition of __proto__ property"); }
 };

 pp.checkYieldAwaitInDefaultParams=function() {
 if (this.yieldPos && (!this.awaitPos || this.yieldPos < this.awaitPos))
 { this.raise(this.yieldPos,"Yield expression cannot be a default value"); }
 if (this.awaitPos)
 { this.raise(this.awaitPos,"Await expression cannot be a default value"); }
 };

 pp.isSimpleAssignTarget=function(expr) {
 if (expr.type === "ParenthesizedExpression")
 { return this.isSimpleAssignTarget(expr.expression) }
 return expr.type === "Identifier" || expr.type === "MemberExpression"
 };

 var pp$1=Parser.prototype;



 pp$1.parseTopLevel=function(node) {
 var exports={};
 if (!node.body) { node.body=[]; }
 while (this.type !== types.eof) {
var stmt=this.parseStatement(null,true,exports);
node.body.push(stmt);
 }
 if (this.inModule)
 { for (var i=0,list=Object.keys(this.undefinedExports); i < list.length; i += 1)
 {
var name=list[i];

this.raiseRecoverable(this.undefinedExports[name].start,("Export '" + name + "' is not defined"));
 } }
 this.adaptDirectivePrologue(node.body);
 this.next();
 node.sourceType=this.options.sourceType;
 return this.finishNode(node,"Program")
 };

 var loopLabel={kind: "loop"},switchLabel={kind: "switch"};

 pp$1.isLet=function(context) {
 if (this.options.ecmaVersion < 6 || !this.isContextual("let")) { return false }
 skipWhiteSpace.lastIndex=this.pos;
 var skip=skipWhiteSpace.exec(this.input);
 var next=this.pos + skip[0].length,nextCh=this.input.charCodeAt(next);
 if (nextCh === 91) { return true }
 if (context) { return false }

 if (nextCh === 123) { return true }
 if (isIdentifierStart(nextCh,true)) {
var pos=next + 1;
while (isIdentifierChar(this.input.charCodeAt(pos),true)) { ++pos; }
var ident=this.input.slice(next,pos);
if (!keywordRelationalOperator.test(ident)) { return true }
 }
 return false
 };

 pp$1.isAsyncFunction=function() {
 if (this.options.ecmaVersion < 8 || !this.isContextual("async"))
 { return false }

 skipWhiteSpace.lastIndex=this.pos;
 var skip=skipWhiteSpace.exec(this.input);
 var next=this.pos + skip[0].length;
 return !lineBreak.test(this.input.slice(this.pos,next)) &&
this.input.slice(next,next + 8) === "function" &&
(next + 8 === this.input.length || !isIdentifierChar(this.input.charAt(next + 8)))
 };


 pp$1.parseStatement=function(context,topLevel,exports) {
 var starttype=this.type,node=this.startNode(),kind;

 if (this.isLet(context)) {
starttype=types._var;
kind="let";
 }


 switch (starttype) {
case types._break: case types._continue: return this.parseBreakContinueStatement(node,starttype.keyword)
case types._debugger: return this.parseDebuggerStatement(node)
case types._do: return this.parseDoStatement(node)
case types._for: return this.parseForStatement(node)
case types._function:
if ((context && (this.strict || context !== "if" && context !== "label")) && this.options.ecmaVersion >= 6) { this.unexpected(); }
return this.parseFunctionStatement(node,false,!context)
case types._class:
if (context) { this.unexpected(); }
return this.parseClass(node,true)
case types._if: return this.parseIfStatement(node)
case types._return: return this.parseReturnStatement(node)
case types._switch: return this.parseSwitchStatement(node)
case types._throw: return this.parseThrowStatement(node)
case types._try: return this.parseTryStatement(node)
case types._const: case types._var:
kind=kind || this.value;
if (context && kind !== "var") { this.unexpected(); }
return this.parseVarStatement(node,kind)
case types._while: return this.parseWhileStatement(node)
case types._with: return this.parseWithStatement(node)
case types.braceL: return this.parseBlock(true,node)
case types.semi: return this.parseEmptyStatement(node)
case types._export:
case types._import:
if (this.options.ecmaVersion > 10 && starttype === types._import) {
skipWhiteSpace.lastIndex=this.pos;
var skip=skipWhiteSpace.exec(this.input);
var next=this.pos + skip[0].length,nextCh=this.input.charCodeAt(next);
if (nextCh === 40)
{ return this.parseExpressionStatement(node,this.parseExpression()) }
}

if (!this.options.allowImportExportEverywhere) {
if (!topLevel)
{ this.raise(this.start,"'import' and 'export' may only appear at the top level"); }
if (!this.inModule)
{ this.raise(this.start,"'import' and 'export' may appear only with 'sourceType: module'"); }
}
return starttype === types._import ? this.parseImport(node) : this.parseExport(node,exports)

default:
if (this.isAsyncFunction()) {
if (context) { this.unexpected(); }
this.next();
return this.parseFunctionStatement(node,true,!context)
}

var maybeName=this.value,expr=this.parseExpression();
if (starttype === types.name && expr.type === "Identifier" && this.eat(types.colon))
{ return this.parseLabeledStatement(node,maybeName,expr,context) }
else { return this.parseExpressionStatement(node,expr) }
 }
 };

 pp$1.parseBreakContinueStatement=function(node,keyword) {
 var isBreak=keyword === "break";
 this.next();
 if (this.eat(types.semi) || this.insertSemicolon()) { node.label=null; }
 else if (this.type !== types.name) { this.unexpected(); }
 else {
node.label=this.parseIdent();
this.semicolon();
 }

 var i=0;
 for (; i < this.labels.length; ++i) {
var lab=this.labels[i];
if (node.label == null || lab.name === node.label.name) {
if (lab.kind != null && (isBreak || lab.kind === "loop")) { break }
if (node.label && isBreak) { break }
}
 }
 if (i === this.labels.length) { this.raise(node.start,"Unsyntactic " + keyword); }
 return this.finishNode(node,isBreak ? "BreakStatement" : "ContinueStatement")
 };

 pp$1.parseDebuggerStatement=function(node) {
 this.next();
 this.semicolon();
 return this.finishNode(node,"DebuggerStatement")
 };

 pp$1.parseDoStatement=function(node) {
 this.next();
 this.labels.push(loopLabel);
 node.body=this.parseStatement("do");
 this.labels.pop();
 this.expect(types._while);
 node.test=this.parseParenExpression();
 if (this.options.ecmaVersion >= 6)
 { this.eat(types.semi); }
 else
 { this.semicolon(); }
 return this.finishNode(node,"DoWhileStatement")
 };


 pp$1.parseForStatement=function(node) {
 this.next();
 var awaitAt=(this.options.ecmaVersion >= 9 && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction)) && this.eatContextual("await")) ? this.lastTokStart : -1;
 this.labels.push(loopLabel);
 this.enterScope(0);
 this.expect(types.parenL);
 if (this.type === types.semi) {
if (awaitAt > -1) { this.unexpected(awaitAt); }
return this.parseFor(node,null)
 }
 var isLet=this.isLet();
 if (this.type === types._var || this.type === types._const || isLet) {
var init$1=this.startNode(),kind=isLet ? "let" : this.value;
this.next();
this.parseVar(init$1,true,kind);
this.finishNode(init$1,"VariableDeclaration");
if ((this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init$1.declarations.length === 1) {
if (this.options.ecmaVersion >= 9) {
if (this.type === types._in) {
if (awaitAt > -1) { this.unexpected(awaitAt); }
} else { node.await=awaitAt > -1; }
}
return this.parseForIn(node,init$1)
}
if (awaitAt > -1) { this.unexpected(awaitAt); }
return this.parseFor(node,init$1)
 }
 var refDestructuringErrors=new DestructuringErrors;
 var init=this.parseExpression(true,refDestructuringErrors);
 if (this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
if (this.options.ecmaVersion >= 9) {
if (this.type === types._in) {
if (awaitAt > -1) { this.unexpected(awaitAt); }
} else { node.await=awaitAt > -1; }
}
this.toAssignable(init,false,refDestructuringErrors);
this.checkLVal(init);
return this.parseForIn(node,init)
 } else {
this.checkExpressionErrors(refDestructuringErrors,true);
 }
 if (awaitAt > -1) { this.unexpected(awaitAt); }
 return this.parseFor(node,init)
 };

 pp$1.parseFunctionStatement=function(node,isAsync,declarationPosition) {
 this.next();
 return this.parseFunction(node,FUNC_STATEMENT | (declarationPosition ? 0 : FUNC_HANGING_STATEMENT),false,isAsync)
 };

 pp$1.parseIfStatement=function(node) {
 this.next();
 node.test=this.parseParenExpression();
 node.consequent=this.parseStatement("if");
 node.alternate=this.eat(types._else) ? this.parseStatement("if") : null;
 return this.finishNode(node,"IfStatement")
 };

 pp$1.parseReturnStatement=function(node) {
 if (!this.inFunction && !this.options.allowReturnOutsideFunction)
 { this.raise(this.start,"'return' outside of function"); }
 this.next();


 if (this.eat(types.semi) || this.insertSemicolon()) { node.argument=null; }
 else { node.argument=this.parseExpression(); this.semicolon(); }
 return this.finishNode(node,"ReturnStatement")
 };

 pp$1.parseSwitchStatement=function(node) {
 this.next();
 node.discriminant=this.parseParenExpression();
 node.cases=[];
 this.expect(types.braceL);
 this.labels.push(switchLabel);
 this.enterScope(0);


 var cur;
 for (var sawDefault=false; this.type !== types.braceR;) {
if (this.type === types._case || this.type === types._default) {
var isCase=this.type === types._case;
if (cur) { this.finishNode(cur,"SwitchCase"); }
node.cases.push(cur=this.startNode());
cur.consequent=[];
this.next();
if (isCase) {
cur.test=this.parseExpression();
} else {
if (sawDefault) { this.raiseRecoverable(this.lastTokStart,"Multiple default clauses"); }
sawDefault=true;
cur.test=null;
}
this.expect(types.colon);
} else {
if (!cur) { this.unexpected(); }
cur.consequent.push(this.parseStatement(null));
}
 }
 this.exitScope();
 if (cur) { this.finishNode(cur,"SwitchCase"); }
 this.next();
 this.labels.pop();
 return this.finishNode(node,"SwitchStatement")
 };

 pp$1.parseThrowStatement=function(node) {
 this.next();
 if (lineBreak.test(this.input.slice(this.lastTokEnd,this.start)))
 { this.raise(this.lastTokEnd,"Illegal newline after throw"); }
 node.argument=this.parseExpression();
 this.semicolon();
 return this.finishNode(node,"ThrowStatement")
 };


 var empty=[];

 pp$1.parseTryStatement=function(node) {
 this.next();
 node.block=this.parseBlock();
 node.handler=null;
 if (this.type === types._catch) {
var clause=this.startNode();
this.next();
if (this.eat(types.parenL)) {
clause.param=this.parseBindingAtom();
var simple=clause.param.type === "Identifier";
this.enterScope(simple ? SCOPE_SIMPLE_CATCH : 0);
this.checkLVal(clause.param,simple ? BIND_SIMPLE_CATCH : BIND_LEXICAL);
this.expect(types.parenR);
} else {
if (this.options.ecmaVersion < 10) { this.unexpected(); }
clause.param=null;
this.enterScope(0);
}
clause.body=this.parseBlock(false);
this.exitScope();
node.handler=this.finishNode(clause,"CatchClause");
 }
 node.finalizer=this.eat(types._finally) ? this.parseBlock() : null;
 if (!node.handler && !node.finalizer)
 { this.raise(node.start,"Missing catch or finally clause"); }
 return this.finishNode(node,"TryStatement")
 };

 pp$1.parseVarStatement=function(node,kind) {
 this.next();
 this.parseVar(node,false,kind);
 this.semicolon();
 return this.finishNode(node,"VariableDeclaration")
 };

 pp$1.parseWhileStatement=function(node) {
 this.next();
 node.test=this.parseParenExpression();
 this.labels.push(loopLabel);
 node.body=this.parseStatement("while");
 this.labels.pop();
 return this.finishNode(node,"WhileStatement")
 };

 pp$1.parseWithStatement=function(node) {
 if (this.strict) { this.raise(this.start,"'with' in strict mode"); }
 this.next();
 node.object=this.parseParenExpression();
 node.body=this.parseStatement("with");
 return this.finishNode(node,"WithStatement")
 };

 pp$1.parseEmptyStatement=function(node) {
 this.next();
 return this.finishNode(node,"EmptyStatement")
 };

 pp$1.parseLabeledStatement=function(node,maybeName,expr,context) {
 for (var i$1=0,list=this.labels; i$1 < list.length; i$1 += 1)
 {
var label=list[i$1];

if (label.name === maybeName)
{ this.raise(expr.start,"Label '" + maybeName + "' is already declared");
} }
 var kind=this.type.isLoop ? "loop" : this.type === types._switch ? "switch" : null;
 for (var i=this.labels.length - 1; i >= 0; i--) {
var label$1=this.labels[i];
if (label$1.statementStart === node.start) {
label$1.statementStart=this.start;
label$1.kind=kind;
} else { break }
 }
 this.labels.push({name: maybeName,kind: kind,statementStart: this.start});
 node.body=this.parseStatement(context ? context.indexOf("label") === -1 ? context + "label" : context : "label");
 this.labels.pop();
 node.label=expr;
 return this.finishNode(node,"LabeledStatement")
 };

 pp$1.parseExpressionStatement=function(node,expr) {
 node.expression=expr;
 this.semicolon();
 return this.finishNode(node,"ExpressionStatement")
 };


 pp$1.parseBlock=function(createNewLexicalScope,node) {
 if ( createNewLexicalScope === void 0 ) createNewLexicalScope=true;
 if ( node === void 0 ) node=this.startNode();

 node.body=[];
 this.expect(types.braceL);
 if (createNewLexicalScope) { this.enterScope(0); }
 while (!this.eat(types.braceR)) {
var stmt=this.parseStatement(null);
node.body.push(stmt);
 }
 if (createNewLexicalScope) { this.exitScope(); }
 return this.finishNode(node,"BlockStatement")
 };


 pp$1.parseFor=function(node,init) {
 node.init=init;
 this.expect(types.semi);
 node.test=this.type === types.semi ? null : this.parseExpression();
 this.expect(types.semi);
 node.update=this.type === types.parenR ? null : this.parseExpression();
 this.expect(types.parenR);
 node.body=this.parseStatement("for");
 this.exitScope();
 this.labels.pop();
 return this.finishNode(node,"ForStatement")
 };


 pp$1.parseForIn=function(node,init) {
 var isForIn=this.type === types._in;
 this.next();

 if (
init.type === "VariableDeclaration" &&
init.declarations[0].init != null &&
(
!isForIn ||
this.options.ecmaVersion < 8 ||
this.strict ||
init.kind !== "var" ||
init.declarations[0].id.type !== "Identifier"
)
 ) {
this.raise(
init.start,
((isForIn ? "for-in" : "for-of") + " loop variable declaration may not have an initializer")
);
 } else if (init.type === "AssignmentPattern") {
this.raise(init.start,"Invalid left-hand side in for-loop");
 }
 node.left=init;
 node.right=isForIn ? this.parseExpression() : this.parseMaybeAssign();
 this.expect(types.parenR);
 node.body=this.parseStatement("for");
 this.exitScope();
 this.labels.pop();
 return this.finishNode(node,isForIn ? "ForInStatement" : "ForOfStatement")
 };


 pp$1.parseVar=function(node,isFor,kind) {
 node.declarations=[];
 node.kind=kind;
 for (;;) {
var decl=this.startNode();
this.parseVarId(decl,kind);
if (this.eat(types.eq)) {
decl.init=this.parseMaybeAssign(isFor);
} else if (kind === "const" && !(this.type === types._in || (this.options.ecmaVersion >= 6 && this.isContextual("of")))) {
this.unexpected();
} else if (decl.id.type !== "Identifier" && !(isFor && (this.type === types._in || this.isContextual("of")))) {
this.raise(this.lastTokEnd,"Complex binding patterns require an initialization value");
} else {
decl.init=null;
}
node.declarations.push(this.finishNode(decl,"VariableDeclarator"));
if (!this.eat(types.comma)) { break }
 }
 return node
 };

 pp$1.parseVarId=function(decl,kind) {
 decl.id=this.parseBindingAtom();
 this.checkLVal(decl.id,kind === "var" ? BIND_VAR : BIND_LEXICAL,false);
 };

 var FUNC_STATEMENT=1,FUNC_HANGING_STATEMENT=2,FUNC_NULLABLE_ID=4;


 pp$1.parseFunction=function(node,statement,allowExpressionBody,isAsync) {
 this.initFunction(node);
 if (this.options.ecmaVersion >= 9 || this.options.ecmaVersion >= 6 && !isAsync) {
if (this.type === types.star && (statement & FUNC_HANGING_STATEMENT))
{ this.unexpected(); }
node.generator=this.eat(types.star);
 }
 if (this.options.ecmaVersion >= 8)
 { node.async=!!isAsync; }

 if (statement & FUNC_STATEMENT) {
node.id=(statement & FUNC_NULLABLE_ID) && this.type !== types.name ? null : this.parseIdent();
if (node.id && !(statement & FUNC_HANGING_STATEMENT))
{ this.checkLVal(node.id,(this.strict || node.generator || node.async) ? this.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION); }
 }

 var oldYieldPos=this.yieldPos,oldAwaitPos=this.awaitPos,oldAwaitIdentPos=this.awaitIdentPos;
 this.yieldPos=0;
 this.awaitPos=0;
 this.awaitIdentPos=0;
 this.enterScope(functionFlags(node.async,node.generator));

 if (!(statement & FUNC_STATEMENT))
 { node.id=this.type === types.name ? this.parseIdent() : null; }

 this.parseFunctionParams(node);
 this.parseFunctionBody(node,allowExpressionBody,false);

 this.yieldPos=oldYieldPos;
 this.awaitPos=oldAwaitPos;
 this.awaitIdentPos=oldAwaitIdentPos;
 return this.finishNode(node,(statement & FUNC_STATEMENT) ? "FunctionDeclaration" : "FunctionExpression")
 };

 pp$1.parseFunctionParams=function(node) {
 this.expect(types.parenL);
 node.params=this.parseBindingList(types.parenR,false,this.options.ecmaVersion >= 8);
 this.checkYieldAwaitInDefaultParams();
 };


 pp$1.parseClass=function(node,isStatement) {
 this.next();

 var oldStrict=this.strict;
 this.strict=true;

 this.parseClassId(node,isStatement);
 this.parseClassSuper(node);
 var classBody=this.startNode();
 var hadConstructor=false;
 classBody.body=[];
 this.expect(types.braceL);
 while (!this.eat(types.braceR)) {
var element=this.parseClassElement(node.superClass !== null);
if (element) {
classBody.body.push(element);
if (element.type === "MethodDefinition" && element.kind === "constructor") {
if (hadConstructor) { this.raise(element.start,"Duplicate constructor in the same class"); }
hadConstructor=true;
}
}
 }
 node.body=this.finishNode(classBody,"ClassBody");
 this.strict=oldStrict;
 return this.finishNode(node,isStatement ? "ClassDeclaration" : "ClassExpression")
 };

 pp$1.parseClassElement=function(constructorAllowsSuper) {
 var this$1=this;

 if (this.eat(types.semi)) { return null }

 var method=this.startNode();
 var tryContextual=function (k,noLineBreak) {
if ( noLineBreak === void 0 ) noLineBreak=false;

var start=this$1.start,startLoc=this$1.startLoc;
if (!this$1.eatContextual(k)) { return false }
if (this$1.type !== types.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }
if (method.key) { this$1.unexpected(); }
method.computed=false;
method.key=this$1.startNodeAt(start,startLoc);
method.key.name=k;
this$1.finishNode(method.key,"Identifier");
return false
 };

 method.kind="method";
 method.static=tryContextual("static");
 var isGenerator=this.eat(types.star);
 var isAsync=false;
 if (!isGenerator) {
if (this.options.ecmaVersion >= 8 && tryContextual("async",true)) {
isAsync=true;
isGenerator=this.options.ecmaVersion >= 9 && this.eat(types.star);
} else if (tryContextual("get")) {
method.kind="get";
} else if (tryContextual("set")) {
method.kind="set";
}
 }
 if (!method.key) { this.parsePropertyName(method); }
 var key=method.key;
 var allowsDirectSuper=false;
 if (!method.computed && !method.static && (key.type === "Identifier" && key.name === "constructor" ||
key.type === "Literal" && key.value === "constructor")) {
if (method.kind !== "method") { this.raise(key.start,"Constructor can't have get/set modifier"); }
if (isGenerator) { this.raise(key.start,"Constructor can't be a generator"); }
if (isAsync) { this.raise(key.start,"Constructor can't be an async method"); }
method.kind="constructor";
allowsDirectSuper=constructorAllowsSuper;
 } else if (method.static && key.type === "Identifier" && key.name === "prototype") {
this.raise(key.start,"Classes may not have a static property named prototype");
 }
 this.parseClassMethod(method,isGenerator,isAsync,allowsDirectSuper);
 if (method.kind === "get" && method.value.params.length !== 0)
 { this.raiseRecoverable(method.value.start,"getter should have no params"); }
 if (method.kind === "set" && method.value.params.length !== 1)
 { this.raiseRecoverable(method.value.start,"setter should have exactly one param"); }
 if (method.kind === "set" && method.value.params[0].type === "RestElement")
 { this.raiseRecoverable(method.value.params[0].start,"Setter cannot use rest params"); }
 return method
 };

 pp$1.parseClassMethod=function(method,isGenerator,isAsync,allowsDirectSuper) {
 method.value=this.parseMethod(isGenerator,isAsync,allowsDirectSuper);
 return this.finishNode(method,"MethodDefinition")
 };

 pp$1.parseClassId=function(node,isStatement) {
 if (this.type === types.name) {
node.id=this.parseIdent();
if (isStatement)
{ this.checkLVal(node.id,BIND_LEXICAL,false); }
 } else {
if (isStatement === true)
{ this.unexpected(); }
node.id=null;
 }
 };

 pp$1.parseClassSuper=function(node) {
 node.superClass=this.eat(types._extends) ? this.parseExprSubscripts() : null;
 };


 pp$1.parseExport=function(node,exports) {
 this.next();
 if (this.eat(types.star)) {
this.expectContextual("from");
if (this.type !== types.string) { this.unexpected(); }
node.source=this.parseExprAtom();
this.semicolon();
return this.finishNode(node,"ExportAllDeclaration")
 }
 if (this.eat(types._default)) {
this.checkExport(exports,"default",this.lastTokStart);
var isAsync;
if (this.type === types._function || (isAsync=this.isAsyncFunction())) {
var fNode=this.startNode();
this.next();
if (isAsync) { this.next(); }
node.declaration=this.parseFunction(fNode,FUNC_STATEMENT | FUNC_NULLABLE_ID,false,isAsync);
} else if (this.type === types._class) {
var cNode=this.startNode();
node.declaration=this.parseClass(cNode,"nullableID");
} else {
node.declaration=this.parseMaybeAssign();
this.semicolon();
}
return this.finishNode(node,"ExportDefaultDeclaration")
 }
 if (this.shouldParseExportStatement()) {
node.declaration=this.parseStatement(null);
if (node.declaration.type === "VariableDeclaration")
{ this.checkVariableExport(exports,node.declaration.declarations); }
else
{ this.checkExport(exports,node.declaration.id.name,node.declaration.id.start); }
node.specifiers=[];
node.source=null;
 } else {
node.declaration=null;
node.specifiers=this.parseExportSpecifiers(exports);
if (this.eatContextual("from")) {
if (this.type !== types.string) { this.unexpected(); }
node.source=this.parseExprAtom();
} else {
for (var i=0,list=node.specifiers; i < list.length; i += 1) {
var spec=list[i];

this.checkUnreserved(spec.local);
this.checkLocalExport(spec.local);
}

node.source=null;
}
this.semicolon();
 }
 return this.finishNode(node,"ExportNamedDeclaration")
 };

 pp$1.checkExport=function(exports,name,pos) {
 if (!exports) { return }
 if (has(exports,name))
 { this.raiseRecoverable(pos,"Duplicate export '" + name + "'"); }
 exports[name]=true;
 };

 pp$1.checkPatternExport=function(exports,pat) {
 var type=pat.type;
 if (type === "Identifier")
 { this.checkExport(exports,pat.name,pat.start); }
 else if (type === "ObjectPattern")
 { for (var i=0,list=pat.properties; i < list.length; i += 1)
 {
var prop=list[i];

this.checkPatternExport(exports,prop);
 } }
 else if (type === "ArrayPattern")
 { for (var i$1=0,list$1=pat.elements; i$1 < list$1.length; i$1 += 1) {
var elt=list$1[i$1];

if (elt) { this.checkPatternExport(exports,elt); }
 } }
 else if (type === "Property")
 { this.checkPatternExport(exports,pat.value); }
 else if (type === "AssignmentPattern")
 { this.checkPatternExport(exports,pat.left); }
 else if (type === "RestElement")
 { this.checkPatternExport(exports,pat.argument); }
 else if (type === "ParenthesizedExpression")
 { this.checkPatternExport(exports,pat.expression); }
 };

 pp$1.checkVariableExport=function(exports,decls) {
 if (!exports) { return }
 for (var i=0,list=decls; i < list.length; i += 1)
 {
var decl=list[i];

this.checkPatternExport(exports,decl.id);
 }
 };

 pp$1.shouldParseExportStatement=function() {
 return this.type.keyword === "var" ||
this.type.keyword === "const" ||
this.type.keyword === "class" ||
this.type.keyword === "function" ||
this.isLet() ||
this.isAsyncFunction()
 };


 pp$1.parseExportSpecifiers=function(exports) {
 var nodes=[],first=true;
 this.expect(types.braceL);
 while (!this.eat(types.braceR)) {
if (!first) {
this.expect(types.comma);
if (this.afterTrailingComma(types.braceR)) { break }
} else { first=false; }

var node=this.startNode();
node.local=this.parseIdent(true);
node.exported=this.eatContextual("as") ? this.parseIdent(true) : node.local;
this.checkExport(exports,node.exported.name,node.exported.start);
nodes.push(this.finishNode(node,"ExportSpecifier"));
 }
 return nodes
 };


 pp$1.parseImport=function(node) {
 this.next();
 if (this.type === types.string) {
node.specifiers=empty;
node.source=this.parseExprAtom();
 } else {
node.specifiers=this.parseImportSpecifiers();
this.expectContextual("from");
node.source=this.type === types.string ? this.parseExprAtom() : this.unexpected();
 }
 this.semicolon();
 return this.finishNode(node,"ImportDeclaration")
 };


 pp$1.parseImportSpecifiers=function() {
 var nodes=[],first=true;
 if (this.type === types.name) {
var node=this.startNode();
node.local=this.parseIdent();
this.checkLVal(node.local,BIND_LEXICAL);
nodes.push(this.finishNode(node,"ImportDefaultSpecifier"));
if (!this.eat(types.comma)) { return nodes }
 }
 if (this.type === types.star) {
var node$1=this.startNode();
this.next();
this.expectContextual("as");
node$1.local=this.parseIdent();
this.checkLVal(node$1.local,BIND_LEXICAL);
nodes.push(this.finishNode(node$1,"ImportNamespaceSpecifier"));
return nodes
 }
 this.expect(types.braceL);
 while (!this.eat(types.braceR)) {
if (!first) {
this.expect(types.comma);
if (this.afterTrailingComma(types.braceR)) { break }
} else { first=false; }

var node$2=this.startNode();
node$2.imported=this.parseIdent(true);
if (this.eatContextual("as")) {
node$2.local=this.parseIdent();
} else {
this.checkUnreserved(node$2.imported);
node$2.local=node$2.imported;
}
this.checkLVal(node$2.local,BIND_LEXICAL);
nodes.push(this.finishNode(node$2,"ImportSpecifier"));
 }
 return nodes
 };

 pp$1.adaptDirectivePrologue=function(statements) {
 for (var i=0; i < statements.length && this.isDirectiveCandidate(statements[i]); ++i) {
statements[i].directive=statements[i].expression.raw.slice(1,-1);
 }
 };
 pp$1.isDirectiveCandidate=function(statement) {
 return (
statement.type === "ExpressionStatement" &&
statement.expression.type === "Literal" &&
typeof statement.expression.value === "string" &&
(this.input[statement.start] === "\"" || this.input[statement.start] === "'")
 )
 };

 var pp$2=Parser.prototype;


 pp$2.toAssignable=function(node,isBinding,refDestructuringErrors) {
 if (this.options.ecmaVersion >= 6 && node) {
switch (node.type) {
case "Identifier":
if (this.inAsync && node.name === "await")
{ this.raise(node.start,"Cannot use 'await' as identifier inside an async function"); }
break

case "ObjectPattern":
case "ArrayPattern":
case "RestElement":
break

case "ObjectExpression":
node.type="ObjectPattern";
if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors,true); }
for (var i=0,list=node.properties; i < list.length; i += 1) {
var prop=list[i];

this.toAssignable(prop,isBinding);
if (
 prop.type === "RestElement" &&
 (prop.argument.type === "ArrayPattern" || prop.argument.type === "ObjectPattern")
) {
 this.raise(prop.argument.start,"Unexpected token");
}
}
break

case "Property":
if (node.kind !== "init") { this.raise(node.key.start,"Object pattern can't contain getter or setter"); }
this.toAssignable(node.value,isBinding);
break

case "ArrayExpression":
node.type="ArrayPattern";
if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors,true); }
this.toAssignableList(node.elements,isBinding);
break

case "SpreadElement":
node.type="RestElement";
this.toAssignable(node.argument,isBinding);
if (node.argument.type === "AssignmentPattern")
{ this.raise(node.argument.start,"Rest elements cannot have a default value"); }
break

case "AssignmentExpression":
if (node.operator !== "=") { this.raise(node.left.end,"Only '=' operator can be used for specifying default value."); }
node.type="AssignmentPattern";
delete node.operator;
this.toAssignable(node.left,isBinding);

case "AssignmentPattern":
break

case "ParenthesizedExpression":
this.toAssignable(node.expression,isBinding,refDestructuringErrors);
break

case "MemberExpression":
if (!isBinding) { break }

default:
this.raise(node.start,"Assigning to rvalue");
}
 } else if (refDestructuringErrors) { this.checkPatternErrors(refDestructuringErrors,true); }
 return node
 };


 pp$2.toAssignableList=function(exprList,isBinding) {
 var end=exprList.length;
 for (var i=0; i < end; i++) {
var elt=exprList[i];
if (elt) { this.toAssignable(elt,isBinding); }
 }
 if (end) {
var last=exprList[end - 1];
if (this.options.ecmaVersion === 6 && isBinding && last && last.type === "RestElement" && last.argument.type !== "Identifier")
{ this.unexpected(last.argument.start); }
 }
 return exprList
 };


 pp$2.parseSpread=function(refDestructuringErrors) {
 var node=this.startNode();
 this.next();
 node.argument=this.parseMaybeAssign(false,refDestructuringErrors);
 return this.finishNode(node,"SpreadElement")
 };

 pp$2.parseRestBinding=function() {
 var node=this.startNode();
 this.next();

 if (this.options.ecmaVersion === 6 && this.type !== types.name)
 { this.unexpected(); }

 node.argument=this.parseBindingAtom();

 return this.finishNode(node,"RestElement")
 };


 pp$2.parseBindingAtom=function() {
 if (this.options.ecmaVersion >= 6) {
switch (this.type) {
case types.bracketL:
var node=this.startNode();
this.next();
node.elements=this.parseBindingList(types.bracketR,true,true);
return this.finishNode(node,"ArrayPattern")

case types.braceL:
return this.parseObj(true)
}
 }
 return this.parseIdent()
 };

 pp$2.parseBindingList=function(close,allowEmpty,allowTrailingComma) {
 var elts=[],first=true;
 while (!this.eat(close)) {
if (first) { first=false; }
else { this.expect(types.comma); }
if (allowEmpty && this.type === types.comma) {
elts.push(null);
} else if (allowTrailingComma && this.afterTrailingComma(close)) {
break
} else if (this.type === types.ellipsis) {
var rest=this.parseRestBinding();
this.parseBindingListItem(rest);
elts.push(rest);
if (this.type === types.comma) { this.raise(this.start,"Comma is not permitted after the rest element"); }
this.expect(close);
break
} else {
var elem=this.parseMaybeDefault(this.start,this.startLoc);
this.parseBindingListItem(elem);
elts.push(elem);
}
 }
 return elts
 };

 pp$2.parseBindingListItem=function(param) {
 return param
 };


 pp$2.parseMaybeDefault=function(startPos,startLoc,left) {
 left=left || this.parseBindingAtom();
 if (this.options.ecmaVersion < 6 || !this.eat(types.eq)) { return left }
 var node=this.startNodeAt(startPos,startLoc);
 node.left=left;
 node.right=this.parseMaybeAssign();
 return this.finishNode(node,"AssignmentPattern")
 };


 pp$2.checkLVal=function(expr,bindingType,checkClashes) {
 if ( bindingType === void 0 ) bindingType=BIND_NONE;

 switch (expr.type) {
case "Identifier":
if (bindingType === BIND_LEXICAL && expr.name === "let")
{ this.raiseRecoverable(expr.start,"let is disallowed as a lexically bound name"); }
if (this.strict && this.reservedWordsStrictBind.test(expr.name))
{ this.raiseRecoverable(expr.start,(bindingType ? "Binding " : "Assigning to ") + expr.name + " in strict mode"); }
if (checkClashes) {
if (has(checkClashes,expr.name))
{ this.raiseRecoverable(expr.start,"Argument name clash"); }
checkClashes[expr.name]=true;
}
if (bindingType !== BIND_NONE && bindingType !== BIND_OUTSIDE) { this.declareName(expr.name,bindingType,expr.start); }
break

case "MemberExpression":
if (bindingType) { this.raiseRecoverable(expr.start,"Binding member expression"); }
break

case "ObjectPattern":
for (var i=0,list=expr.properties; i < list.length; i += 1)
{
var prop=list[i];

this.checkLVal(prop,bindingType,checkClashes);
}
break

case "Property":
this.checkLVal(expr.value,bindingType,checkClashes);
break

case "ArrayPattern":
for (var i$1=0,list$1=expr.elements; i$1 < list$1.length; i$1 += 1) {
var elem=list$1[i$1];

if (elem) { this.checkLVal(elem,bindingType,checkClashes); }
}
break

case "AssignmentPattern":
this.checkLVal(expr.left,bindingType,checkClashes);
break

case "RestElement":
this.checkLVal(expr.argument,bindingType,checkClashes);
break

case "ParenthesizedExpression":
this.checkLVal(expr.expression,bindingType,checkClashes);
break

default:
this.raise(expr.start,(bindingType ? "Binding" : "Assigning to") + " rvalue");
 }
 };


 var pp$3=Parser.prototype;


 pp$3.checkPropClash=function(prop,propHash,refDestructuringErrors) {
 if (this.options.ecmaVersion >= 9 && prop.type === "SpreadElement")
 { return }
 if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))
 { return }
 var key=prop.key;
 var name;
 switch (key.type) {
case "Identifier": name=key.name; break
case "Literal": name=String(key.value); break
default: return
 }
 var kind=prop.kind;
 if (this.options.ecmaVersion >= 6) {
if (name === "__proto__" && kind === "init") {
if (propHash.proto) {
if (refDestructuringErrors) {
if (refDestructuringErrors.doubleProto < 0)
{ refDestructuringErrors.doubleProto=key.start; }
} else { this.raiseRecoverable(key.start,"Redefinition of __proto__ property"); }
}
propHash.proto=true;
}
return
 }
 name="$" + name;
 var other=propHash[name];
 if (other) {
var redefinition;
if (kind === "init") {
redefinition=this.strict && other.init || other.get || other.set;
} else {
redefinition=other.init || other[kind];
}
if (redefinition)
{ this.raiseRecoverable(key.start,"Redefinition of property"); }
 } else {
other=propHash[name]={
init: false,
get: false,
set: false
};
 }
 other[kind]=true;
 };




 pp$3.parseExpression=function(noIn,refDestructuringErrors) {
 var startPos=this.start,startLoc=this.startLoc;
 var expr=this.parseMaybeAssign(noIn,refDestructuringErrors);
 if (this.type === types.comma) {
var node=this.startNodeAt(startPos,startLoc);
node.expressions=[expr];
while (this.eat(types.comma)) { node.expressions.push(this.parseMaybeAssign(noIn,refDestructuringErrors)); }
return this.finishNode(node,"SequenceExpression")
 }
 return expr
 };


 pp$3.parseMaybeAssign=function(noIn,refDestructuringErrors,afterLeftParse) {
 if (this.isContextual("yield")) {
if (this.inGenerator) { return this.parseYield(noIn) }
else { this.exprAllowed=false; }
 }

 var ownDestructuringErrors=false,oldParenAssign=-1,oldTrailingComma=-1;
 if (refDestructuringErrors) {
oldParenAssign=refDestructuringErrors.parenthesizedAssign;
oldTrailingComma=refDestructuringErrors.trailingComma;
refDestructuringErrors.parenthesizedAssign=refDestructuringErrors.trailingComma=-1;
 } else {
refDestructuringErrors=new DestructuringErrors;
ownDestructuringErrors=true;
 }

 var startPos=this.start,startLoc=this.startLoc;
 if (this.type === types.parenL || this.type === types.name)
 { this.potentialArrowAt=this.start; }
 var left=this.parseMaybeConditional(noIn,refDestructuringErrors);
 if (afterLeftParse) { left=afterLeftParse.call(this,left,startPos,startLoc); }
 if (this.type.isAssign) {
var node=this.startNodeAt(startPos,startLoc);
node.operator=this.value;
node.left=this.type === types.eq ? this.toAssignable(left,false,refDestructuringErrors) : left;
if (!ownDestructuringErrors) {
refDestructuringErrors.parenthesizedAssign=refDestructuringErrors.trailingComma=refDestructuringErrors.doubleProto=-1;
}
if (refDestructuringErrors.shorthandAssign >= node.left.start)
{ refDestructuringErrors.shorthandAssign=-1; }
this.checkLVal(left);
this.next();
node.right=this.parseMaybeAssign(noIn);
return this.finishNode(node,"AssignmentExpression")
 } else {
if (ownDestructuringErrors) { this.checkExpressionErrors(refDestructuringErrors,true); }
 }
 if (oldParenAssign > -1) { refDestructuringErrors.parenthesizedAssign=oldParenAssign; }
 if (oldTrailingComma > -1) { refDestructuringErrors.trailingComma=oldTrailingComma; }
 return left
 };


 pp$3.parseMaybeConditional=function(noIn,refDestructuringErrors) {
 var startPos=this.start,startLoc=this.startLoc;
 var expr=this.parseExprOps(noIn,refDestructuringErrors);
 if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
 if (this.eat(types.question)) {
var node=this.startNodeAt(startPos,startLoc);
node.test=expr;
node.consequent=this.parseMaybeAssign();
this.expect(types.colon);
node.alternate=this.parseMaybeAssign(noIn);
return this.finishNode(node,"ConditionalExpression")
 }
 return expr
 };


 pp$3.parseExprOps=function(noIn,refDestructuringErrors) {
 var startPos=this.start,startLoc=this.startLoc;
 var expr=this.parseMaybeUnary(refDestructuringErrors,false);
 if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
 return expr.start === startPos && expr.type === "ArrowFunctionExpression" ? expr : this.parseExprOp(expr,startPos,startLoc,-1,noIn)
 };


 pp$3.parseExprOp=function(left,leftStartPos,leftStartLoc,minPrec,noIn) {
 var prec=this.type.binop;
 if (prec != null && (!noIn || this.type !== types._in)) {
if (prec > minPrec) {
var logical=this.type === types.logicalOR || this.type === types.logicalAND;
var op=this.value;
this.next();
var startPos=this.start,startLoc=this.startLoc;
var right=this.parseExprOp(this.parseMaybeUnary(null,false),startPos,startLoc,prec,noIn);
var node=this.buildBinary(leftStartPos,leftStartLoc,left,right,op,logical);
return this.parseExprOp(node,leftStartPos,leftStartLoc,minPrec,noIn)
}
 }
 return left
 };

 pp$3.buildBinary=function(startPos,startLoc,left,right,op,logical) {
 var node=this.startNodeAt(startPos,startLoc);
 node.left=left;
 node.operator=op;
 node.right=right;
 return this.finishNode(node,logical ? "LogicalExpression" : "BinaryExpression")
 };


 pp$3.parseMaybeUnary=function(refDestructuringErrors,sawUnary) {
 var startPos=this.start,startLoc=this.startLoc,expr;
 if (this.isContextual("await") && (this.inAsync || (!this.inFunction && this.options.allowAwaitOutsideFunction))) {
expr=this.parseAwait();
sawUnary=true;
 } else if (this.type.prefix) {
var node=this.startNode(),update=this.type === types.incDec;
node.operator=this.value;
node.prefix=true;
this.next();
node.argument=this.parseMaybeUnary(null,true);
this.checkExpressionErrors(refDestructuringErrors,true);
if (update) { this.checkLVal(node.argument); }
else if (this.strict && node.operator === "delete" &&
node.argument.type === "Identifier")
{ this.raiseRecoverable(node.start,"Deleting local variable in strict mode"); }
else { sawUnary=true; }
expr=this.finishNode(node,update ? "UpdateExpression" : "UnaryExpression");
 } else {
expr=this.parseExprSubscripts(refDestructuringErrors);
if (this.checkExpressionErrors(refDestructuringErrors)) { return expr }
while (this.type.postfix && !this.canInsertSemicolon()) {
var node$1=this.startNodeAt(startPos,startLoc);
node$1.operator=this.value;
node$1.prefix=false;
node$1.argument=expr;
this.checkLVal(expr);
this.next();
expr=this.finishNode(node$1,"UpdateExpression");
}
 }

 if (!sawUnary && this.eat(types.starstar))
 { return this.buildBinary(startPos,startLoc,expr,this.parseMaybeUnary(null,false),"**",false) }
 else
 { return expr }
 };


 pp$3.parseExprSubscripts=function(refDestructuringErrors) {
 var startPos=this.start,startLoc=this.startLoc;
 var expr=this.parseExprAtom(refDestructuringErrors);
 if (expr.type === "ArrowFunctionExpression" && this.input.slice(this.lastTokStart,this.lastTokEnd) !== ")")
 { return expr }
 var result=this.parseSubscripts(expr,startPos,startLoc);
 if (refDestructuringErrors && result.type === "MemberExpression") {
if (refDestructuringErrors.parenthesizedAssign >= result.start) { refDestructuringErrors.parenthesizedAssign=-1; }
if (refDestructuringErrors.parenthesizedBind >= result.start) { refDestructuringErrors.parenthesizedBind=-1; }
 }
 return result
 };

 pp$3.parseSubscripts=function(base,startPos,startLoc,noCalls) {
 var maybeAsyncArrow=this.options.ecmaVersion >= 8 && base.type === "Identifier" && base.name === "async" &&
this.lastTokEnd === base.end && !this.canInsertSemicolon() && this.input.slice(base.start,base.end) === "async";
 while (true) {
var element=this.parseSubscript(base,startPos,startLoc,noCalls,maybeAsyncArrow);
if (element === base || element.type === "ArrowFunctionExpression") { return element }
base=element;
 }
 };

 pp$3.parseSubscript=function(base,startPos,startLoc,noCalls,maybeAsyncArrow) {
 var computed=this.eat(types.bracketL);
 if (computed || this.eat(types.dot)) {
var node=this.startNodeAt(startPos,startLoc);
node.object=base;
node.property=computed ? this.parseExpression() : this.parseIdent(this.options.allowReserved !== "never");
node.computed=!!computed;
if (computed) { this.expect(types.bracketR); }
base=this.finishNode(node,"MemberExpression");
 } else if (!noCalls && this.eat(types.parenL)) {
var refDestructuringErrors=new DestructuringErrors,oldYieldPos=this.yieldPos,oldAwaitPos=this.awaitPos,oldAwaitIdentPos=this.awaitIdentPos;
this.yieldPos=0;
this.awaitPos=0;
this.awaitIdentPos=0;
var exprList=this.parseExprList(types.parenR,this.options.ecmaVersion >= 8,false,refDestructuringErrors);
if (maybeAsyncArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {
this.checkPatternErrors(refDestructuringErrors,false);
this.checkYieldAwaitInDefaultParams();
if (this.awaitIdentPos > 0)
{ this.raise(this.awaitIdentPos,"Cannot use 'await' as identifier inside an async function"); }
this.yieldPos=oldYieldPos;
this.awaitPos=oldAwaitPos;
this.awaitIdentPos=oldAwaitIdentPos;
return this.parseArrowExpression(this.startNodeAt(startPos,startLoc),exprList,true)
}
this.checkExpressionErrors(refDestructuringErrors,true);
this.yieldPos=oldYieldPos || this.yieldPos;
this.awaitPos=oldAwaitPos || this.awaitPos;
this.awaitIdentPos=oldAwaitIdentPos || this.awaitIdentPos;
var node$1=this.startNodeAt(startPos,startLoc);
node$1.callee=base;
node$1.arguments=exprList;
base=this.finishNode(node$1,"CallExpression");
 } else if (this.type === types.backQuote) {
var node$2=this.startNodeAt(startPos,startLoc);
node$2.tag=base;
node$2.quasi=this.parseTemplate({isTagged: true});
base=this.finishNode(node$2,"TaggedTemplateExpression");
 }
 return base
 };


 pp$3.parseExprAtom=function(refDestructuringErrors) {
 if (this.type === types.slash) { this.readRegexp(); }

 var node,canBeArrow=this.potentialArrowAt === this.start;
 switch (this.type) {
case types._super:
if (!this.allowSuper)
{ this.raise(this.start,"'super' keyword outside a method"); }
node=this.startNode();
this.next();
if (this.type === types.parenL && !this.allowDirectSuper)
{ this.raise(node.start,"super() call outside constructor of a subclass"); }
if (this.type !== types.dot && this.type !== types.bracketL && this.type !== types.parenL)
{ this.unexpected(); }
return this.finishNode(node,"Super")

case types._this:
node=this.startNode();
this.next();
return this.finishNode(node,"ThisExpression")

case types.name:
var startPos=this.start,startLoc=this.startLoc,containsEsc=this.containsEsc;
var id=this.parseIdent(false);
if (this.options.ecmaVersion >= 8 && !containsEsc && id.name === "async" && !this.canInsertSemicolon() && this.eat(types._function))
{ return this.parseFunction(this.startNodeAt(startPos,startLoc),0,false,true) }
if (canBeArrow && !this.canInsertSemicolon()) {
if (this.eat(types.arrow))
{ return this.parseArrowExpression(this.startNodeAt(startPos,startLoc),[id],false) }
if (this.options.ecmaVersion >= 8 && id.name === "async" && this.type === types.name && !containsEsc) {
id=this.parseIdent(false);
if (this.canInsertSemicolon() || !this.eat(types.arrow))
{ this.unexpected(); }
return this.parseArrowExpression(this.startNodeAt(startPos,startLoc),[id],true)
}
}
return id

case types.regexp:
var value=this.value;
node=this.parseLiteral(value.value);
node.regex={pattern: value.pattern,flags: value.flags};
return node

case types.num: case types.string:
return this.parseLiteral(this.value)

case types._null: case types._true: case types._false:
node=this.startNode();
node.value=this.type === types._null ? null : this.type === types._true;
node.raw=this.type.keyword;
this.next();
return this.finishNode(node,"Literal")

case types.parenL:
var start=this.start,expr=this.parseParenAndDistinguishExpression(canBeArrow);
if (refDestructuringErrors) {
if (refDestructuringErrors.parenthesizedAssign < 0 && !this.isSimpleAssignTarget(expr))
{ refDestructuringErrors.parenthesizedAssign=start; }
if (refDestructuringErrors.parenthesizedBind < 0)
{ refDestructuringErrors.parenthesizedBind=start; }
}
return expr

case types.bracketL:
node=this.startNode();
this.next();
node.elements=this.parseExprList(types.bracketR,true,true,refDestructuringErrors);
return this.finishNode(node,"ArrayExpression")

case types.braceL:
return this.parseObj(false,refDestructuringErrors)

case types._function:
node=this.startNode();
this.next();
return this.parseFunction(node,0)

case types._class:
return this.parseClass(this.startNode(),false)

case types._new:
return this.parseNew()

case types.backQuote:
return this.parseTemplate()

case types._import:
if (this.options.ecmaVersion >= 11) {
return this.parseExprImport()
} else {
return this.unexpected()
}

default:
this.unexpected();
 }
 };

 pp$3.parseExprImport=function() {
 var node=this.startNode();
 this.next();
 switch (this.type) {
case types.parenL:
return this.parseDynamicImport(node)
default:
this.unexpected();
 }
 };

 pp$3.parseDynamicImport=function(node) {
 this.next();

 node.source=this.parseMaybeAssign();

 if (!this.eat(types.parenR)) {
var errorPos=this.start;
if (this.eat(types.comma) && this.eat(types.parenR)) {
this.raiseRecoverable(errorPos,"Trailing comma is not allowed in import()");
} else {
this.unexpected(errorPos);
}
 }

 return this.finishNode(node,"ImportExpression")
 };

 pp$3.parseLiteral=function(value) {
 var node=this.startNode();
 node.value=value;
 node.raw=this.input.slice(this.start,this.end);
 if (node.raw.charCodeAt(node.raw.length - 1) === 110) { node.bigint=node.raw.slice(0,-1); }
 this.next();
 return this.finishNode(node,"Literal")
 };

 pp$3.parseParenExpression=function() {
 this.expect(types.parenL);
 var val=this.parseExpression();
 this.expect(types.parenR);
 return val
 };

 pp$3.parseParenAndDistinguishExpression=function(canBeArrow) {
 var startPos=this.start,startLoc=this.startLoc,val,allowTrailingComma=this.options.ecmaVersion >= 8;
 if (this.options.ecmaVersion >= 6) {
this.next();

var innerStartPos=this.start,innerStartLoc=this.startLoc;
var exprList=[],first=true,lastIsComma=false;
var refDestructuringErrors=new DestructuringErrors,oldYieldPos=this.yieldPos,oldAwaitPos=this.awaitPos,spreadStart;
this.yieldPos=0;
this.awaitPos=0;
while (this.type !== types.parenR) {
first ? first=false : this.expect(types.comma);
if (allowTrailingComma && this.afterTrailingComma(types.parenR,true)) {
lastIsComma=true;
break
} else if (this.type === types.ellipsis) {
spreadStart=this.start;
exprList.push(this.parseParenItem(this.parseRestBinding()));
if (this.type === types.comma) { this.raise(this.start,"Comma is not permitted after the rest element"); }
break
} else {
exprList.push(this.parseMaybeAssign(false,refDestructuringErrors,this.parseParenItem));
}
}
var innerEndPos=this.start,innerEndLoc=this.startLoc;
this.expect(types.parenR);

if (canBeArrow && !this.canInsertSemicolon() && this.eat(types.arrow)) {
this.checkPatternErrors(refDestructuringErrors,false);
this.checkYieldAwaitInDefaultParams();
this.yieldPos=oldYieldPos;
this.awaitPos=oldAwaitPos;
return this.parseParenArrowList(startPos,startLoc,exprList)
}

if (!exprList.length || lastIsComma) { this.unexpected(this.lastTokStart); }
if (spreadStart) { this.unexpected(spreadStart); }
this.checkExpressionErrors(refDestructuringErrors,true);
this.yieldPos=oldYieldPos || this.yieldPos;
this.awaitPos=oldAwaitPos || this.awaitPos;

if (exprList.length > 1) {
val=this.startNodeAt(innerStartPos,innerStartLoc);
val.expressions=exprList;
this.finishNodeAt(val,"SequenceExpression",innerEndPos,innerEndLoc);
} else {
val=exprList[0];
}
 } else {
val=this.parseParenExpression();
 }

 if (this.options.preserveParens) {
var par=this.startNodeAt(startPos,startLoc);
par.expression=val;
return this.finishNode(par,"ParenthesizedExpression")
 } else {
return val
 }
 };

 pp$3.parseParenItem=function(item) {
 return item
 };

 pp$3.parseParenArrowList=function(startPos,startLoc,exprList) {
 return this.parseArrowExpression(this.startNodeAt(startPos,startLoc),exprList)
 };


 var empty$1=[];

 pp$3.parseNew=function() {
 if (this.containsEsc) { this.raiseRecoverable(this.start,"Escape sequence in keyword new"); }
 var node=this.startNode();
 var meta=this.parseIdent(true);
 if (this.options.ecmaVersion >= 6 && this.eat(types.dot)) {
node.meta=meta;
var containsEsc=this.containsEsc;
node.property=this.parseIdent(true);
if (node.property.name !== "target" || containsEsc)
{ this.raiseRecoverable(node.property.start,"The only valid meta property for new is new.target"); }
if (!this.inNonArrowFunction())
{ this.raiseRecoverable(node.start,"new.target can only be used in functions"); }
return this.finishNode(node,"MetaProperty")
 }
 var startPos=this.start,startLoc=this.startLoc,isImport=this.type === types._import;
 node.callee=this.parseSubscripts(this.parseExprAtom(),startPos,startLoc,true);
 if (isImport && node.callee.type === "ImportExpression") {
this.raise(startPos,"Cannot use new with import()");
 }
 if (this.eat(types.parenL)) { node.arguments=this.parseExprList(types.parenR,this.options.ecmaVersion >= 8,false); }
 else { node.arguments=empty$1; }
 return this.finishNode(node,"NewExpression")
 };


 pp$3.parseTemplateElement=function(ref) {
 var isTagged=ref.isTagged;

 var elem=this.startNode();
 if (this.type === types.invalidTemplate) {
if (!isTagged) {
this.raiseRecoverable(this.start,"Bad escape sequence in untagged template literal");
}
elem.value={
raw: this.value,
cooked: null
};
 } else {
elem.value={
raw: this.input.slice(this.start,this.end).replace(/\r\n?/g,"\n"),
cooked: this.value
};
 }
 this.next();
 elem.tail=this.type === types.backQuote;
 return this.finishNode(elem,"TemplateElement")
 };

 pp$3.parseTemplate=function(ref) {
 if ( ref === void 0 ) ref={};
 var isTagged=ref.isTagged; if ( isTagged === void 0 ) isTagged=false;

 var node=this.startNode();
 this.next();
 node.expressions=[];
 var curElt=this.parseTemplateElement({isTagged: isTagged});
 node.quasis=[curElt];
 while (!curElt.tail) {
if (this.type === types.eof) { this.raise(this.pos,"Unterminated template literal"); }
this.expect(types.dollarBraceL);
node.expressions.push(this.parseExpression());
this.expect(types.braceR);
node.quasis.push(curElt=this.parseTemplateElement({isTagged: isTagged}));
 }
 this.next();
 return this.finishNode(node,"TemplateLiteral")
 };

 pp$3.isAsyncProp=function(prop) {
 return !prop.computed && prop.key.type === "Identifier" && prop.key.name === "async" &&
(this.type === types.name || this.type === types.num || this.type === types.string || this.type === types.bracketL || this.type.keyword || (this.options.ecmaVersion >= 9 && this.type === types.star)) &&
!lineBreak.test(this.input.slice(this.lastTokEnd,this.start))
 };


 pp$3.parseObj=function(isPattern,refDestructuringErrors) {
 var node=this.startNode(),first=true,propHash={};
 node.properties=[];
 this.next();
 while (!this.eat(types.braceR)) {
if (!first) {
this.expect(types.comma);
if (this.options.ecmaVersion >= 5 && this.afterTrailingComma(types.braceR)) { break }
} else { first=false; }

var prop=this.parseProperty(isPattern,refDestructuringErrors);
if (!isPattern) { this.checkPropClash(prop,propHash,refDestructuringErrors); }
node.properties.push(prop);
 }
 return this.finishNode(node,isPattern ? "ObjectPattern" : "ObjectExpression")
 };

 pp$3.parseProperty=function(isPattern,refDestructuringErrors) {
 var prop=this.startNode(),isGenerator,isAsync,startPos,startLoc;
 if (this.options.ecmaVersion >= 9 && this.eat(types.ellipsis)) {
if (isPattern) {
prop.argument=this.parseIdent(false);
if (this.type === types.comma) {
this.raise(this.start,"Comma is not permitted after the rest element");
}
return this.finishNode(prop,"RestElement")
}
if (this.type === types.parenL && refDestructuringErrors) {
if (refDestructuringErrors.parenthesizedAssign < 0) {
refDestructuringErrors.parenthesizedAssign=this.start;
}
if (refDestructuringErrors.parenthesizedBind < 0) {
refDestructuringErrors.parenthesizedBind=this.start;
}
}
prop.argument=this.parseMaybeAssign(false,refDestructuringErrors);
if (this.type === types.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {
refDestructuringErrors.trailingComma=this.start;
}
return this.finishNode(prop,"SpreadElement")
 }
 if (this.options.ecmaVersion >= 6) {
prop.method=false;
prop.shorthand=false;
if (isPattern || refDestructuringErrors) {
startPos=this.start;
startLoc=this.startLoc;
}
if (!isPattern)
{ isGenerator=this.eat(types.star); }
 }
 var containsEsc=this.containsEsc;
 this.parsePropertyName(prop);
 if (!isPattern && !containsEsc && this.options.ecmaVersion >= 8 && !isGenerator && this.isAsyncProp(prop)) {
isAsync=true;
isGenerator=this.options.ecmaVersion >= 9 && this.eat(types.star);
this.parsePropertyName(prop,refDestructuringErrors);
 } else {
isAsync=false;
 }
 this.parsePropertyValue(prop,isPattern,isGenerator,isAsync,startPos,startLoc,refDestructuringErrors,containsEsc);
 return this.finishNode(prop,"Property")
 };

 pp$3.parsePropertyValue=function(prop,isPattern,isGenerator,isAsync,startPos,startLoc,refDestructuringErrors,containsEsc) {
 if ((isGenerator || isAsync) && this.type === types.colon)
 { this.unexpected(); }

 if (this.eat(types.colon)) {
prop.value=isPattern ? this.parseMaybeDefault(this.start,this.startLoc) : this.parseMaybeAssign(false,refDestructuringErrors);
prop.kind="init";
 } else if (this.options.ecmaVersion >= 6 && this.type === types.parenL) {
if (isPattern) { this.unexpected(); }
prop.kind="init";
prop.method=true;
prop.value=this.parseMethod(isGenerator,isAsync);
 } else if (!isPattern && !containsEsc &&
this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
(prop.key.name === "get" || prop.key.name === "set") &&
(this.type !== types.comma && this.type !== types.braceR)) {
if (isGenerator || isAsync) { this.unexpected(); }
prop.kind=prop.key.name;
this.parsePropertyName(prop);
prop.value=this.parseMethod(false);
var paramCount=prop.kind === "get" ? 0 : 1;
if (prop.value.params.length !== paramCount) {
var start=prop.value.start;
if (prop.kind === "get")
{ this.raiseRecoverable(start,"getter should have no params"); }
else
{ this.raiseRecoverable(start,"setter should have exactly one param"); }
} else {
if (prop.kind === "set" && prop.value.params[0].type === "RestElement")
{ this.raiseRecoverable(prop.value.params[0].start,"Setter cannot use rest params"); }
}
 } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
if (isGenerator || isAsync) { this.unexpected(); }
this.checkUnreserved(prop.key);
if (prop.key.name === "await" && !this.awaitIdentPos)
{ this.awaitIdentPos=startPos; }
prop.kind="init";
if (isPattern) {
prop.value=this.parseMaybeDefault(startPos,startLoc,prop.key);
} else if (this.type === types.eq && refDestructuringErrors) {
if (refDestructuringErrors.shorthandAssign < 0)
{ refDestructuringErrors.shorthandAssign=this.start; }
prop.value=this.parseMaybeDefault(startPos,startLoc,prop.key);
} else {
prop.value=prop.key;
}
prop.shorthand=true;
 } else { this.unexpected(); }
 };

 pp$3.parsePropertyName=function(prop) {
 if (this.options.ecmaVersion >= 6) {
if (this.eat(types.bracketL)) {
prop.computed=true;
prop.key=this.parseMaybeAssign();
this.expect(types.bracketR);
return prop.key
} else {
prop.computed=false;
}
 }
 return prop.key=this.type === types.num || this.type === types.string ? this.parseExprAtom() : this.parseIdent(this.options.allowReserved !== "never")
 };


 pp$3.initFunction=function(node) {
 node.id=null;
 if (this.options.ecmaVersion >= 6) { node.generator=node.expression=false; }
 if (this.options.ecmaVersion >= 8) { node.async=false; }
 };


 pp$3.parseMethod=function(isGenerator,isAsync,allowDirectSuper) {
 var node=this.startNode(),oldYieldPos=this.yieldPos,oldAwaitPos=this.awaitPos,oldAwaitIdentPos=this.awaitIdentPos;

 this.initFunction(node);
 if (this.options.ecmaVersion >= 6)
 { node.generator=isGenerator; }
 if (this.options.ecmaVersion >= 8)
 { node.async=!!isAsync; }

 this.yieldPos=0;
 this.awaitPos=0;
 this.awaitIdentPos=0;
 this.enterScope(functionFlags(isAsync,node.generator) | SCOPE_SUPER | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));

 this.expect(types.parenL);
 node.params=this.parseBindingList(types.parenR,false,this.options.ecmaVersion >= 8);
 this.checkYieldAwaitInDefaultParams();
 this.parseFunctionBody(node,false,true);

 this.yieldPos=oldYieldPos;
 this.awaitPos=oldAwaitPos;
 this.awaitIdentPos=oldAwaitIdentPos;
 return this.finishNode(node,"FunctionExpression")
 };


 pp$3.parseArrowExpression=function(node,params,isAsync) {
 var oldYieldPos=this.yieldPos,oldAwaitPos=this.awaitPos,oldAwaitIdentPos=this.awaitIdentPos;

 this.enterScope(functionFlags(isAsync,false) | SCOPE_ARROW);
 this.initFunction(node);
 if (this.options.ecmaVersion >= 8) { node.async=!!isAsync; }

 this.yieldPos=0;
 this.awaitPos=0;
 this.awaitIdentPos=0;

 node.params=this.toAssignableList(params,true);
 this.parseFunctionBody(node,true,false);

 this.yieldPos=oldYieldPos;
 this.awaitPos=oldAwaitPos;
 this.awaitIdentPos=oldAwaitIdentPos;
 return this.finishNode(node,"ArrowFunctionExpression")
 };


 pp$3.parseFunctionBody=function(node,isArrowFunction,isMethod) {
 var isExpression=isArrowFunction && this.type !== types.braceL;
 var oldStrict=this.strict,useStrict=false;

 if (isExpression) {
node.body=this.parseMaybeAssign();
node.expression=true;
this.checkParams(node,false);
 } else {
var nonSimple=this.options.ecmaVersion >= 7 && !this.isSimpleParamList(node.params);
if (!oldStrict || nonSimple) {
useStrict=this.strictDirective(this.end);
if (useStrict && nonSimple)
{ this.raiseRecoverable(node.start,"Illegal 'use strict' directive in function with non-simple parameter list"); }
}
var oldLabels=this.labels;
this.labels=[];
if (useStrict) { this.strict=true; }

this.checkParams(node,!oldStrict && !useStrict && !isArrowFunction && !isMethod && this.isSimpleParamList(node.params));
node.body=this.parseBlock(false);
node.expression=false;
this.adaptDirectivePrologue(node.body.body);
this.labels=oldLabels;
 }
 this.exitScope();

 if (this.strict && node.id) { this.checkLVal(node.id,BIND_OUTSIDE); }
 this.strict=oldStrict;
 };

 pp$3.isSimpleParamList=function(params) {
 for (var i=0,list=params; i < list.length; i += 1)
 {
var param=list[i];

if (param.type !== "Identifier") { return false
} }
 return true
 };


 pp$3.checkParams=function(node,allowDuplicates) {
 var nameHash={};
 for (var i=0,list=node.params; i < list.length; i += 1)
 {
var param=list[i];

this.checkLVal(param,BIND_VAR,allowDuplicates ? null : nameHash);
 }
 };


 pp$3.parseExprList=function(close,allowTrailingComma,allowEmpty,refDestructuringErrors) {
 var elts=[],first=true;
 while (!this.eat(close)) {
if (!first) {
this.expect(types.comma);
if (allowTrailingComma && this.afterTrailingComma(close)) { break }
} else { first=false; }

var elt=(void 0);
if (allowEmpty && this.type === types.comma)
{ elt=null; }
else if (this.type === types.ellipsis) {
elt=this.parseSpread(refDestructuringErrors);
if (refDestructuringErrors && this.type === types.comma && refDestructuringErrors.trailingComma < 0)
{ refDestructuringErrors.trailingComma=this.start; }
} else {
elt=this.parseMaybeAssign(false,refDestructuringErrors);
}
elts.push(elt);
 }
 return elts
 };

 pp$3.checkUnreserved=function(ref) {
 var start=ref.start;
 var end=ref.end;
 var name=ref.name;

 if (this.inGenerator && name === "yield")
 { this.raiseRecoverable(start,"Cannot use 'yield' as identifier inside a generator"); }
 if (this.inAsync && name === "await")
 { this.raiseRecoverable(start,"Cannot use 'await' as identifier inside an async function"); }
 if (this.keywords.test(name))
 { this.raise(start,("Unexpected keyword '" + name + "'")); }
 if (this.options.ecmaVersion < 6 &&
this.input.slice(start,end).indexOf("\\") !== -1) { return }
 var re=this.strict ? this.reservedWordsStrict : this.reservedWords;
 if (re.test(name)) {
if (!this.inAsync && name === "await")
{ this.raiseRecoverable(start,"Cannot use keyword 'await' outside an async function"); }
this.raiseRecoverable(start,("The keyword '" + name + "' is reserved"));
 }
 };


 pp$3.parseIdent=function(liberal,isBinding) {
 var node=this.startNode();
 if (this.type === types.name) {
node.name=this.value;
 } else if (this.type.keyword) {
node.name=this.type.keyword;

if ((node.name === "class" || node.name === "function") &&
(this.lastTokEnd !== this.lastTokStart + 1 || this.input.charCodeAt(this.lastTokStart) !== 46)) {
this.context.pop();
}
 } else {
this.unexpected();
 }
 this.next(!!liberal);
 this.finishNode(node,"Identifier");
 if (!liberal) {
this.checkUnreserved(node);
if (node.name === "await" && !this.awaitIdentPos)
{ this.awaitIdentPos=node.start; }
 }
 return node
 };


 pp$3.parseYield=function(noIn) {
 if (!this.yieldPos) { this.yieldPos=this.start; }

 var node=this.startNode();
 this.next();
 if (this.type === types.semi || this.canInsertSemicolon() || (this.type !== types.star && !this.type.startsExpr)) {
node.delegate=false;
node.argument=null;
 } else {
node.delegate=this.eat(types.star);
node.argument=this.parseMaybeAssign(noIn);
 }
 return this.finishNode(node,"YieldExpression")
 };

 pp$3.parseAwait=function() {
 if (!this.awaitPos) { this.awaitPos=this.start; }

 var node=this.startNode();
 this.next();
 node.argument=this.parseMaybeUnary(null,false);
 return this.finishNode(node,"AwaitExpression")
 };

 var pp$4=Parser.prototype;


 pp$4.raise=function(pos,message) {
 var loc=getLineInfo(this.input,pos);
 message += " (" + loc.line + ":" + loc.column + ")";
 var err=new SyntaxError(message);
 err.pos=pos; err.loc=loc; err.raisedAt=this.pos;
 throw err
 };

 pp$4.raiseRecoverable=pp$4.raise;

 pp$4.curPosition=function() {
 if (this.options.locations) {
return new Position(this.curLine,this.pos - this.lineStart)
 }
 };

 var pp$5=Parser.prototype;

 var Scope=function Scope(flags) {
 this.flags=flags;
 this.var=[];
 this.lexical=[];
 this.functions=[];
 };


 pp$5.enterScope=function(flags) {
 this.scopeStack.push(new Scope(flags));
 };

 pp$5.exitScope=function() {
 this.scopeStack.pop();
 };

 pp$5.treatFunctionsAsVarInScope=function(scope) {
 return (scope.flags & SCOPE_FUNCTION) || !this.inModule && (scope.flags & SCOPE_TOP)
 };

 pp$5.declareName=function(name,bindingType,pos) {
 var redeclared=false;
 if (bindingType === BIND_LEXICAL) {
var scope=this.currentScope();
redeclared=scope.lexical.indexOf(name) > -1 || scope.functions.indexOf(name) > -1 || scope.var.indexOf(name) > -1;
scope.lexical.push(name);
if (this.inModule && (scope.flags & SCOPE_TOP))
{ delete this.undefinedExports[name]; }
 } else if (bindingType === BIND_SIMPLE_CATCH) {
var scope$1=this.currentScope();
scope$1.lexical.push(name);
 } else if (bindingType === BIND_FUNCTION) {
var scope$2=this.currentScope();
if (this.treatFunctionsAsVar)
{ redeclared=scope$2.lexical.indexOf(name) > -1; }
else
{ redeclared=scope$2.lexical.indexOf(name) > -1 || scope$2.var.indexOf(name) > -1; }
scope$2.functions.push(name);
 } else {
for (var i=this.scopeStack.length - 1; i >= 0; --i) {
var scope$3=this.scopeStack[i];
if (scope$3.lexical.indexOf(name) > -1 && !((scope$3.flags & SCOPE_SIMPLE_CATCH) && scope$3.lexical[0] === name) ||
!this.treatFunctionsAsVarInScope(scope$3) && scope$3.functions.indexOf(name) > -1) {
redeclared=true;
break
}
scope$3.var.push(name);
if (this.inModule && (scope$3.flags & SCOPE_TOP))
{ delete this.undefinedExports[name]; }
if (scope$3.flags & SCOPE_VAR) { break }
}
 }
 if (redeclared) { this.raiseRecoverable(pos,("Identifier '" + name + "' has already been declared")); }
 };

 pp$5.checkLocalExport=function(id) {
 if (this.scopeStack[0].lexical.indexOf(id.name) === -1 &&
this.scopeStack[0].var.indexOf(id.name) === -1) {
this.undefinedExports[id.name]=id;
 }
 };

 pp$5.currentScope=function() {
 return this.scopeStack[this.scopeStack.length - 1]
 };

 pp$5.currentVarScope=function() {
 for (var i=this.scopeStack.length - 1;; i--) {
var scope=this.scopeStack[i];
if (scope.flags & SCOPE_VAR) { return scope }
 }
 };

 pp$5.currentThisScope=function() {
 for (var i=this.scopeStack.length - 1;; i--) {
var scope=this.scopeStack[i];
if (scope.flags & SCOPE_VAR && !(scope.flags & SCOPE_ARROW)) { return scope }
 }
 };

 var Node=function Node(parser,pos,loc) {
 this.type="";
 this.start=pos;
 this.end=0;
 if (parser.options.locations)
 { this.loc=new SourceLocation(parser,loc); }
 if (parser.options.directSourceFile)
 { this.sourceFile=parser.options.directSourceFile; }
 if (parser.options.ranges)
 { this.range=[pos,0]; }
 };


 var pp$6=Parser.prototype;

 pp$6.startNode=function() {
 return new Node(this,this.start,this.startLoc)
 };

 pp$6.startNodeAt=function(pos,loc) {
 return new Node(this,pos,loc)
 };


 function finishNodeAt(node,type,pos,loc) {
 node.type=type;
 node.end=pos;
 if (this.options.locations)
 { node.loc.end=loc; }
 if (this.options.ranges)
 { node.range[1]=pos; }
 return node
 }

 pp$6.finishNode=function(node,type) {
 return finishNodeAt.call(this,node,type,this.lastTokEnd,this.lastTokEndLoc)
 };


 pp$6.finishNodeAt=function(node,type,pos,loc) {
 return finishNodeAt.call(this,node,type,pos,loc)
 };


 var TokContext=function TokContext(token,isExpr,preserveSpace,override,generator) {
 this.token=token;
 this.isExpr=!!isExpr;
 this.preserveSpace=!!preserveSpace;
 this.override=override;
 this.generator=!!generator;
 };

 var types$1={
 b_stat: new TokContext("{",false),
 b_expr: new TokContext("{",true),
 b_tmpl: new TokContext("${",false),
 p_stat: new TokContext("(",false),
 p_expr: new TokContext("(",true),
 q_tmpl: new TokContext("`",true,true,function (p) { return p.tryReadTemplateToken(); }),
 f_stat: new TokContext("function",false),
 f_expr: new TokContext("function",true),
 f_expr_gen: new TokContext("function",true,false,null,true),
 f_gen: new TokContext("function",false,false,null,true)
 };

 var pp$7=Parser.prototype;

 pp$7.initialContext=function() {
 return [types$1.b_stat]
 };

 pp$7.braceIsBlock=function(prevType) {
 var parent=this.curContext();
 if (parent === types$1.f_expr || parent === types$1.f_stat)
 { return true }
 if (prevType === types.colon && (parent === types$1.b_stat || parent === types$1.b_expr))
 { return !parent.isExpr }

 if (prevType === types._return || prevType === types.name && this.exprAllowed)
 { return lineBreak.test(this.input.slice(this.lastTokEnd,this.start)) }
 if (prevType === types._else || prevType === types.semi || prevType === types.eof || prevType === types.parenR || prevType === types.arrow)
 { return true }
 if (prevType === types.braceL)
 { return parent === types$1.b_stat }
 if (prevType === types._var || prevType === types._const || prevType === types.name)
 { return false }
 return !this.exprAllowed
 };

 pp$7.inGeneratorContext=function() {
 for (var i=this.context.length - 1; i >= 1; i--) {
var context=this.context[i];
if (context.token === "function")
{ return context.generator }
 }
 return false
 };

 pp$7.updateContext=function(prevType) {
 var update,type=this.type;
 if (type.keyword && prevType === types.dot)
 { this.exprAllowed=false; }
 else if (update=type.updateContext)
 { update.call(this,prevType); }
 else
 { this.exprAllowed=type.beforeExpr; }
 };


 types.parenR.updateContext=types.braceR.updateContext=function() {
 if (this.context.length === 1) {
this.exprAllowed=true;
return
 }
 var out=this.context.pop();
 if (out === types$1.b_stat && this.curContext().token === "function") {
out=this.context.pop();
 }
 this.exprAllowed=!out.isExpr;
 };

 types.braceL.updateContext=function(prevType) {
 this.context.push(this.braceIsBlock(prevType) ? types$1.b_stat : types$1.b_expr);
 this.exprAllowed=true;
 };

 types.dollarBraceL.updateContext=function() {
 this.context.push(types$1.b_tmpl);
 this.exprAllowed=true;
 };

 types.parenL.updateContext=function(prevType) {
 var statementParens=prevType === types._if || prevType === types._for || prevType === types._with || prevType === types._while;
 this.context.push(statementParens ? types$1.p_stat : types$1.p_expr);
 this.exprAllowed=true;
 };

 types.incDec.updateContext=function() {
 };

 types._function.updateContext=types._class.updateContext=function(prevType) {
 if (prevType.beforeExpr && prevType !== types.semi && prevType !== types._else &&
!(prevType === types._return && lineBreak.test(this.input.slice(this.lastTokEnd,this.start))) &&
!((prevType === types.colon || prevType === types.braceL) && this.curContext() === types$1.b_stat))
 { this.context.push(types$1.f_expr); }
 else
 { this.context.push(types$1.f_stat); }
 this.exprAllowed=false;
 };

 types.backQuote.updateContext=function() {
 if (this.curContext() === types$1.q_tmpl)
 { this.context.pop(); }
 else
 { this.context.push(types$1.q_tmpl); }
 this.exprAllowed=false;
 };

 types.star.updateContext=function(prevType) {
 if (prevType === types._function) {
var index=this.context.length - 1;
if (this.context[index] === types$1.f_expr)
{ this.context[index]=types$1.f_expr_gen; }
else
{ this.context[index]=types$1.f_gen; }
 }
 this.exprAllowed=true;
 };

 types.name.updateContext=function(prevType) {
 var allowed=false;
 if (this.options.ecmaVersion >= 6 && prevType !== types.dot) {
if (this.value === "of" && !this.exprAllowed ||
this.value === "yield" && this.inGeneratorContext())
{ allowed=true; }
 }
 this.exprAllowed=allowed;
 };


 var ecma9BinaryProperties="ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS";
 var ecma10BinaryProperties=ecma9BinaryProperties + " Extended_Pictographic";
 var ecma11BinaryProperties=ecma10BinaryProperties;
 var unicodeBinaryProperties={
 9: ecma9BinaryProperties,
 10: ecma10BinaryProperties,
 11: ecma11BinaryProperties
 };

 var unicodeGeneralCategoryValues="Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu";

 var ecma9ScriptValues="Adlam Adlm Ahom Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb";
 var ecma10ScriptValues=ecma9ScriptValues + " Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd";
 var ecma11ScriptValues=ecma10ScriptValues + " Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho";
 var unicodeScriptValues={
 9: ecma9ScriptValues,
 10: ecma10ScriptValues,
 11: ecma11ScriptValues
 };

 var data={};
 function buildUnicodeData(ecmaVersion) {
 var d=data[ecmaVersion]={
binary: wordsRegexp(unicodeBinaryProperties[ecmaVersion] + " " + unicodeGeneralCategoryValues),
nonBinary: {
General_Category: wordsRegexp(unicodeGeneralCategoryValues),
Script: wordsRegexp(unicodeScriptValues[ecmaVersion])
}
 };
 d.nonBinary.Script_Extensions=d.nonBinary.Script;

 d.nonBinary.gc=d.nonBinary.General_Category;
 d.nonBinary.sc=d.nonBinary.Script;
 d.nonBinary.scx=d.nonBinary.Script_Extensions;
 }
 buildUnicodeData(9);
 buildUnicodeData(10);
 buildUnicodeData(11);

 var pp$8=Parser.prototype;

 var RegExpValidationState=function RegExpValidationState(parser) {
 this.parser=parser;
 this.validFlags="gim" + (parser.options.ecmaVersion >= 6 ? "uy" : "") + (parser.options.ecmaVersion >= 9 ? "s" : "");
 this.unicodeProperties=data[parser.options.ecmaVersion >= 11 ? 11 : parser.options.ecmaVersion];
 this.source="";
 this.flags="";
 this.start=0;
 this.switchU=false;
 this.switchN=false;
 this.pos=0;
 this.lastIntValue=0;
 this.lastStringValue="";
 this.lastAssertionIsQuantifiable=false;
 this.numCapturingParens=0;
 this.maxBackReference=0;
 this.groupNames=[];
 this.backReferenceNames=[];
 };

 RegExpValidationState.prototype.reset=function reset (start,pattern,flags) {
 var unicode=flags.indexOf("u") !== -1;
 this.start=start | 0;
 this.source=pattern + "";
 this.flags=flags;
 this.switchU=unicode && this.parser.options.ecmaVersion >= 6;
 this.switchN=unicode && this.parser.options.ecmaVersion >= 9;
 };

 RegExpValidationState.prototype.raise=function raise (message) {
 this.parser.raiseRecoverable(this.start,("Invalid regular expression: /" + (this.source) + "/: " + message));
 };

 RegExpValidationState.prototype.at=function at (i) {
 var s=this.source;
 var l=s.length;
 if (i >= l) {
return -1
 }
 var c=s.charCodeAt(i);
 if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l) {
return c
 }
 var next=s.charCodeAt(i + 1);
 return next >= 0xDC00 && next <= 0xDFFF ? (c << 10) + next - 0x35FDC00 : c
 };

 RegExpValidationState.prototype.nextIndex=function nextIndex (i) {
 var s=this.source;
 var l=s.length;
 if (i >= l) {
return l
 }
 var c=s.charCodeAt(i),next;
 if (!this.switchU || c <= 0xD7FF || c >= 0xE000 || i + 1 >= l ||
(next=s.charCodeAt(i + 1)) < 0xDC00 || next > 0xDFFF) {
return i + 1
 }
 return i + 2
 };

 RegExpValidationState.prototype.current=function current () {
 return this.at(this.pos)
 };

 RegExpValidationState.prototype.lookahead=function lookahead () {
 return this.at(this.nextIndex(this.pos))
 };

 RegExpValidationState.prototype.advance=function advance () {
 this.pos=this.nextIndex(this.pos);
 };

 RegExpValidationState.prototype.eat=function eat (ch) {
 if (this.current() === ch) {
this.advance();
return true
 }
 return false
 };

 function codePointToString(ch) {
 if (ch <= 0xFFFF) { return String.fromCharCode(ch) }
 ch -= 0x10000;
 return String.fromCharCode((ch >> 10) + 0xD800,(ch & 0x03FF) + 0xDC00)
 }

 pp$8.validateRegExpFlags=function(state) {
 var validFlags=state.validFlags;
 var flags=state.flags;

 for (var i=0; i < flags.length; i++) {
var flag=flags.charAt(i);
if (validFlags.indexOf(flag) === -1) {
this.raise(state.start,"Invalid regular expression flag");
}
if (flags.indexOf(flag,i + 1) > -1) {
this.raise(state.start,"Duplicate regular expression flag");
}
 }
 };

 pp$8.validateRegExpPattern=function(state) {
 this.regexp_pattern(state);

 if (!state.switchN && this.options.ecmaVersion >= 9 && state.groupNames.length > 0) {
state.switchN=true;
this.regexp_pattern(state);
 }
 };

 pp$8.regexp_pattern=function(state) {
 state.pos=0;
 state.lastIntValue=0;
 state.lastStringValue="";
 state.lastAssertionIsQuantifiable=false;
 state.numCapturingParens=0;
 state.maxBackReference=0;
 state.groupNames.length=0;
 state.backReferenceNames.length=0;

 this.regexp_disjunction(state);

 if (state.pos !== state.source.length) {
if (state.eat(0x29 )) {
state.raise("Unmatched ')'");
}
if (state.eat(0x5D ) || state.eat(0x7D )) {
state.raise("Lone quantifier brackets");
}
 }
 if (state.maxBackReference > state.numCapturingParens) {
state.raise("Invalid escape");
 }
 for (var i=0,list=state.backReferenceNames; i < list.length; i += 1) {
var name=list[i];

if (state.groupNames.indexOf(name) === -1) {
state.raise("Invalid named capture referenced");
}
 }
 };

 pp$8.regexp_disjunction=function(state) {
 this.regexp_alternative(state);
 while (state.eat(0x7C )) {
this.regexp_alternative(state);
 }

 if (this.regexp_eatQuantifier(state,true)) {
state.raise("Nothing to repeat");
 }
 if (state.eat(0x7B )) {
state.raise("Lone quantifier brackets");
 }
 };

 pp$8.regexp_alternative=function(state) {
 while (state.pos < state.source.length && this.regexp_eatTerm(state))
 { }
 };

 pp$8.regexp_eatTerm=function(state) {
 if (this.regexp_eatAssertion(state)) {
if (state.lastAssertionIsQuantifiable && this.regexp_eatQuantifier(state)) {
if (state.switchU) {
state.raise("Invalid quantifier");
}
}
return true
 }

 if (state.switchU ? this.regexp_eatAtom(state) : this.regexp_eatExtendedAtom(state)) {
this.regexp_eatQuantifier(state);
return true
 }

 return false
 };

 pp$8.regexp_eatAssertion=function(state) {
 var start=state.pos;
 state.lastAssertionIsQuantifiable=false;

 if (state.eat(0x5E ) || state.eat(0x24 )) {
return true
 }

 if (state.eat(0x5C )) {
if (state.eat(0x42 ) || state.eat(0x62 )) {
return true
}
state.pos=start;
 }

 if (state.eat(0x28 ) && state.eat(0x3F )) {
var lookbehind=false;
if (this.options.ecmaVersion >= 9) {
lookbehind=state.eat(0x3C );
}
if (state.eat(0x3D ) || state.eat(0x21 )) {
this.regexp_disjunction(state);
if (!state.eat(0x29 )) {
state.raise("Unterminated group");
}
state.lastAssertionIsQuantifiable=!lookbehind;
return true
}
 }

 state.pos=start;
 return false
 };

 pp$8.regexp_eatQuantifier=function(state,noError) {
 if ( noError === void 0 ) noError=false;

 if (this.regexp_eatQuantifierPrefix(state,noError)) {
state.eat(0x3F );
return true
 }
 return false
 };

 pp$8.regexp_eatQuantifierPrefix=function(state,noError) {
 return (
state.eat(0x2A ) ||
state.eat(0x2B ) ||
state.eat(0x3F ) ||
this.regexp_eatBracedQuantifier(state,noError)
 )
 };
 pp$8.regexp_eatBracedQuantifier=function(state,noError) {
 var start=state.pos;
 if (state.eat(0x7B )) {
var min=0,max=-1;
if (this.regexp_eatDecimalDigits(state)) {
min=state.lastIntValue;
if (state.eat(0x2C ) && this.regexp_eatDecimalDigits(state)) {
max=state.lastIntValue;
}
if (state.eat(0x7D )) {
if (max !== -1 && max < min && !noError) {
state.raise("numbers out of order in {} quantifier");
}
return true
}
}
if (state.switchU && !noError) {
state.raise("Incomplete quantifier");
}
state.pos=start;
 }
 return false
 };

 pp$8.regexp_eatAtom=function(state) {
 return (
this.regexp_eatPatternCharacters(state) ||
state.eat(0x2E ) ||
this.regexp_eatReverseSolidusAtomEscape(state) ||
this.regexp_eatCharacterClass(state) ||
this.regexp_eatUncapturingGroup(state) ||
this.regexp_eatCapturingGroup(state)
 )
 };
 pp$8.regexp_eatReverseSolidusAtomEscape=function(state) {
 var start=state.pos;
 if (state.eat(0x5C )) {
if (this.regexp_eatAtomEscape(state)) {
return true
}
state.pos=start;
 }
 return false
 };
 pp$8.regexp_eatUncapturingGroup=function(state) {
 var start=state.pos;
 if (state.eat(0x28 )) {
if (state.eat(0x3F ) && state.eat(0x3A )) {
this.regexp_disjunction(state);
if (state.eat(0x29 )) {
return true
}
state.raise("Unterminated group");
}
state.pos=start;
 }
 return false
 };
 pp$8.regexp_eatCapturingGroup=function(state) {
 if (state.eat(0x28 )) {
if (this.options.ecmaVersion >= 9) {
this.regexp_groupSpecifier(state);
} else if (state.current() === 0x3F ) {
state.raise("Invalid group");
}
this.regexp_disjunction(state);
if (state.eat(0x29 )) {
state.numCapturingParens += 1;
return true
}
state.raise("Unterminated group");
 }
 return false
 };

 pp$8.regexp_eatExtendedAtom=function(state) {
 return (
state.eat(0x2E ) ||
this.regexp_eatReverseSolidusAtomEscape(state) ||
this.regexp_eatCharacterClass(state) ||
this.regexp_eatUncapturingGroup(state) ||
this.regexp_eatCapturingGroup(state) ||
this.regexp_eatInvalidBracedQuantifier(state) ||
this.regexp_eatExtendedPatternCharacter(state)
 )
 };

 pp$8.regexp_eatInvalidBracedQuantifier=function(state) {
 if (this.regexp_eatBracedQuantifier(state,true)) {
state.raise("Nothing to repeat");
 }
 return false
 };

 pp$8.regexp_eatSyntaxCharacter=function(state) {
 var ch=state.current();
 if (isSyntaxCharacter(ch)) {
state.lastIntValue=ch;
state.advance();
return true
 }
 return false
 };
 function isSyntaxCharacter(ch) {
 return (
ch === 0x24 ||
ch >= 0x28 && ch <= 0x2B ||
ch === 0x2E ||
ch === 0x3F ||
ch >= 0x5B && ch <= 0x5E ||
ch >= 0x7B && ch <= 0x7D
 )
 }

 pp$8.regexp_eatPatternCharacters=function(state) {
 var start=state.pos;
 var ch=0;
 while ((ch=state.current()) !== -1 && !isSyntaxCharacter(ch)) {
state.advance();
 }
 return state.pos !== start
 };

 pp$8.regexp_eatExtendedPatternCharacter=function(state) {
 var ch=state.current();
 if (
ch !== -1 &&
ch !== 0x24 &&
!(ch >= 0x28 && ch <= 0x2B ) &&
ch !== 0x2E &&
ch !== 0x3F &&
ch !== 0x5B &&
ch !== 0x5E &&
ch !== 0x7C
 ) {
state.advance();
return true
 }
 return false
 };

 pp$8.regexp_groupSpecifier=function(state) {
 if (state.eat(0x3F )) {
if (this.regexp_eatGroupName(state)) {
if (state.groupNames.indexOf(state.lastStringValue) !== -1) {
state.raise("Duplicate capture group name");
}
state.groupNames.push(state.lastStringValue);
return
}
state.raise("Invalid group");
 }
 };

 pp$8.regexp_eatGroupName=function(state) {
 state.lastStringValue="";
 if (state.eat(0x3C )) {
if (this.regexp_eatRegExpIdentifierName(state) && state.eat(0x3E )) {
return true
}
state.raise("Invalid capture group name");
 }
 return false
 };

 pp$8.regexp_eatRegExpIdentifierName=function(state) {
 state.lastStringValue="";
 if (this.regexp_eatRegExpIdentifierStart(state)) {
state.lastStringValue += codePointToString(state.lastIntValue);
while (this.regexp_eatRegExpIdentifierPart(state)) {
state.lastStringValue += codePointToString(state.lastIntValue);
}
return true
 }
 return false
 };

 pp$8.regexp_eatRegExpIdentifierStart=function(state) {
 var start=state.pos;
 var ch=state.current();
 state.advance();

 if (ch === 0x5C && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {
ch=state.lastIntValue;
 }
 if (isRegExpIdentifierStart(ch)) {
state.lastIntValue=ch;
return true
 }

 state.pos=start;
 return false
 };
 function isRegExpIdentifierStart(ch) {
 return isIdentifierStart(ch,true) || ch === 0x24 || ch === 0x5F
 }

 pp$8.regexp_eatRegExpIdentifierPart=function(state) {
 var start=state.pos;
 var ch=state.current();
 state.advance();

 if (ch === 0x5C && this.regexp_eatRegExpUnicodeEscapeSequence(state)) {
ch=state.lastIntValue;
 }
 if (isRegExpIdentifierPart(ch)) {
state.lastIntValue=ch;
return true
 }

 state.pos=start;
 return false
 };
 function isRegExpIdentifierPart(ch) {
 return isIdentifierChar(ch,true) || ch === 0x24 || ch === 0x5F || ch === 0x200C || ch === 0x200D
 }

 pp$8.regexp_eatAtomEscape=function(state) {
 if (
this.regexp_eatBackReference(state) ||
this.regexp_eatCharacterClassEscape(state) ||
this.regexp_eatCharacterEscape(state) ||
(state.switchN && this.regexp_eatKGroupName(state))
 ) {
return true
 }
 if (state.switchU) {
if (state.current() === 0x63 ) {
state.raise("Invalid unicode escape");
}
state.raise("Invalid escape");
 }
 return false
 };
 pp$8.regexp_eatBackReference=function(state) {
 var start=state.pos;
 if (this.regexp_eatDecimalEscape(state)) {
var n=state.lastIntValue;
if (state.switchU) {
if (n > state.maxBackReference) {
state.maxBackReference=n;
}
return true
}
if (n <= state.numCapturingParens) {
return true
}
state.pos=start;
 }
 return false
 };
 pp$8.regexp_eatKGroupName=function(state) {
 if (state.eat(0x6B )) {
if (this.regexp_eatGroupName(state)) {
state.backReferenceNames.push(state.lastStringValue);
return true
}
state.raise("Invalid named reference");
 }
 return false
 };

 pp$8.regexp_eatCharacterEscape=function(state) {
 return (
this.regexp_eatControlEscape(state) ||
this.regexp_eatCControlLetter(state) ||
this.regexp_eatZero(state) ||
this.regexp_eatHexEscapeSequence(state) ||
this.regexp_eatRegExpUnicodeEscapeSequence(state) ||
(!state.switchU && this.regexp_eatLegacyOctalEscapeSequence(state)) ||
this.regexp_eatIdentityEscape(state)
 )
 };
 pp$8.regexp_eatCControlLetter=function(state) {
 var start=state.pos;
 if (state.eat(0x63 )) {
if (this.regexp_eatControlLetter(state)) {
return true
}
state.pos=start;
 }
 return false
 };
 pp$8.regexp_eatZero=function(state) {
 if (state.current() === 0x30 && !isDecimalDigit(state.lookahead())) {
state.lastIntValue=0;
state.advance();
return true
 }
 return false
 };

 pp$8.regexp_eatControlEscape=function(state) {
 var ch=state.current();
 if (ch === 0x74 ) {
state.lastIntValue=0x09;
state.advance();
return true
 }
 if (ch === 0x6E ) {
state.lastIntValue=0x0A;
state.advance();
return true
 }
 if (ch === 0x76 ) {
state.lastIntValue=0x0B;
state.advance();
return true
 }
 if (ch === 0x66 ) {
state.lastIntValue=0x0C;
state.advance();
return true
 }
 if (ch === 0x72 ) {
state.lastIntValue=0x0D;
state.advance();
return true
 }
 return false
 };

 pp$8.regexp_eatControlLetter=function(state) {
 var ch=state.current();
 if (isControlLetter(ch)) {
state.lastIntValue=ch % 0x20;
state.advance();
return true
 }
 return false
 };
 function isControlLetter(ch) {
 return (
(ch >= 0x41 && ch <= 0x5A ) ||
(ch >= 0x61 && ch <= 0x7A )
 )
 }

 pp$8.regexp_eatRegExpUnicodeEscapeSequence=function(state) {
 var start=state.pos;

 if (state.eat(0x75 )) {
if (this.regexp_eatFixedHexDigits(state,4)) {
var lead=state.lastIntValue;
if (state.switchU && lead >= 0xD800 && lead <= 0xDBFF) {
var leadSurrogateEnd=state.pos;
if (state.eat(0x5C ) && state.eat(0x75 ) && this.regexp_eatFixedHexDigits(state,4)) {
var trail=state.lastIntValue;
if (trail >= 0xDC00 && trail <= 0xDFFF) {
 state.lastIntValue=(lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
 return true
}
}
state.pos=leadSurrogateEnd;
state.lastIntValue=lead;
}
return true
}
if (
state.switchU &&
state.eat(0x7B ) &&
this.regexp_eatHexDigits(state) &&
state.eat(0x7D ) &&
isValidUnicode(state.lastIntValue)
) {
return true
}
if (state.switchU) {
state.raise("Invalid unicode escape");
}
state.pos=start;
 }

 return false
 };
 function isValidUnicode(ch) {
 return ch >= 0 && ch <= 0x10FFFF
 }

 pp$8.regexp_eatIdentityEscape=function(state) {
 if (state.switchU) {
if (this.regexp_eatSyntaxCharacter(state)) {
return true
}
if (state.eat(0x2F )) {
state.lastIntValue=0x2F;
return true
}
return false
 }

 var ch=state.current();
 if (ch !== 0x63 && (!state.switchN || ch !== 0x6B )) {
state.lastIntValue=ch;
state.advance();
return true
 }

 return false
 };

 pp$8.regexp_eatDecimalEscape=function(state) {
 state.lastIntValue=0;
 var ch=state.current();
 if (ch >= 0x31 && ch <= 0x39 ) {
do {
state.lastIntValue=10 * state.lastIntValue + (ch - 0x30 );
state.advance();
} while ((ch=state.current()) >= 0x30 && ch <= 0x39 )
return true
 }
 return false
 };

 pp$8.regexp_eatCharacterClassEscape=function(state) {
 var ch=state.current();

 if (isCharacterClassEscape(ch)) {
state.lastIntValue=-1;
state.advance();
return true
 }

 if (
state.switchU &&
this.options.ecmaVersion >= 9 &&
(ch === 0x50 || ch === 0x70 )
 ) {
state.lastIntValue=-1;
state.advance();
if (
state.eat(0x7B ) &&
this.regexp_eatUnicodePropertyValueExpression(state) &&
state.eat(0x7D )
) {
return true
}
state.raise("Invalid property name");
 }

 return false
 };
 function isCharacterClassEscape(ch) {
 return (
ch === 0x64 ||
ch === 0x44 ||
ch === 0x73 ||
ch === 0x53 ||
ch === 0x77 ||
ch === 0x57
 )
 }

 pp$8.regexp_eatUnicodePropertyValueExpression=function(state) {
 var start=state.pos;

 if (this.regexp_eatUnicodePropertyName(state) && state.eat(0x3D )) {
var name=state.lastStringValue;
if (this.regexp_eatUnicodePropertyValue(state)) {
var value=state.lastStringValue;
this.regexp_validateUnicodePropertyNameAndValue(state,name,value);
return true
}
 }
 state.pos=start;

 if (this.regexp_eatLoneUnicodePropertyNameOrValue(state)) {
var nameOrValue=state.lastStringValue;
this.regexp_validateUnicodePropertyNameOrValue(state,nameOrValue);
return true
 }
 return false
 };
 pp$8.regexp_validateUnicodePropertyNameAndValue=function(state,name,value) {
 if (!has(state.unicodeProperties.nonBinary,name))
 { state.raise("Invalid property name"); }
 if (!state.unicodeProperties.nonBinary[name].test(value))
 { state.raise("Invalid property value"); }
 };
 pp$8.regexp_validateUnicodePropertyNameOrValue=function(state,nameOrValue) {
 if (!state.unicodeProperties.binary.test(nameOrValue))
 { state.raise("Invalid property name"); }
 };

 pp$8.regexp_eatUnicodePropertyName=function(state) {
 var ch=0;
 state.lastStringValue="";
 while (isUnicodePropertyNameCharacter(ch=state.current())) {
state.lastStringValue += codePointToString(ch);
state.advance();
 }
 return state.lastStringValue !== ""
 };
 function isUnicodePropertyNameCharacter(ch) {
 return isControlLetter(ch) || ch === 0x5F
 }

 pp$8.regexp_eatUnicodePropertyValue=function(state) {
 var ch=0;
 state.lastStringValue="";
 while (isUnicodePropertyValueCharacter(ch=state.current())) {
state.lastStringValue += codePointToString(ch);
state.advance();
 }
 return state.lastStringValue !== ""
 };
 function isUnicodePropertyValueCharacter(ch) {
 return isUnicodePropertyNameCharacter(ch) || isDecimalDigit(ch)
 }

 pp$8.regexp_eatLoneUnicodePropertyNameOrValue=function(state) {
 return this.regexp_eatUnicodePropertyValue(state)
 };

 pp$8.regexp_eatCharacterClass=function(state) {
 if (state.eat(0x5B )) {
state.eat(0x5E );
this.regexp_classRanges(state);
if (state.eat(0x5D )) {
return true
}
state.raise("Unterminated character class");
 }
 return false
 };

 pp$8.regexp_classRanges=function(state) {
 while (this.regexp_eatClassAtom(state)) {
var left=state.lastIntValue;
if (state.eat(0x2D ) && this.regexp_eatClassAtom(state)) {
var right=state.lastIntValue;
if (state.switchU && (left === -1 || right === -1)) {
state.raise("Invalid character class");
}
if (left !== -1 && right !== -1 && left > right) {
state.raise("Range out of order in character class");
}
}
 }
 };

 pp$8.regexp_eatClassAtom=function(state) {
 var start=state.pos;

 if (state.eat(0x5C )) {
if (this.regexp_eatClassEscape(state)) {
return true
}
if (state.switchU) {
var ch$1=state.current();
if (ch$1 === 0x63 || isOctalDigit(ch$1)) {
state.raise("Invalid class escape");
}
state.raise("Invalid escape");
}
state.pos=start;
 }

 var ch=state.current();
 if (ch !== 0x5D ) {
state.lastIntValue=ch;
state.advance();
return true
 }

 return false
 };

 pp$8.regexp_eatClassEscape=function(state) {
 var start=state.pos;

 if (state.eat(0x62 )) {
state.lastIntValue=0x08;
return true
 }

 if (state.switchU && state.eat(0x2D )) {
state.lastIntValue=0x2D;
return true
 }

 if (!state.switchU && state.eat(0x63 )) {
if (this.regexp_eatClassControlLetter(state)) {
return true
}
state.pos=start;
 }

 return (
this.regexp_eatCharacterClassEscape(state) ||
this.regexp_eatCharacterEscape(state)
 )
 };

 pp$8.regexp_eatClassControlLetter=function(state) {
 var ch=state.current();
 if (isDecimalDigit(ch) || ch === 0x5F ) {
state.lastIntValue=ch % 0x20;
state.advance();
return true
 }
 return false
 };

 pp$8.regexp_eatHexEscapeSequence=function(state) {
 var start=state.pos;
 if (state.eat(0x78 )) {
if (this.regexp_eatFixedHexDigits(state,2)) {
return true
}
if (state.switchU) {
state.raise("Invalid escape");
}
state.pos=start;
 }
 return false
 };

 pp$8.regexp_eatDecimalDigits=function(state) {
 var start=state.pos;
 var ch=0;
 state.lastIntValue=0;
 while (isDecimalDigit(ch=state.current())) {
state.lastIntValue=10 * state.lastIntValue + (ch - 0x30 );
state.advance();
 }
 return state.pos !== start
 };
 function isDecimalDigit(ch) {
 return ch >= 0x30 && ch <= 0x39
 }

 pp$8.regexp_eatHexDigits=function(state) {
 var start=state.pos;
 var ch=0;
 state.lastIntValue=0;
 while (isHexDigit(ch=state.current())) {
state.lastIntValue=16 * state.lastIntValue + hexToInt(ch);
state.advance();
 }
 return state.pos !== start
 };
 function isHexDigit(ch) {
 return (
(ch >= 0x30 && ch <= 0x39 ) ||
(ch >= 0x41 && ch <= 0x46 ) ||
(ch >= 0x61 && ch <= 0x66 )
 )
 }
 function hexToInt(ch) {
 if (ch >= 0x41 && ch <= 0x46 ) {
return 10 + (ch - 0x41 )
 }
 if (ch >= 0x61 && ch <= 0x66 ) {
return 10 + (ch - 0x61 )
 }
 return ch - 0x30
 }

 pp$8.regexp_eatLegacyOctalEscapeSequence=function(state) {
 if (this.regexp_eatOctalDigit(state)) {
var n1=state.lastIntValue;
if (this.regexp_eatOctalDigit(state)) {
var n2=state.lastIntValue;
if (n1 <= 3 && this.regexp_eatOctalDigit(state)) {
state.lastIntValue=n1 * 64 + n2 * 8 + state.lastIntValue;
} else {
state.lastIntValue=n1 * 8 + n2;
}
} else {
state.lastIntValue=n1;
}
return true
 }
 return false
 };

 pp$8.regexp_eatOctalDigit=function(state) {
 var ch=state.current();
 if (isOctalDigit(ch)) {
state.lastIntValue=ch - 0x30;
state.advance();
return true
 }
 state.lastIntValue=0;
 return false
 };
 function isOctalDigit(ch) {
 return ch >= 0x30 && ch <= 0x37
 }

 pp$8.regexp_eatFixedHexDigits=function(state,length) {
 var start=state.pos;
 state.lastIntValue=0;
 for (var i=0; i < length; ++i) {
var ch=state.current();
if (!isHexDigit(ch)) {
state.pos=start;
return false
}
state.lastIntValue=16 * state.lastIntValue + hexToInt(ch);
state.advance();
 }
 return true
 };


 var Token=function Token(p) {
 this.type=p.type;
 this.value=p.value;
 this.start=p.start;
 this.end=p.end;
 if (p.options.locations)
 { this.loc=new SourceLocation(p,p.startLoc,p.endLoc); }
 if (p.options.ranges)
 { this.range=[p.start,p.end]; }
 };


 var pp$9=Parser.prototype;


 pp$9.next=function(ignoreEscapeSequenceInKeyword) {
 if (!ignoreEscapeSequenceInKeyword && this.type.keyword && this.containsEsc)
 { this.raiseRecoverable(this.start,"Escape sequence in keyword " + this.type.keyword); }
 if (this.options.onToken)
 { this.options.onToken(new Token(this)); }

 this.lastTokEnd=this.end;
 this.lastTokStart=this.start;
 this.lastTokEndLoc=this.endLoc;
 this.lastTokStartLoc=this.startLoc;
 this.nextToken();
 };

 pp$9.getToken=function() {
 this.next();
 return new Token(this)
 };

 if (typeof Symbol !== "undefined")
 { pp$9[Symbol.iterator]=function() {
 var this$1=this;

 return {
next: function () {
var token=this$1.getToken();
return {
done: token.type === types.eof,
value: token
}
}
 }
 }; }


 pp$9.curContext=function() {
 return this.context[this.context.length - 1]
 };


 pp$9.nextToken=function() {
 var curContext=this.curContext();
 if (!curContext || !curContext.preserveSpace) { this.skipSpace(); }

 this.start=this.pos;
 if (this.options.locations) { this.startLoc=this.curPosition(); }
 if (this.pos >= this.input.length) { return this.finishToken(types.eof) }

 if (curContext.override) { return curContext.override(this) }
 else { this.readToken(this.fullCharCodeAtPos()); }
 };

 pp$9.readToken=function(code) {
 if (isIdentifierStart(code,this.options.ecmaVersion >= 6) || code === 92 )
 { return this.readWord() }

 return this.getTokenFromCode(code)
 };

 pp$9.fullCharCodeAtPos=function() {
 var code=this.input.charCodeAt(this.pos);
 if (code <= 0xd7ff || code >= 0xe000) { return code }
 var next=this.input.charCodeAt(this.pos + 1);
 return (code << 10) + next - 0x35fdc00
 };

 pp$9.skipBlockComment=function() {
 var startLoc=this.options.onComment && this.curPosition();
 var start=this.pos,end=this.input.indexOf("*/",this.pos += 2);
 if (end === -1) { this.raise(this.pos - 2,"Unterminated comment"); }
 this.pos=end + 2;
 if (this.options.locations) {
lineBreakG.lastIndex=start;
var match;
while ((match=lineBreakG.exec(this.input)) && match.index < this.pos) {
++this.curLine;
this.lineStart=match.index + match[0].length;
}
 }
 if (this.options.onComment)
 { this.options.onComment(true,this.input.slice(start + 2,end),start,this.pos,
startLoc,this.curPosition()); }
 };

 pp$9.skipLineComment=function(startSkip) {
 var start=this.pos;
 var startLoc=this.options.onComment && this.curPosition();
 var ch=this.input.charCodeAt(this.pos += startSkip);
 while (this.pos < this.input.length && !isNewLine(ch)) {
ch=this.input.charCodeAt(++this.pos);
 }
 if (this.options.onComment)
 { this.options.onComment(false,this.input.slice(start + startSkip,this.pos),start,this.pos,
startLoc,this.curPosition()); }
 };


 pp$9.skipSpace=function() {
 loop: while (this.pos < this.input.length) {
var ch=this.input.charCodeAt(this.pos);
switch (ch) {
case 32: case 160:
++this.pos;
break
case 13:
if (this.input.charCodeAt(this.pos + 1) === 10) {
++this.pos;
}
case 10: case 8232: case 8233:
++this.pos;
if (this.options.locations) {
++this.curLine;
this.lineStart=this.pos;
}
break
case 47:
switch (this.input.charCodeAt(this.pos + 1)) {
case 42:
 this.skipBlockComment();
 break
case 47:
 this.skipLineComment(2);
 break
default:
 break loop
}
break
default:
if (ch > 8 && ch < 14 || ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
++this.pos;
} else {
break loop
}
}
 }
 };


 pp$9.finishToken=function(type,val) {
 this.end=this.pos;
 if (this.options.locations) { this.endLoc=this.curPosition(); }
 var prevType=this.type;
 this.type=type;
 this.value=val;

 this.updateContext(prevType);
 };


 pp$9.readToken_dot=function() {
 var next=this.input.charCodeAt(this.pos + 1);
 if (next >= 48 && next <= 57) { return this.readNumber(true) }
 var next2=this.input.charCodeAt(this.pos + 2);
 if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) {
this.pos += 3;
return this.finishToken(types.ellipsis)
 } else {
++this.pos;
return this.finishToken(types.dot)
 }
 };

 pp$9.readToken_slash=function() {
 var next=this.input.charCodeAt(this.pos + 1);
 if (this.exprAllowed) { ++this.pos; return this.readRegexp() }
 if (next === 61) { return this.finishOp(types.assign,2) }
 return this.finishOp(types.slash,1)
 };

 pp$9.readToken_mult_modulo_exp=function(code) {
 var next=this.input.charCodeAt(this.pos + 1);
 var size=1;
 var tokentype=code === 42 ? types.star : types.modulo;

 if (this.options.ecmaVersion >= 7 && code === 42 && next === 42) {
++size;
tokentype=types.starstar;
next=this.input.charCodeAt(this.pos + 2);
 }

 if (next === 61) { return this.finishOp(types.assign,size + 1) }
 return this.finishOp(tokentype,size)
 };

 pp$9.readToken_pipe_amp=function(code) {
 var next=this.input.charCodeAt(this.pos + 1);
 if (next === code) { return this.finishOp(code === 124 ? types.logicalOR : types.logicalAND,2) }
 if (next === 61) { return this.finishOp(types.assign,2) }
 return this.finishOp(code === 124 ? types.bitwiseOR : types.bitwiseAND,1)
 };

 pp$9.readToken_caret=function() {
 var next=this.input.charCodeAt(this.pos + 1);
 if (next === 61) { return this.finishOp(types.assign,2) }
 return this.finishOp(types.bitwiseXOR,1)
 };

 pp$9.readToken_plus_min=function(code) {
 var next=this.input.charCodeAt(this.pos + 1);
 if (next === code) {
if (next === 45 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 62 &&
(this.lastTokEnd === 0 || lineBreak.test(this.input.slice(this.lastTokEnd,this.pos)))) {
this.skipLineComment(3);
this.skipSpace();
return this.nextToken()
}
return this.finishOp(types.incDec,2)
 }
 if (next === 61) { return this.finishOp(types.assign,2) }
 return this.finishOp(types.plusMin,1)
 };

 pp$9.readToken_lt_gt=function(code) {
 var next=this.input.charCodeAt(this.pos + 1);
 var size=1;
 if (next === code) {
size=code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
if (this.input.charCodeAt(this.pos + size) === 61) { return this.finishOp(types.assign,size + 1) }
return this.finishOp(types.bitShift,size)
 }
 if (next === 33 && code === 60 && !this.inModule && this.input.charCodeAt(this.pos + 2) === 45 &&
this.input.charCodeAt(this.pos + 3) === 45) {
this.skipLineComment(4);
this.skipSpace();
return this.nextToken()
 }
 if (next === 61) { size=2; }
 return this.finishOp(types.relational,size)
 };

 pp$9.readToken_eq_excl=function(code) {
 var next=this.input.charCodeAt(this.pos + 1);
 if (next === 61) { return this.finishOp(types.equality,this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2) }
 if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) {
this.pos += 2;
return this.finishToken(types.arrow)
 }
 return this.finishOp(code === 61 ? types.eq : types.prefix,1)
 };

 pp$9.getTokenFromCode=function(code) {
 switch (code) {
case 46:
return this.readToken_dot()

case 40: ++this.pos; return this.finishToken(types.parenL)
case 41: ++this.pos; return this.finishToken(types.parenR)
case 59: ++this.pos; return this.finishToken(types.semi)
case 44: ++this.pos; return this.finishToken(types.comma)
case 91: ++this.pos; return this.finishToken(types.bracketL)
case 93: ++this.pos; return this.finishToken(types.bracketR)
case 123: ++this.pos; return this.finishToken(types.braceL)
case 125: ++this.pos; return this.finishToken(types.braceR)
case 58: ++this.pos; return this.finishToken(types.colon)
case 63: ++this.pos; return this.finishToken(types.question)

case 96:
if (this.options.ecmaVersion < 6) { break }
++this.pos;
return this.finishToken(types.backQuote)

case 48:
var next=this.input.charCodeAt(this.pos + 1);
if (next === 120 || next === 88) { return this.readRadixNumber(16) }
if (this.options.ecmaVersion >= 6) {
if (next === 111 || next === 79) { return this.readRadixNumber(8) }
if (next === 98 || next === 66) { return this.readRadixNumber(2) }
}

case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57:
return this.readNumber(false)

case 34: case 39:
return this.readString(code)


case 47:
return this.readToken_slash()

case 37: case 42:
return this.readToken_mult_modulo_exp(code)

case 124: case 38:
return this.readToken_pipe_amp(code)

case 94:
return this.readToken_caret()

case 43: case 45:
return this.readToken_plus_min(code)

case 60: case 62:
return this.readToken_lt_gt(code)

case 61: case 33:
return this.readToken_eq_excl(code)

case 126:
return this.finishOp(types.prefix,1)
 }

 this.raise(this.pos,"Unexpected character '" + codePointToString$1(code) + "'");
 };

 pp$9.finishOp=function(type,size) {
 var str=this.input.slice(this.pos,this.pos + size);
 this.pos += size;
 return this.finishToken(type,str)
 };

 pp$9.readRegexp=function() {
 var escaped,inClass,start=this.pos;
 for (;;) {
if (this.pos >= this.input.length) { this.raise(start,"Unterminated regular expression"); }
var ch=this.input.charAt(this.pos);
if (lineBreak.test(ch)) { this.raise(start,"Unterminated regular expression"); }
if (!escaped) {
if (ch === "[") { inClass=true; }
else if (ch === "]" && inClass) { inClass=false; }
else if (ch === "/" && !inClass) { break }
escaped=ch === "\\";
} else { escaped=false; }
++this.pos;
 }
 var pattern=this.input.slice(start,this.pos);
 ++this.pos;
 var flagsStart=this.pos;
 var flags=this.readWord1();
 if (this.containsEsc) { this.unexpected(flagsStart); }

 var state=this.regexpState || (this.regexpState=new RegExpValidationState(this));
 state.reset(start,pattern,flags);
 this.validateRegExpFlags(state);
 this.validateRegExpPattern(state);

 var value=null;
 try {
value=new RegExp(pattern,flags);
 } catch (e) {
 }

 return this.finishToken(types.regexp,{pattern: pattern,flags: flags,value: value})
 };


 pp$9.readInt=function(radix,len) {
 var start=this.pos,total=0;
 for (var i=0,e=len == null ? Infinity : len; i < e; ++i) {
var code=this.input.charCodeAt(this.pos),val=(void 0);
if (code >= 97) { val=code - 97 + 10; }
else if (code >= 65) { val=code - 65 + 10; }
else if (code >= 48 && code <= 57) { val=code - 48; }
else { val=Infinity; }
if (val >= radix) { break }
++this.pos;
total=total * radix + val;
 }
 if (this.pos === start || len != null && this.pos - start !== len) { return null }

 return total
 };

 pp$9.readRadixNumber=function(radix) {
 var start=this.pos;
 this.pos += 2;
 var val=this.readInt(radix);
 if (val == null) { this.raise(this.start + 2,"Expected number in radix " + radix); }
 if (this.options.ecmaVersion >= 11 && this.input.charCodeAt(this.pos) === 110) {
val=typeof BigInt !== "undefined" ? BigInt(this.input.slice(start,this.pos)) : null;
++this.pos;
 } else if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos,"Identifier directly after number"); }
 return this.finishToken(types.num,val)
 };


 pp$9.readNumber=function(startsWithDot) {
 var start=this.pos;
 if (!startsWithDot && this.readInt(10) === null) { this.raise(start,"Invalid number"); }
 var octal=this.pos - start >= 2 && this.input.charCodeAt(start) === 48;
 if (octal && this.strict) { this.raise(start,"Invalid number"); }
 var next=this.input.charCodeAt(this.pos);
 if (!octal && !startsWithDot && this.options.ecmaVersion >= 11 && next === 110) {
var str$1=this.input.slice(start,this.pos);
var val$1=typeof BigInt !== "undefined" ? BigInt(str$1) : null;
++this.pos;
if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos,"Identifier directly after number"); }
return this.finishToken(types.num,val$1)
 }
 if (octal && /[89]/.test(this.input.slice(start,this.pos))) { octal=false; }
 if (next === 46 && !octal) {
++this.pos;
this.readInt(10);
next=this.input.charCodeAt(this.pos);
 }
 if ((next === 69 || next === 101) && !octal) {
next=this.input.charCodeAt(++this.pos);
if (next === 43 || next === 45) { ++this.pos; }
if (this.readInt(10) === null) { this.raise(start,"Invalid number"); }
 }
 if (isIdentifierStart(this.fullCharCodeAtPos())) { this.raise(this.pos,"Identifier directly after number"); }

 var str=this.input.slice(start,this.pos);
 var val=octal ? parseInt(str,8) : parseFloat(str);
 return this.finishToken(types.num,val)
 };


 pp$9.readCodePoint=function() {
 var ch=this.input.charCodeAt(this.pos),code;

 if (ch === 123) {
if (this.options.ecmaVersion < 6) { this.unexpected(); }
var codePos=++this.pos;
code=this.readHexChar(this.input.indexOf("}",this.pos) - this.pos);
++this.pos;
if (code > 0x10FFFF) { this.invalidStringToken(codePos,"Code point out of bounds"); }
 } else {
code=this.readHexChar(4);
 }
 return code
 };

 function codePointToString$1(code) {
 if (code <= 0xFFFF) { return String.fromCharCode(code) }
 code -= 0x10000;
 return String.fromCharCode((code >> 10) + 0xD800,(code & 1023) + 0xDC00)
 }

 pp$9.readString=function(quote) {
 var out="",chunkStart=++this.pos;
 for (;;) {
if (this.pos >= this.input.length) { this.raise(this.start,"Unterminated string constant"); }
var ch=this.input.charCodeAt(this.pos);
if (ch === quote) { break }
if (ch === 92) {
out += this.input.slice(chunkStart,this.pos);
out += this.readEscapedChar(false);
chunkStart=this.pos;
} else {
if (isNewLine(ch,this.options.ecmaVersion >= 10)) { this.raise(this.start,"Unterminated string constant"); }
++this.pos;
}
 }
 out += this.input.slice(chunkStart,this.pos++);
 return this.finishToken(types.string,out)
 };


 var INVALID_TEMPLATE_ESCAPE_ERROR={};

 pp$9.tryReadTemplateToken=function() {
 this.inTemplateElement=true;
 try {
this.readTmplToken();
 } catch (err) {
if (err === INVALID_TEMPLATE_ESCAPE_ERROR) {
this.readInvalidTemplateToken();
} else {
throw err
}
 }

 this.inTemplateElement=false;
 };

 pp$9.invalidStringToken=function(position,message) {
 if (this.inTemplateElement && this.options.ecmaVersion >= 9) {
throw INVALID_TEMPLATE_ESCAPE_ERROR
 } else {
this.raise(position,message);
 }
 };

 pp$9.readTmplToken=function() {
 var out="",chunkStart=this.pos;
 for (;;) {
if (this.pos >= this.input.length) { this.raise(this.start,"Unterminated template"); }
var ch=this.input.charCodeAt(this.pos);
if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) {
if (this.pos === this.start && (this.type === types.template || this.type === types.invalidTemplate)) {
if (ch === 36) {
this.pos += 2;
return this.finishToken(types.dollarBraceL)
} else {
++this.pos;
return this.finishToken(types.backQuote)
}
}
out += this.input.slice(chunkStart,this.pos);
return this.finishToken(types.template,out)
}
if (ch === 92) {
out += this.input.slice(chunkStart,this.pos);
out += this.readEscapedChar(true);
chunkStart=this.pos;
} else if (isNewLine(ch)) {
out += this.input.slice(chunkStart,this.pos);
++this.pos;
switch (ch) {
case 13:
if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; }
case 10:
out += "\n";
break
default:
out += String.fromCharCode(ch);
break
}
if (this.options.locations) {
++this.curLine;
this.lineStart=this.pos;
}
chunkStart=this.pos;
} else {
++this.pos;
}
 }
 };

 pp$9.readInvalidTemplateToken=function() {
 for (; this.pos < this.input.length; this.pos++) {
switch (this.input[this.pos]) {
case "\\":
++this.pos;
break

case "$":
if (this.input[this.pos + 1] !== "{") {
break
}

case "`":
return this.finishToken(types.invalidTemplate,this.input.slice(this.start,this.pos))

}
 }
 this.raise(this.start,"Unterminated template");
 };


 pp$9.readEscapedChar=function(inTemplate) {
 var ch=this.input.charCodeAt(++this.pos);
 ++this.pos;
 switch (ch) {
case 110: return "\n"
case 114: return "\r"
case 120: return String.fromCharCode(this.readHexChar(2))
case 117: return codePointToString$1(this.readCodePoint())
case 116: return "\t"
case 98: return "\b"
case 118: return "\u000b"
case 102: return "\f"
case 13: if (this.input.charCodeAt(this.pos) === 10) { ++this.pos; }
case 10:
if (this.options.locations) { this.lineStart=this.pos; ++this.curLine; }
return ""
case 56:
case 57:
if (inTemplate) {
var codePos=this.pos - 1;

this.invalidStringToken(
codePos,
"Invalid escape sequence in template string"
);

return null
}
default:
if (ch >= 48 && ch <= 55) {
var octalStr=this.input.substr(this.pos - 1,3).match(/^[0-7]+/)[0];
var octal=parseInt(octalStr,8);
if (octal > 255) {
octalStr=octalStr.slice(0,-1);
octal=parseInt(octalStr,8);
}
this.pos += octalStr.length - 1;
ch=this.input.charCodeAt(this.pos);
if ((octalStr !== "0" || ch === 56 || ch === 57) && (this.strict || inTemplate)) {
this.invalidStringToken(
 this.pos - 1 - octalStr.length,
 inTemplate
 ? "Octal literal in template string"
 : "Octal literal in strict mode"
);
}
return String.fromCharCode(octal)
}
if (isNewLine(ch)) {
return ""
}
return String.fromCharCode(ch)
 }
 };


 pp$9.readHexChar=function(len) {
 var codePos=this.pos;
 var n=this.readInt(16,len);
 if (n === null) { this.invalidStringToken(codePos,"Bad character escape sequence"); }
 return n
 };


 pp$9.readWord1=function() {
 this.containsEsc=false;
 var word="",first=true,chunkStart=this.pos;
 var astral=this.options.ecmaVersion >= 6;
 while (this.pos < this.input.length) {
var ch=this.fullCharCodeAtPos();
if (isIdentifierChar(ch,astral)) {
this.pos += ch <= 0xffff ? 1 : 2;
} else if (ch === 92) {
this.containsEsc=true;
word += this.input.slice(chunkStart,this.pos);
var escStart=this.pos;
if (this.input.charCodeAt(++this.pos) !== 117)
{ this.invalidStringToken(this.pos,"Expecting Unicode escape sequence \\uXXXX"); }
++this.pos;
var esc=this.readCodePoint();
if (!(first ? isIdentifierStart : isIdentifierChar)(esc,astral))
{ this.invalidStringToken(escStart,"Invalid Unicode escape"); }
word += codePointToString$1(esc);
chunkStart=this.pos;
} else {
break
}
first=false;
 }
 return word + this.input.slice(chunkStart,this.pos)
 };


 pp$9.readWord=function() {
 var word=this.readWord1();
 var type=types.name;
 if (this.keywords.test(word)) {
type=keywords$1[word];
 }
 return this.finishToken(type,word)
 };


 var version="7.1.0";

 Parser.acorn={
 Parser: Parser,
 version: version,
 defaultOptions: defaultOptions,
 Position: Position,
 SourceLocation: SourceLocation,
 getLineInfo: getLineInfo,
 Node: Node,
 TokenType: TokenType,
 tokTypes: types,
 keywordTypes: keywords$1,
 TokContext: TokContext,
 tokContexts: types$1,
 isIdentifierChar: isIdentifierChar,
 isIdentifierStart: isIdentifierStart,
 Token: Token,
 isNewLine: isNewLine,
 lineBreak: lineBreak,
 lineBreakG: lineBreakG,
 nonASCIIwhitespace: nonASCIIwhitespace
 };


 function parse(input,options) {
 return Parser.parse(input,options)
 }


 function parseExpressionAt(input,pos,options) {
 return Parser.parseExpressionAt(input,pos,options)
 }


 function tokenizer(input,options) {
 return Parser.tokenizer(input,options)
 }

 exports.Node=Node;
 exports.Parser=Parser;
 exports.Position=Position;
 exports.SourceLocation=SourceLocation;
 exports.TokContext=TokContext;
 exports.Token=Token;
 exports.TokenType=TokenType;
 exports.defaultOptions=defaultOptions;
 exports.getLineInfo=getLineInfo;
 exports.isIdentifierChar=isIdentifierChar;
 exports.isIdentifierStart=isIdentifierStart;
 exports.isNewLine=isNewLine;
 exports.keywordTypes=keywords$1;
 exports.lineBreak=lineBreak;
 exports.lineBreakG=lineBreakG;
 exports.nonASCIIwhitespace=nonASCIIwhitespace;
 exports.parse=parse;
 exports.parseExpressionAt=parseExpressionAt;
 exports.tokContexts=types$1;
 exports.tokTypes=types;
 exports.tokenizer=tokenizer;
 exports.version=version;

 Object.defineProperty(exports,'__esModule',{ value: true });

 }));

 },{}],2:[function(require,module,exports){

 },{}],3:[function(require,module,exports){
 function glWiretap(gl,options={}) {
 const {
 contextName='gl',
 throwGetError,
 useTrackablePrimitives,
 readPixelsFile,
 recording=[],
 variables={},
 onReadPixels,
 onUnrecognizedArgumentLookup,
 }=options;
 const proxy=new Proxy(gl,{ get: listen });
 const contextVariables=[];
 const entityNames={};
 let imageCount=0;
 let indent='';
 let readPixelsVariableName;
 return proxy;
 function listen(obj,property) {
 switch (property) {
case 'addComment': return addComment;
case 'checkThrowError': return checkThrowError;
case 'getReadPixelsVariableName': return readPixelsVariableName;
case 'insertVariable': return insertVariable;
case 'reset': return reset;
case 'setIndent': return setIndent;
case 'toString': return toString;
case 'getContextVariableName': return getContextVariableName;
 }
 if (typeof gl[property] === 'function') {
return function() {
switch (property) {
case 'getError':
if (throwGetError) {
 recording.push(`${indent}if (${contextName}.getError() !== ${contextName}.NONE) throw new Error('error');`);
} else {
 recording.push(`${indent}${contextName}.getError();`);
}
return gl.getError();
case 'getExtension': {
const variableName=`${contextName}Variables${contextVariables.length}`;
recording.push(`${indent}const ${variableName}=${contextName}.getExtension('${arguments[0]}');`);
const extension=gl.getExtension(arguments[0]);
if (extension && typeof extension === 'object') {
 const tappedExtension=glExtensionWiretap(extension,{
 getEntity,
 useTrackablePrimitives,
 recording,
 contextName: variableName,
 contextVariables,
 variables,
 indent,
 onUnrecognizedArgumentLookup,
 });
 contextVariables.push(tappedExtension);
 return tappedExtension;
} else {
 contextVariables.push(null);
}
return extension;
}
case 'readPixels':
const i=contextVariables.indexOf(arguments[6]);
let targetVariableName;
if (i === -1) {
 const variableName=getVariableName(arguments[6]);
 if (variableName) {
 targetVariableName=variableName;
 recording.push(`${indent}${variableName}`);
 } else {
 targetVariableName=`${contextName}Variable${contextVariables.length}`;
 contextVariables.push(arguments[6]);
 recording.push(`${indent}const ${targetVariableName}=new ${arguments[6].constructor.name}(${arguments[6].length});`);
 }
} else {
 targetVariableName=`${contextName}Variable${i}`;
}
readPixelsVariableName=targetVariableName;
const argumentAsStrings=[
 arguments[0],
 arguments[1],
 arguments[2],
 arguments[3],
 getEntity(arguments[4]),
 getEntity(arguments[5]),
 targetVariableName
];
recording.push(`${indent}${contextName}.readPixels(${argumentAsStrings.join(',')});`);
if (readPixelsFile) {
 writePPM(arguments[2],arguments[3]);
}
if (onReadPixels) {
 onReadPixels(targetVariableName,argumentAsStrings);
}
return gl.readPixels.apply(gl,arguments);
case 'drawBuffers':
recording.push(`${indent}${contextName}.drawBuffers([${argumentsToString(arguments[0],{ contextName,contextVariables,getEntity,addVariable,variables,onUnrecognizedArgumentLookup } )}]);`);
return gl.drawBuffers(arguments[0]);
}
let result=gl[property].apply(gl,arguments);
switch (typeof result) {
case 'undefined':
recording.push(`${indent}${methodCallToString(property,arguments)};`);
return;
case 'number':
case 'boolean':
if (useTrackablePrimitives && contextVariables.indexOf(trackablePrimitive(result)) === -1) {
 recording.push(`${indent}const ${contextName}Variable${contextVariables.length}=${methodCallToString(property,arguments)};`);
 contextVariables.push(result=trackablePrimitive(result));
 break;
}
default:
if (result === null) {
 recording.push(`${methodCallToString(property,arguments)};`);
} else {
 recording.push(`${indent}const ${contextName}Variable${contextVariables.length}=${methodCallToString(property,arguments)};`);
}

contextVariables.push(result);
}
return result;
}
 }
 entityNames[gl[property]]=property;
 return gl[property];
 }
 function toString() {
 return recording.join('\n');
 }
 function reset() {
 while (recording.length > 0) {
recording.pop();
 }
 }
 function insertVariable(name,value) {
 variables[name]=value;
 }
 function getEntity(value) {
 const name=entityNames[value];
 if (name) {
return contextName + '.' + name;
 }
 return value;
 }
 function setIndent(spaces) {
 indent=' '.repeat(spaces);
 }
 function addVariable(value,source) {
 const variableName=`${contextName}Variable${contextVariables.length}`;
 recording.push(`${indent}const ${variableName}=${source};`);
 contextVariables.push(value);
 return variableName;
 }
 function writePPM(width,height) {
 const sourceVariable=`${contextName}Variable${contextVariables.length}`;
 const imageVariable=`imageDatum${imageCount}`;
 recording.push(`${indent}let ${imageVariable}=["P3\\n# ${readPixelsFile}.ppm\\n",${width},' ',${height},"\\n255\\n"].join("");`);
 recording.push(`${indent}for (let i=0; i < ${imageVariable}.length; i += 4) {`);
 recording.push(`${indent} ${imageVariable} += ${sourceVariable}[i] + ' ' + ${sourceVariable}[i + 1] + ' ' + ${sourceVariable}[i + 2] + ' ';`);
 recording.push(`${indent}}`);
 recording.push(`${indent}if (typeof require !== "undefined") {`);
 recording.push(`${indent} require('fs').writeFileSync('./${readPixelsFile}.ppm',${imageVariable});`);
 recording.push(`${indent}}`);
 imageCount++;
 }
 function addComment(value) {
 recording.push(`${indent}// ${value}`);
 }
 function checkThrowError() {
 recording.push(`${indent}(() => {
${indent}const error=${contextName}.getError();
${indent}if (error !== ${contextName}.NONE) {
${indent} const names=Object.getOwnPropertyNames(gl);
${indent} for (let i=0; i < names.length; i++) {
${indent} const name=names[i];
${indent} if (${contextName}[name] === error) {
${indent} throw new Error('${contextName} threw ' + name);
${indent} }
${indent} }
${indent}}
${indent}})();`);
 }
 function methodCallToString(method,args) {
 return `${contextName}.${method}(${argumentsToString(args,{ contextName,contextVariables,getEntity,addVariable,variables,onUnrecognizedArgumentLookup })})`;
 }

 function getVariableName(value) {
 if (variables) {
for (const name in variables) {
if (variables[name] === value) {
return name;
}
}
 }
 return null;
 }

 function getContextVariableName(value) {
 const i=contextVariables.indexOf(value);
 if (i !== -1) {
return `${contextName}Variable${i}`;
 }
 return null;
 }
 }

 function glExtensionWiretap(extension,options) {
 const proxy=new Proxy(extension,{ get: listen });
 const extensionEntityNames={};
 const {
 contextName,
 contextVariables,
 getEntity,
 useTrackablePrimitives,
 recording,
 variables,
 indent,
 onUnrecognizedArgumentLookup,
 }=options;
 return proxy;
 function listen(obj,property) {
 if (typeof obj[property] === 'function') {
return function() {
switch (property) {
case 'drawBuffersWEBGL':
recording.push(`${indent}${contextName}.drawBuffersWEBGL([${argumentsToString(arguments[0],{ contextName,contextVariables,getEntity: getExtensionEntity,addVariable,variables,onUnrecognizedArgumentLookup })}]);`);
return extension.drawBuffersWEBGL(arguments[0]);
}
let result=extension[property].apply(extension,arguments);
switch (typeof result) {
case 'undefined':
recording.push(`${indent}${methodCallToString(property,arguments)};`);
return;
case 'number':
case 'boolean':
if (useTrackablePrimitives && contextVariables.indexOf(trackablePrimitive(result)) === -1) {
 recording.push(`${indent}const ${contextName}Variable${contextVariables.length}=${methodCallToString(property,arguments)};`);
 contextVariables.push(result=trackablePrimitive(result));
} else {
 recording.push(`${indent}const ${contextName}Variable${contextVariables.length}=${methodCallToString(property,arguments)};`);
 contextVariables.push(result);
}
break;
default:
if (result === null) {
 recording.push(`${methodCallToString(property,arguments)};`);
} else {
 recording.push(`${indent}const ${contextName}Variable${contextVariables.length}=${methodCallToString(property,arguments)};`);
}
contextVariables.push(result);
}
return result;
};
 }
 extensionEntityNames[extension[property]]=property;
 return extension[property];
 }

 function getExtensionEntity(value) {
 if (extensionEntityNames.hasOwnProperty(value)) {
return `${contextName}.${extensionEntityNames[value]}`;
 }
 return getEntity(value);
 }

 function methodCallToString(method,args) {
 return `${contextName}.${method}(${argumentsToString(args,{ contextName,contextVariables,getEntity: getExtensionEntity,addVariable,variables,onUnrecognizedArgumentLookup })})`;
 }

 function addVariable(value,source) {
 const variableName=`${contextName}Variable${contextVariables.length}`;
 contextVariables.push(value);
 recording.push(`${indent}const ${variableName}=${source};`);
 return variableName;
 }
 }

 function argumentsToString(args,options) {
 const { variables,onUnrecognizedArgumentLookup }=options;
 return (Array.from(args).map((arg) => {
 const variableName=getVariableName(arg);
 if (variableName) {
return variableName;
 }
 return argumentToString(arg,options);
 }).join(','));

 function getVariableName(value) {
 if (variables) {
for (const name in variables) {
if (!variables.hasOwnProperty(name)) continue;
if (variables[name] === value) {
return name;
}
}
 }
 if (onUnrecognizedArgumentLookup) {
return onUnrecognizedArgumentLookup(value);
 }
 return null;
 }
 }

 function argumentToString(arg,options) {
 const { contextName,contextVariables,getEntity,addVariable,onUnrecognizedArgumentLookup }=options;
 if (typeof arg === 'undefined') {
 return 'undefined';
 }
 if (arg === null) {
 return 'null';
 }
 const i=contextVariables.indexOf(arg);
 if (i > -1) {
 return `${contextName}Variable${i}`;
 }
 switch (arg.constructor.name) {
 case 'String':
const hasLines=/\n/.test(arg);
const hasSingleQuotes=/'/.test(arg);
const hasDoubleQuotes=/"/.test(arg);
if (hasLines) {
return '`' + arg + '`';
} else if (hasSingleQuotes && !hasDoubleQuotes) {
return '"' + arg + '"';
} else if (!hasSingleQuotes && hasDoubleQuotes) {
return "'" + arg + "'";
} else {
return '\'' + arg + '\'';
}
 case 'Number': return getEntity(arg);
 case 'Boolean': return getEntity(arg);
 case 'Array':
return addVariable(arg,`new ${arg.constructor.name}([${Array.from(arg).join(',')}])`);
 case 'Float32Array':
 case 'Uint8Array':
 case 'Uint16Array':
 case 'Int32Array':
return addVariable(arg,`new ${arg.constructor.name}(${JSON.stringify(Array.from(arg))})`);
 default:
if (onUnrecognizedArgumentLookup) {
const instantiationString=onUnrecognizedArgumentLookup(arg);
if (instantiationString) {
return instantiationString;
}
}
throw new Error(`unrecognized argument type ${arg.constructor.name}`);
 }
 }

 function trackablePrimitive(value) {
 return new value.constructor(value);
 }

 if (typeof module !== 'undefined') {
 module.exports={ glWiretap,glExtensionWiretap };
 }

 if (typeof window !== 'undefined') {
 glWiretap.glExtensionWiretap=glExtensionWiretap;
 window.glWiretap=glWiretap;
 }

 },{}],4:[function(require,module,exports){
 function setupArguments(args) {
 const newArguments=new Array(args.length);
 for (let i=0; i < args.length; i++) {
 const arg=args[i];
 if (arg.toArray) {
newArguments[i]=arg.toArray();
 } else {
newArguments[i]=arg;
 }
 }
 return newArguments;
 }

 function mock1D() {
 const args=setupArguments(arguments);
 const row=new Float32Array(this.output.x);
 for (let x=0; x < this.output.x; x++) {
 this.thread.x=x;
 this.thread.y=0;
 this.thread.z=0;
 row[x]=this._fn.apply(this,args);
 }
 return row;
 }

 function mock2D() {
 const args=setupArguments(arguments);
 const matrix=new Array(this.output.y);
 for (let y=0; y < this.output.y; y++) {
 const row=new Float32Array(this.output.x);
 for (let x=0; x < this.output.x; x++) {
this.thread.x=x;
this.thread.y=y;
this.thread.z=0;
row[x]=this._fn.apply(this,args);
 }
 matrix[y]=row;
 }
 return matrix;
 }

 function mock2DGraphical() {
 const args=setupArguments(arguments);
 for (let y=0; y < this.output.y; y++) {
 for (let x=0; x < this.output.x; x++) {
this.thread.x=x;
this.thread.y=y;
this.thread.z=0;
this._fn.apply(this,args);
 }
 }
 }

 function mock3D() {
 const args=setupArguments(arguments);
 const cube=new Array(this.output.z);
 for (let z=0; z < this.output.z; z++) {
 const matrix=new Array(this.output.y);
 for (let y=0; y < this.output.y; y++) {
const row=new Float32Array(this.output.x);
for (let x=0; x < this.output.x; x++) {
this.thread.x=x;
this.thread.y=y;
this.thread.z=z;
row[x]=this._fn.apply(this,args);
}
matrix[y]=row;
 }
 cube[z]=matrix;
 }
 return cube;
 }

 function apiDecorate(kernel) {
 kernel.setOutput=(output) => {
 kernel.output=setupOutput(output);
 if (kernel.graphical) {
setupGraphical(kernel);
 }
 };
 kernel.toJSON=() => {
 throw new Error('Not usable with gpuMock');
 };
 kernel.setConstants=(flag) => {
 kernel.constants=flag;
 return kernel;
 };
 kernel.setGraphical=(flag) => {
 kernel.graphical=flag;
 return kernel;
 };
 kernel.setCanvas=(flag) => {
 kernel.canvas=flag;
 return kernel;
 };
 kernel.setContext=(flag) => {
 kernel.context=flag;
 return kernel;
 };
 kernel.destroy=() => {};
 kernel.validateSettings=() => {};
 if (kernel.graphical && kernel.output) {
 setupGraphical(kernel);
 }
 kernel.exec=function() {
 return new Promise((resolve,reject) => {
try {
resolve(kernel.apply(kernel,arguments));
} catch(e) {
reject(e);
}
 });
 };
 kernel.getPixels=(flip) => {
 const {x,y}=kernel.output;
 return flip ? flipPixels(kernel._imageData.data,x,y) : kernel._imageData.data.slice(0);
 };
 kernel.color=function(r,g,b,a) {
 if (typeof a === 'undefined') {
a=1;
 }

 r=Math.floor(r * 255);
 g=Math.floor(g * 255);
 b=Math.floor(b * 255);
 a=Math.floor(a * 255);

 const width=kernel.output.x;
 const height=kernel.output.y;

 const x=kernel.thread.x;
 const y=height - kernel.thread.y - 1;

 const index=x + y * width;

 kernel._colorData[index * 4 + 0]=r;
 kernel._colorData[index * 4 + 1]=g;
 kernel._colorData[index * 4 + 2]=b;
 kernel._colorData[index * 4 + 3]=a;
 };

 const mockMethod=() => kernel;
 const methods=[
 'setWarnVarUsage',
 'setArgumentTypes',
 'setTactic',
 'setOptimizeFloatMemory',
 'setDebug',
 'setLoopMaxIterations',
 'setConstantTypes',
 'setFunctions',
 'setNativeFunctions',
 'setInjectedNative',
 'setPipeline',
 'setPrecision',
 'setOutputToTexture',
 'setImmutable',
 'setStrictIntegers',
 'setDynamicOutput',
 'setHardcodeConstants',
 'setDynamicArguments',
 'setUseLegacyEncoder',
 'setWarnVarUsage',
 'addSubKernel',
 ];
 for (let i=0; i < methods.length; i++) {
 kernel[methods[i]]=mockMethod;
 }
 return kernel;
 }

 function setupGraphical(kernel) {
 const {x,y}=kernel.output;
 if (kernel.context && kernel.context.createImageData) {
 const data=new Uint8ClampedArray(x * y * 4);
 kernel._imageData=kernel.context.createImageData(x,y);
 kernel._colorData=data;
 } else {
 const data=new Uint8ClampedArray(x * y * 4);
 kernel._imageData={ data };
 kernel._colorData=data;
 }
 }

 function setupOutput(output) {
 let result=null;
 if (output.length) {
 if (output.length === 3) {
const [x,y,z]=output;
result={ x,y,z };
 } else if (output.length === 2) {
const [x,y]=output;
result={ x,y };
 } else {
const [x]=output;
result={ x };
 }
 } else {
 result=output;
 }
 return result;
 }

 function gpuMock(fn,settings={}) {
 const output=settings.output ? setupOutput(settings.output) : null;
 function kernel() {
 if (kernel.output.z) {
return mock3D.apply(kernel,arguments);
 } else if (kernel.output.y) {
if (kernel.graphical) {
return mock2DGraphical.apply(kernel,arguments);
}
return mock2D.apply(kernel,arguments);
 } else {
return mock1D.apply(kernel,arguments);
 }
 }
 kernel._fn=fn;
 kernel.constants=settings.constants || null;
 kernel.context=settings.context || null;
 kernel.canvas=settings.canvas || null;
 kernel.graphical=settings.graphical || false;
 kernel._imageData=null;
 kernel._colorData=null;
 kernel.output=output;
 kernel.thread={
 x: 0,
 y: 0,
 z: 0
 };
 return apiDecorate(kernel);
 }

 function flipPixels(pixels,width,height) {
 const halfHeight=height / 2 | 0;
 const bytesPerRow=width * 4;
 const temp=new Uint8ClampedArray(width * 4);
 const result=pixels.slice(0);
 for (let y=0; y < halfHeight; ++y) {
 const topOffset=y * bytesPerRow;
 const bottomOffset=(height - y - 1) * bytesPerRow;

 temp.set(result.subarray(topOffset,topOffset + bytesPerRow));

 result.copyWithin(topOffset,bottomOffset,bottomOffset + bytesPerRow);

 result.set(temp,bottomOffset);
 }
 return result;
 }

 module.exports={
 gpuMock
 };

 },{}],5:[function(require,module,exports){
 const { utils }=require('./utils');

 function alias(name,source) {
 const fnString=source.toString();
 return new Function(`return function ${ name } (${ utils.getArgumentNamesFromString(fnString).join(',') }) {
 ${ utils.getFunctionBodyFromString(fnString) }
}`)();
 }

 module.exports={
 alias
 };
 },{"./utils":114}],6:[function(require,module,exports){
 const { FunctionNode }=require('../function-node');

 class CPUFunctionNode extends FunctionNode {
 astFunction(ast,retArr) {

 if (!this.isRootKernel) {
retArr.push('function');
retArr.push(' ');
retArr.push(this.name);
retArr.push('(');

for (let i=0; i < this.argumentNames.length; ++i) {
const argumentName=this.argumentNames[i];

if (i > 0) {
retArr.push(',');
}
retArr.push('user_');
retArr.push(argumentName);
}

retArr.push(') {\n');
 }

 for (let i=0; i < ast.body.body.length; ++i) {
this.astGeneric(ast.body.body[i],retArr);
retArr.push('\n');
 }

 if (!this.isRootKernel) {
retArr.push('}\n');
 }
 return retArr;
 }

 astReturnStatement(ast,retArr) {
 const type=this.returnType || this.getType(ast.argument);

 if (!this.returnType) {
this.returnType=type;
 }

 if (this.isRootKernel) {
retArr.push(this.leadingReturnStatement);
this.astGeneric(ast.argument,retArr);
retArr.push(';\n');
retArr.push(this.followingReturnStatement);
retArr.push('continue;\n');
 } else if (this.isSubKernel) {
retArr.push(`subKernelResult_${ this.name }=`);
this.astGeneric(ast.argument,retArr);
retArr.push(';');
retArr.push(`return subKernelResult_${ this.name };`);
 } else {
retArr.push('return ');
this.astGeneric(ast.argument,retArr);
retArr.push(';');
 }
 return retArr;
 }

 astLiteral(ast,retArr) {

 if (isNaN(ast.value)) {
throw this.astErrorOutput(
'Non-numeric literal not supported : ' + ast.value,
ast
);
 }

 retArr.push(ast.value);

 return retArr;
 }

 astBinaryExpression(ast,retArr) {
 retArr.push('(');
 this.astGeneric(ast.left,retArr);
 retArr.push(ast.operator);
 this.astGeneric(ast.right,retArr);
 retArr.push(')');
 return retArr;
 }

 astIdentifierExpression(idtNode,retArr) {
 if (idtNode.type !== 'Identifier') {
throw this.astErrorOutput(
'IdentifierExpression - not an Identifier',
idtNode
);
 }

 switch (idtNode.name) {
case 'Infinity':
retArr.push('Infinity');
break;
default:
if (this.constants && this.constants.hasOwnProperty(idtNode.name)) {
retArr.push('constants_' + idtNode.name);
} else {
retArr.push('user_' + idtNode.name);
}
 }

 return retArr;
 }

 astForStatement(forNode,retArr) {
 if (forNode.type !== 'ForStatement') {
throw this.astErrorOutput('Invalid for statement',forNode);
 }

 const initArr=[];
 const testArr=[];
 const updateArr=[];
 const bodyArr=[];
 let isSafe=null;

 if (forNode.init) {
this.pushState('in-for-loop-init');
this.astGeneric(forNode.init,initArr);
for (let i=0; i < initArr.length; i++) {
if (initArr[i].includes && initArr[i].includes(',')) {
isSafe=false;
}
}
this.popState('in-for-loop-init');
 } else {
isSafe=false;
 }

 if (forNode.test) {
this.astGeneric(forNode.test,testArr);
 } else {
isSafe=false;
 }

 if (forNode.update) {
this.astGeneric(forNode.update,updateArr);
 } else {
isSafe=false;
 }

 if (forNode.body) {
this.pushState('loop-body');
this.astGeneric(forNode.body,bodyArr);
this.popState('loop-body');
 }

 if (isSafe === null) {
isSafe=this.isSafe(forNode.init) && this.isSafe(forNode.test);
 }

 if (isSafe) {
retArr.push(`for (${initArr.join('')};${testArr.join('')};${updateArr.join('')}){\n`);
retArr.push(bodyArr.join(''));
retArr.push('}\n');
 } else {
const iVariableName=this.getInternalVariableName('safeI');
if (initArr.length > 0) {
retArr.push(initArr.join(''),';\n');
}
retArr.push(`for (let ${iVariableName}=0;${iVariableName}<LOOP_MAX;${iVariableName}++){\n`);
if (testArr.length > 0) {
retArr.push(`if (!${testArr.join('')}) break;\n`);
}
retArr.push(bodyArr.join(''));
retArr.push(`\n${updateArr.join('')};`);
retArr.push('}\n');
 }
 return retArr;
 }

 astWhileStatement(whileNode,retArr) {
 if (whileNode.type !== 'WhileStatement') {
throw this.astErrorOutput(
'Invalid while statement',
whileNode
);
 }

 retArr.push('for (let i=0; i < LOOP_MAX; i++) {');
 retArr.push('if (');
 this.astGeneric(whileNode.test,retArr);
 retArr.push(') {\n');
 this.astGeneric(whileNode.body,retArr);
 retArr.push('} else {\n');
 retArr.push('break;\n');
 retArr.push('}\n');
 retArr.push('}\n');

 return retArr;
 }

 astDoWhileStatement(doWhileNode,retArr) {
 if (doWhileNode.type !== 'DoWhileStatement') {
throw this.astErrorOutput(
'Invalid while statement',
doWhileNode
);
 }

 retArr.push('for (let i=0; i < LOOP_MAX; i++) {');
 this.astGeneric(doWhileNode.body,retArr);
 retArr.push('if (!');
 this.astGeneric(doWhileNode.test,retArr);
 retArr.push(') {\n');
 retArr.push('break;\n');
 retArr.push('}\n');
 retArr.push('}\n');

 return retArr;

 }

 astAssignmentExpression(assNode,retArr) {
 const declaration=this.getDeclaration(assNode.left);
 if (declaration && !declaration.assignable) {
throw this.astErrorOutput(`Variable ${assNode.left.name} is not assignable here`,assNode);
 }
 this.astGeneric(assNode.left,retArr);
 retArr.push(assNode.operator);
 this.astGeneric(assNode.right,retArr);
 return retArr;
 }

 astBlockStatement(bNode,retArr) {
 if (this.isState('loop-body')) {
this.pushState('block-body');
for (let i=0; i < bNode.body.length; i++) {
this.astGeneric(bNode.body[i],retArr);
}
this.popState('block-body');
 } else {
retArr.push('{\n');
for (let i=0; i < bNode.body.length; i++) {
this.astGeneric(bNode.body[i],retArr);
}
retArr.push('}\n');
 }
 return retArr;
 }

 astVariableDeclaration(varDecNode,retArr) {
 retArr.push(`${varDecNode.kind} `);
 const { declarations }=varDecNode;
 for (let i=0; i < declarations.length; i++) {
if (i > 0) {
retArr.push(',');
}
const declaration=declarations[i];
const info=this.getDeclaration(declaration.id);
if (!info.valueType) {
info.valueType=this.getType(declaration.init);
}
this.astGeneric(declaration,retArr);
 }
 if (!this.isState('in-for-loop-init')) {
retArr.push(';');
 }
 return retArr;
 }

 astIfStatement(ifNode,retArr) {
 retArr.push('if (');
 this.astGeneric(ifNode.test,retArr);
 retArr.push(')');
 if (ifNode.consequent.type === 'BlockStatement') {
this.astGeneric(ifNode.consequent,retArr);
 } else {
retArr.push(' {\n');
this.astGeneric(ifNode.consequent,retArr);
retArr.push('\n}\n');
 }

 if (ifNode.alternate) {
retArr.push('else ');
if (ifNode.alternate.type === 'BlockStatement' || ifNode.alternate.type === 'IfStatement') {
this.astGeneric(ifNode.alternate,retArr);
} else {
retArr.push(' {\n');
this.astGeneric(ifNode.alternate,retArr);
retArr.push('\n}\n');
}
 }
 return retArr;

 }

 astSwitchStatement(ast,retArr) {
 const { discriminant,cases }=ast;
 retArr.push('switch (');
 this.astGeneric(discriminant,retArr);
 retArr.push(') {\n');
 for (let i=0; i < cases.length; i++) {
if (cases[i].test === null) {
retArr.push('default:\n');
this.astGeneric(cases[i].consequent,retArr);
if (cases[i].consequent && cases[i].consequent.length > 0) {
retArr.push('break;\n');
}
continue;
}
retArr.push('case ');
this.astGeneric(cases[i].test,retArr);
retArr.push(':\n');
if (cases[i].consequent && cases[i].consequent.length > 0) {
this.astGeneric(cases[i].consequent,retArr);
retArr.push('break;\n');
}
 }
 retArr.push('\n}');
 }

 astThisExpression(tNode,retArr) {
 retArr.push('_this');
 return retArr;
 }

 astMemberExpression(mNode,retArr) {
 const {
signature,
type,
property,
xProperty,
yProperty,
zProperty,
name,
origin
 }=this.getMemberExpressionDetails(mNode);
 switch (signature) {
case 'this.thread.value':
retArr.push(`_this.thread.${ name }`);
return retArr;
case 'this.output.value':
switch (name) {
case 'x':
retArr.push('outputX');
break;
case 'y':
retArr.push('outputY');
break;
case 'z':
retArr.push('outputZ');
break;
default:
throw this.astErrorOutput('Unexpected expression',mNode);
}
return retArr;
case 'value':
throw this.astErrorOutput('Unexpected expression',mNode);
case 'value[]':
case 'value[][]':
case 'value[][][]':
case 'value.value':
if (origin === 'Math') {
retArr.push(Math[name]);
return retArr;
}
switch (property) {
case 'r':
retArr.push(`user_${ name }[0]`);
return retArr;
case 'g':
retArr.push(`user_${ name }[1]`);
return retArr;
case 'b':
retArr.push(`user_${ name }[2]`);
return retArr;
case 'a':
retArr.push(`user_${ name }[3]`);
return retArr;
}
break;
case 'this.constants.value':
case 'this.constants.value[]':
case 'this.constants.value[][]':
case 'this.constants.value[][][]':
break;
case 'fn()[]':
this.astGeneric(mNode.object,retArr);
retArr.push('[');
this.astGeneric(mNode.property,retArr);
retArr.push(']');
return retArr;
case 'fn()[][]':
this.astGeneric(mNode.object.object,retArr);
retArr.push('[');
this.astGeneric(mNode.object.property,retArr);
retArr.push(']');
retArr.push('[');
this.astGeneric(mNode.property,retArr);
retArr.push(']');
return retArr;
default:
throw this.astErrorOutput('Unexpected expression',mNode);
 }

 if (!mNode.computed) {
switch (type) {
case 'Number':
case 'Integer':
case 'Float':
case 'Boolean':
retArr.push(`${origin}_${name}`);
return retArr;
}
 }

 const markupName=`${origin}_${name}`;

 switch (type) {
case 'Array(2)':
case 'Array(3)':
case 'Array(4)':
case 'Matrix(2)':
case 'Matrix(3)':
case 'Matrix(4)':
case 'HTMLImageArray':
case 'ArrayTexture(1)':
case 'ArrayTexture(2)':
case 'ArrayTexture(3)':
case 'ArrayTexture(4)':
case 'HTMLImage':
default:
let size;
let isInput;
if (origin === 'constants') {
const constant=this.constants[name];
isInput=this.constantTypes[name] === 'Input';
size=isInput ? constant.size : null;
} else {
isInput=this.isInput(name);
size=isInput ? this.argumentSizes[this.argumentNames.indexOf(name)] : null;
}
retArr.push(`${ markupName }`);
if (zProperty && yProperty) {
if (isInput) {
retArr.push('[(');
this.astGeneric(zProperty,retArr);
retArr.push(`*${ this.dynamicArguments ? '(outputY * outputX)' : size[1] * size[0] })+(`);
this.astGeneric(yProperty,retArr);
retArr.push(`*${ this.dynamicArguments ? 'outputX' : size[0] })+`);
this.astGeneric(xProperty,retArr);
retArr.push(']');
} else {
retArr.push('[');
this.astGeneric(zProperty,retArr);
retArr.push(']');
retArr.push('[');
this.astGeneric(yProperty,retArr);
retArr.push(']');
retArr.push('[');
this.astGeneric(xProperty,retArr);
retArr.push(']');
}
} else if (yProperty) {
if (isInput) {
retArr.push('[(');
this.astGeneric(yProperty,retArr);
retArr.push(`*${ this.dynamicArguments ? 'outputX' : size[0] })+`);
this.astGeneric(xProperty,retArr);
retArr.push(']');
} else {
retArr.push('[');
this.astGeneric(yProperty,retArr);
retArr.push(']');
retArr.push('[');
this.astGeneric(xProperty,retArr);
retArr.push(']');
}
} else if (typeof xProperty !== 'undefined') {
retArr.push('[');
this.astGeneric(xProperty,retArr);
retArr.push(']');
}
 }
 return retArr;
 }

 astCallExpression(ast,retArr) {
 if (ast.type !== 'CallExpression') {
throw this.astErrorOutput('Unknown CallExpression',ast);
 }
 let functionName=this.astMemberExpressionUnroll(ast.callee);

 if (this.calledFunctions.indexOf(functionName) < 0) {
this.calledFunctions.push(functionName);
 }

 const isMathFunction=this.isAstMathFunction(ast);

 if (this.onFunctionCall) {
this.onFunctionCall(this.name,functionName,ast.arguments);
 }

 retArr.push(functionName);

 retArr.push('(');
 const targetTypes=this.lookupFunctionArgumentTypes(functionName) || [];
 for (let i=0; i < ast.arguments.length; ++i) {
const argument=ast.arguments[i];

let argumentType=this.getType(argument);
if (!targetTypes[i]) {
this.triggerImplyArgumentType(functionName,i,argumentType,this);
}

if (i > 0) {
retArr.push(',');
}
this.astGeneric(argument,retArr);
 }
 retArr.push(')');

 return retArr;
 }

 astArrayExpression(arrNode,retArr) {
 const returnType=this.getType(arrNode);
 const arrLen=arrNode.elements.length;
 const elements=[];
 for (let i=0; i < arrLen; ++i) {
const element=[];
this.astGeneric(arrNode.elements[i],element);
elements.push(element.join(''));
 }
 switch (returnType) {
case 'Matrix(2)':
case 'Matrix(3)':
case 'Matrix(4)':
retArr.push(`[${elements.join(',')}]`);
break;
default:
retArr.push(`new Float32Array([${elements.join(',')}])`);
 }
 return retArr;
 }

 astDebuggerStatement(arrNode,retArr) {
 retArr.push('debugger;');
 return retArr;
 }
 }

 module.exports={
 CPUFunctionNode
 };
 },{"../function-node":10}],7:[function(require,module,exports){
 const { utils }=require('../../utils');

 function constantsToString(constants,types) {
 const results=[];
 for (const name in types) {
 if (!types.hasOwnProperty(name)) continue;
 const type=types[name];
 const constant=constants[name];
 switch (type) {
case 'Number':
case 'Integer':
case 'Float':
case 'Boolean':
results.push(`${name}:${constant}`);
break;
case 'Array(2)':
case 'Array(3)':
case 'Array(4)':
case 'Matrix(2)':
case 'Matrix(3)':
case 'Matrix(4)':
results.push(`${name}:new ${constant.constructor.name}(${JSON.stringify(Array.from(constant))})`);
break;
 }
 }
 return `{ ${ results.join() } }`;
 }

 function cpuKernelString(cpuKernel,name) {
 const header=[];
 const thisProperties=[];
 const beforeReturn=[];

 const useFunctionKeyword=!/^function/.test(cpuKernel.color.toString());

 header.push(
 ' const { context,canvas,constants: incomingConstants }=settings;',
 ` const output=new Int32Array(${JSON.stringify(Array.from(cpuKernel.output))});`,
 ` const _constantTypes=${JSON.stringify(cpuKernel.constantTypes)};`,
 ` const _constants=${constantsToString(cpuKernel.constants,cpuKernel.constantTypes)};`
 );

 thisProperties.push(
 ' constants: _constants,',
 ' context,',
 ' output,',
 ' thread: {x: 0,y: 0,z: 0},'
 );

 if (cpuKernel.graphical) {
 header.push(` const _imageData=context.createImageData(${cpuKernel.output[0]},${cpuKernel.output[1]});`);
 header.push(` const _colorData=new Uint8ClampedArray(${cpuKernel.output[0]} * ${cpuKernel.output[1]} * 4);`);

 const colorFn=utils.flattenFunctionToString((useFunctionKeyword ? 'function ' : '') + cpuKernel.color.toString(),{
thisLookup: (propertyName) => {
switch (propertyName) {
case '_colorData':
return '_colorData';
case '_imageData':
return '_imageData';
case 'output':
return 'output';
case 'thread':
return 'this.thread';
}
return JSON.stringify(cpuKernel[propertyName]);
},
findDependency: (object,name) => {
return null;
}
 });

 const getPixelsFn=utils.flattenFunctionToString((useFunctionKeyword ? 'function ' : '') + cpuKernel.getPixels.toString(),{
thisLookup: (propertyName) => {
switch (propertyName) {
case '_colorData':
return '_colorData';
case '_imageData':
return '_imageData';
case 'output':
return 'output';
case 'thread':
return 'this.thread';
}
return JSON.stringify(cpuKernel[propertyName]);
},
findDependency: () => {
return null;
}
 });

 thisProperties.push(
' _imageData,',
' _colorData,',
` color: ${colorFn},`
 );

 beforeReturn.push(
` kernel.getPixels=${getPixelsFn};`
 );
 }

 const constantTypes=[];
 const constantKeys=Object.keys(cpuKernel.constantTypes);
 for (let i=0; i < constantKeys.length; i++) {
 constantTypes.push(cpuKernel.constantTypes[constantKeys]);
 }
 if (cpuKernel.argumentTypes.indexOf('HTMLImageArray') !== -1 || constantTypes.indexOf('HTMLImageArray') !== -1) {
 const flattenedImageTo3DArray=utils.flattenFunctionToString((useFunctionKeyword ? 'function ' : '') + cpuKernel._imageTo3DArray.toString(),{
doNotDefine: ['canvas'],
findDependency: (object,name) => {
if (object === 'this') {
return (useFunctionKeyword ? 'function ' : '') + cpuKernel[name].toString();
}
return null;
},
thisLookup: (propertyName) => {
switch (propertyName) {
case 'canvas':
return;
case 'context':
return 'context';
}
}
 });
 beforeReturn.push(flattenedImageTo3DArray);
 thisProperties.push(` _mediaTo2DArray,`);
 thisProperties.push(` _imageTo3DArray,`);
 } else if (cpuKernel.argumentTypes.indexOf('HTMLImage') !== -1 || constantTypes.indexOf('HTMLImage') !== -1) {
 const flattenedImageTo2DArray=utils.flattenFunctionToString((useFunctionKeyword ? 'function ' : '') + cpuKernel._mediaTo2DArray.toString(),{
findDependency: (object,name) => {
return null;
},
thisLookup: (propertyName) => {
switch (propertyName) {
case 'canvas':
return 'settings.canvas';
case 'context':
return 'settings.context';
}
throw new Error('unhandled thisLookup');
}
 });
 beforeReturn.push(flattenedImageTo2DArray);
 thisProperties.push(` _mediaTo2DArray,`);
 }

 return `function(settings) {
${ header.join('\n') }
 for (const p in _constantTypes) {
 if (!_constantTypes.hasOwnProperty(p)) continue;
 const type=_constantTypes[p];
 switch (type) {
 case 'Number':
 case 'Integer':
 case 'Float':
 case 'Boolean':
 case 'Array(2)':
 case 'Array(3)':
 case 'Array(4)':
 case 'Matrix(2)':
 case 'Matrix(3)':
 case 'Matrix(4)':
 if (incomingConstants.hasOwnProperty(p)) {
 console.warn('constant ' + p + ' of type ' + type + ' cannot be resigned');
 }
 continue;
 }
 if (!incomingConstants.hasOwnProperty(p)) {
 throw new Error('constant ' + p + ' not found');
 }
 _constants[p]=incomingConstants[p];
 }
 const kernel=(function() {
${cpuKernel._kernelString}
 })
 .apply({ ${thisProperties.join('\n')} });
 ${ beforeReturn.join('\n') }
 return kernel;
}`;
 }

 module.exports={
 cpuKernelString
 };
 },{"../../utils":114}],8:[function(require,module,exports){
 const { Kernel }=require('../kernel');
 const { FunctionBuilder }=require('../function-builder');
 const { CPUFunctionNode }=require('./function-node');
 const { utils }=require('../../utils');
 const { cpuKernelString }=require('./kernel-string');

 class CPUKernel extends Kernel {
 static getFeatures() {
 return this.features;
 }
 static get features() {
 return Object.freeze({
kernelMap: true,
isIntegerDivisionAccurate: true
 });
 }
 static get isSupported() {
 return true;
 }
 static isContextMatch(context) {
 return false;
 }
 static get mode() {
 return 'cpu';
 }

 static nativeFunctionArguments() {
 return null;
 }

 static nativeFunctionReturnType() {
 throw new Error(`Looking up native function return type not supported on ${this.name}`);
 }

 static combineKernels(combinedKernel) {
 return combinedKernel;
 }

 static getSignature(kernel,argumentTypes) {
 return 'cpu' + (argumentTypes.length > 0 ? ':' + argumentTypes.join(',') : '');
 }

 constructor(source,settings) {
 super(source,settings);
 this.mergeSettings(source.settings || settings);

 this._imageData=null;
 this._colorData=null;
 this._kernelString=null;
 this._prependedString=[];
 this.thread={
x: 0,
y: 0,
z: 0
 };
 this.translatedSources=null;
 }

 initCanvas() {
 if (typeof document !== 'undefined') {
return document.createElement('canvas');
 } else if (typeof OffscreenCanvas !== 'undefined') {
return new OffscreenCanvas(0,0);
 }
 }

 initContext() {
 if (!this.canvas) return null;
 return this.canvas.getContext('2d');
 }

 initPlugins(settings) {
 return [];
 }

 validateSettings(args) {
 if (!this.output || this.output.length === 0) {
if (args.length !== 1) {
throw new Error('Auto output only supported for kernels with only one input');
}

const argType=utils.getVariableType(args[0],this.strictIntegers);
if (argType === 'Array') {
this.output=utils.getDimensions(argType);
} else if (argType === 'NumberTexture' || argType === 'ArrayTexture(4)') {
this.output=args[0].output;
} else {
throw new Error('Auto output not supported for input type: ' + argType);
}
 }

 if (this.graphical) {
if (this.output.length !== 2) {
throw new Error('Output must have 2 dimensions on graphical mode');
}
 }

 this.checkOutput();
 }

 translateSource() {
 this.leadingReturnStatement=this.output.length > 1 ? 'resultX[x]=' : 'result[x]=';
 if (this.subKernels) {
const followingReturnStatement=[];
for (let i=0; i < this.subKernels.length; i++) {
const {
name
}=this.subKernels[i];
followingReturnStatement.push(this.output.length > 1 ? `resultX_${ name }[x]=subKernelResult_${ name };\n` : `result_${ name }[x]=subKernelResult_${ name };\n`);
}
this.followingReturnStatement=followingReturnStatement.join('');
 }
 const functionBuilder=FunctionBuilder.fromKernel(this,CPUFunctionNode);
 this.translatedSources=functionBuilder.getPrototypes('kernel');
 if (!this.graphical && !this.returnType) {
this.returnType=functionBuilder.getKernelResultType();
 }
 }

 build() {
 if (this.built) return;
 this.setupConstants();
 this.setupArguments(arguments);
 this.validateSettings(arguments);
 this.translateSource();

 if (this.graphical) {
const {
canvas,
output
}=this;
if (!canvas) {
throw new Error('no canvas available for using graphical output');
}
const width=output[0];
const height=output[1] || 1;
canvas.width=width;
canvas.height=height;
this._imageData=this.context.createImageData(width,height);
this._colorData=new Uint8ClampedArray(width * height * 4);
 }

 const kernelString=this.getKernelString();
 this.kernelString=kernelString;

 if (this.debug) {
console.log('Function output:');
console.log(kernelString);
 }

 try {
this.run=new Function([],kernelString).bind(this)();
 } catch (e) {
console.error('An error occurred compiling the javascript: ',e);
 }
 this.buildSignature(arguments);
 this.built=true;
 }

 color(r,g,b,a) {
 if (typeof a === 'undefined') {
a=1;
 }

 r=Math.floor(r * 255);
 g=Math.floor(g * 255);
 b=Math.floor(b * 255);
 a=Math.floor(a * 255);

 const width=this.output[0];
 const height=this.output[1];

 const x=this.thread.x;
 const y=height - this.thread.y - 1;

 const index=x + y * width;

 this._colorData[index * 4 + 0]=r;
 this._colorData[index * 4 + 1]=g;
 this._colorData[index * 4 + 2]=b;
 this._colorData[index * 4 + 3]=a;
 }

 getKernelString() {
 if (this._kernelString !== null) return this._kernelString;

 let kernelThreadString=null;
 let {
translatedSources
 }=this;
 if (translatedSources.length > 1) {
translatedSources=translatedSources.filter(fn => {
if (/^function/.test(fn)) return fn;
kernelThreadString=fn;
return false;
});
 } else {
kernelThreadString=translatedSources.shift();
 }
 return this._kernelString=` const LOOP_MAX=${ this._getLoopMaxString() };
 ${ this.injectedNative || '' }
 const _this=this;
 ${ this._resultKernelHeader() }
 ${ this._processConstants() }
 return (${ this.argumentNames.map(argumentName => 'user_' + argumentName).join(',') }) => {
 ${ this._prependedString.join('') }
 ${ this._earlyThrows() }
 ${ this._processArguments() }
 ${ this.graphical ? this._graphicalKernelBody(kernelThreadString) : this._resultKernelBody(kernelThreadString) }
 ${ translatedSources.length > 0 ? translatedSources.join('\n') : '' }
 };`;
 }

 toString() {
 return cpuKernelString(this);
 }

 _getLoopMaxString() {
 return (
this.loopMaxIterations ?
` ${ parseInt(this.loopMaxIterations) };` :
' 1000;'
 );
 }

 _processConstants() {
 if (!this.constants) return '';

 const result=[];
 for (let p in this.constants) {
const type=this.constantTypes[p];
switch (type) {
case 'HTMLCanvas':
case 'OffscreenCanvas':
case 'HTMLImage':
case 'ImageBitmap':
case 'ImageData':
case 'HTMLVideo':
result.push(` const constants_${p}=this._mediaTo2DArray(this.constants.${p});\n`);
break;
case 'HTMLImageArray':
result.push(` const constants_${p}=this._imageTo3DArray(this.constants.${p});\n`);
break;
case 'Input':
result.push(` const constants_${p}=this.constants.${p}.value;\n`);
break;
default:
result.push(` const constants_${p}=this.constants.${p};\n`);
}
 }
 return result.join('');
 }

 _earlyThrows() {
 if (this.graphical) return '';
 if (this.immutable) return '';
 if (!this.pipeline) return '';
 const arrayArguments=[];
 for (let i=0; i < this.argumentTypes.length; i++) {
if (this.argumentTypes[i] === 'Array') {
arrayArguments.push(this.argumentNames[i]);
}
 }
 if (arrayArguments.length === 0) return '';
 const checks=[];
 for (let i=0; i < arrayArguments.length; i++) {
const argumentName=arrayArguments[i];
const checkSubKernels=this._mapSubKernels(subKernel => `user_${argumentName} === result_${subKernel.name}`).join(' || ');
checks.push(`user_${argumentName} === result${checkSubKernels ? ` || ${checkSubKernels}` : ''}`);
 }
 return `if (${checks.join(' || ')}) throw new Error('Source and destination arrays are the same. Use immutable=true');`;
 }

 _processArguments() {
 const result=[];
 for (let i=0; i < this.argumentTypes.length; i++) {
const variableName=`user_${this.argumentNames[i]}`;
switch (this.argumentTypes[i]) {
case 'HTMLCanvas':
case 'OffscreenCanvas':
case 'HTMLImage':
case 'ImageBitmap':
case 'ImageData':
case 'HTMLVideo':
result.push(` ${variableName}=this._mediaTo2DArray(${variableName});\n`);
break;
case 'HTMLImageArray':
result.push(` ${variableName}=this._imageTo3DArray(${variableName});\n`);
break;
case 'Input':
result.push(` ${variableName}=${variableName}.value;\n`);
break;
case 'ArrayTexture(1)':
case 'ArrayTexture(2)':
case 'ArrayTexture(3)':
case 'ArrayTexture(4)':
case 'NumberTexture':
case 'MemoryOptimizedNumberTexture':
result.push(`
 if (${variableName}.toArray) {
 if (!_this.textureCache) {
 _this.textureCache=[];
 _this.arrayCache=[];
 }
 const textureIndex=_this.textureCache.indexOf(${variableName});
 if (textureIndex !== -1) {
 ${variableName}=_this.arrayCache[textureIndex];
 } else {
 _this.textureCache.push(${variableName});
 ${variableName}=${variableName}.toArray();
 _this.arrayCache.push(${variableName});
 }
 }`);
break;
}
 }
 return result.join('');
 }

 _mediaTo2DArray(media) {
 const canvas=this.canvas;
 const width=media.width > 0 ? media.width : media.videoWidth;
 const height=media.height > 0 ? media.height : media.videoHeight;
 if (canvas.width < width) {
canvas.width=width;
 }
 if (canvas.height < height) {
canvas.height=height;
 }
 const ctx=this.context;
 let pixelsData;
 if (media.constructor === ImageData) {
pixelsData=media.data;
 } else {
ctx.drawImage(media,0,0,width,height);
pixelsData=ctx.getImageData(0,0,width,height).data;
 }
 const imageArray=new Array(height);
 let index=0;
 for (let y=height - 1; y >= 0; y--) {
const row=imageArray[y]=new Array(width);
for (let x=0; x < width; x++) {
const pixel=new Float32Array(4);
pixel[0]=pixelsData[index++] / 255;
pixel[1]=pixelsData[index++] / 255;
pixel[2]=pixelsData[index++] / 255;
pixel[3]=pixelsData[index++] / 255;
row[x]=pixel;
}
 }
 return imageArray;
 }

 getPixels(flip) {
 const [width,height]=this.output;
 return flip ? utils.flipPixels(this._imageData.data,width,height) : this._imageData.data.slice(0);
 }

 _imageTo3DArray(images) {
 const imagesArray=new Array(images.length);
 for (let i=0; i < images.length; i++) {
imagesArray[i]=this._mediaTo2DArray(images[i]);
 }
 return imagesArray;
 }

 _resultKernelHeader() {
 if (this.graphical) return '';
 if (this.immutable) return '';
 if (!this.pipeline) return '';
 switch (this.output.length) {
case 1:
return this._mutableKernel1DResults();
case 2:
return this._mutableKernel2DResults();
case 3:
return this._mutableKernel3DResults();
 }
 }

 _resultKernelBody(kernelString) {
 switch (this.output.length) {
case 1:
return (!this.immutable && this.pipeline ? this._resultMutableKernel1DLoop(kernelString) : this._resultImmutableKernel1DLoop(kernelString)) + this._kernelOutput();
case 2:
return (!this.immutable && this.pipeline ? this._resultMutableKernel2DLoop(kernelString) : this._resultImmutableKernel2DLoop(kernelString)) + this._kernelOutput();
case 3:
return (!this.immutable && this.pipeline ? this._resultMutableKernel3DLoop(kernelString) : this._resultImmutableKernel3DLoop(kernelString)) + this._kernelOutput();
default:
throw new Error('unsupported size kernel');
 }
 }

 _graphicalKernelBody(kernelThreadString) {
 switch (this.output.length) {
case 2:
return this._graphicalKernel2DLoop(kernelThreadString) + this._graphicalOutput();
default:
throw new Error('unsupported size kernel');
 }
 }

 _graphicalOutput() {
 return `
 this._imageData.data.set(this._colorData);
 this.context.putImageData(this._imageData,0,0);
 return;`
 }

 _getKernelResultTypeConstructorString() {
 switch (this.returnType) {
case 'LiteralInteger':
case 'Number':
case 'Integer':
case 'Float':
return 'Float32Array';
case 'Array(2)':
case 'Array(3)':
case 'Array(4)':
return 'Array';
default:
if (this.graphical) {
return 'Float32Array';
}
throw new Error(`unhandled returnType ${ this.returnType }`);
 }
 }

 _resultImmutableKernel1DLoop(kernelString) {
 const constructorString=this._getKernelResultTypeConstructorString();
 return ` const outputX=_this.output[0];
 const result=new ${constructorString}(outputX);
 ${ this._mapSubKernels(subKernel => `const result_${ subKernel.name }=new ${constructorString}(outputX);\n`).join(' ') }
 ${ this._mapSubKernels(subKernel => `let subKernelResult_${ subKernel.name };\n`).join(' ') }
 for (let x=0; x < outputX; x++) {
 this.thread.x=x;
 this.thread.y=0;
 this.thread.z=0;
 ${ kernelString }
 }`;
 }

 _mutableKernel1DResults() {
 const constructorString=this._getKernelResultTypeConstructorString();
 return ` const outputX=_this.output[0];
 const result=new ${constructorString}(outputX);
 ${ this._mapSubKernels(subKernel => `const result_${ subKernel.name }=new ${constructorString}(outputX);\n`).join(' ') }
 ${ this._mapSubKernels(subKernel => `let subKernelResult_${ subKernel.name };\n`).join(' ') }`;
 }

 _resultMutableKernel1DLoop(kernelString) {
 return ` const outputX=_this.output[0];
 for (let x=0; x < outputX; x++) {
 this.thread.x=x;
 this.thread.y=0;
 this.thread.z=0;
 ${ kernelString }
 }`;
 }

 _resultImmutableKernel2DLoop(kernelString) {
 const constructorString=this._getKernelResultTypeConstructorString();
 return ` const outputX=_this.output[0];
 const outputY=_this.output[1];
 const result=new Array(outputY);
 ${ this._mapSubKernels(subKernel => `const result_${ subKernel.name }=new Array(outputY);\n`).join(' ') }
 ${ this._mapSubKernels(subKernel => `let subKernelResult_${ subKernel.name };\n`).join(' ') }
 for (let y=0; y < outputY; y++) {
 this.thread.z=0;
 this.thread.y=y;
 const resultX=result[y]=new ${constructorString}(outputX);
 ${ this._mapSubKernels(subKernel => `const resultX_${ subKernel.name }=result_${subKernel.name}[y]=new ${constructorString}(outputX);\n`).join('') }
 for (let x=0; x < outputX; x++) {
 this.thread.x=x;
 ${ kernelString }
 }
 }`;
 }

 _mutableKernel2DResults() {
 const constructorString=this._getKernelResultTypeConstructorString();
 return ` const outputX=_this.output[0];
 const outputY=_this.output[1];
 const result=new Array(outputY);
 ${ this._mapSubKernels(subKernel => `const result_${ subKernel.name }=new Array(outputY);\n`).join(' ') }
 ${ this._mapSubKernels(subKernel => `let subKernelResult_${ subKernel.name };\n`).join(' ') }
 for (let y=0; y < outputY; y++) {
 const resultX=result[y]=new ${constructorString}(outputX);
 ${ this._mapSubKernels(subKernel => `const resultX_${ subKernel.name }=result_${subKernel.name}[y]=new ${constructorString}(outputX);\n`).join('') }
 }`;
 }

 _resultMutableKernel2DLoop(kernelString) {
 const constructorString=this._getKernelResultTypeConstructorString();
 return ` const outputX=_this.output[0];
 const outputY=_this.output[1];
 for (let y=0; y < outputY; y++) {
 this.thread.z=0;
 this.thread.y=y;
 const resultX=result[y];
 ${ this._mapSubKernels(subKernel => `const resultX_${ subKernel.name }=result_${subKernel.name}[y]=new ${constructorString}(outputX);\n`).join('') }
 for (let x=0; x < outputX; x++) {
 this.thread.x=x;
 ${ kernelString }
 }
 }`;
 }

 _graphicalKernel2DLoop(kernelString) {
 return ` const outputX=_this.output[0];
 const outputY=_this.output[1];
 for (let y=0; y < outputY; y++) {
 this.thread.z=0;
 this.thread.y=y;
 for (let x=0; x < outputX; x++) {
 this.thread.x=x;
 ${ kernelString }
 }
 }`;
 }

 _resultImmutableKernel3DLoop(kernelString) {
 const constructorString=this._getKernelResultTypeConstructorString();
 return ` const outputX=_this.output[0];
 const outputY=_this.output[1];
 const outputZ=_this.output[2];
 const result=new Array(outputZ);
 ${ this._mapSubKernels(subKernel => `const result_${ subKernel.name }=new Array(outputZ);\n`).join(' ') }
 ${ this._mapSubKernels(subKernel => `let subKernelResult_${ subKernel.name };\n`).join(' ') }
 for (let z=0; z < outputZ; z++) {
 this.thread.z=z;
 const resultY=result[z]=new Array(outputY);
 ${ this._mapSubKernels(subKernel => `const resultY_${ subKernel.name }=result_${subKernel.name}[z]=new Array(outputY);\n`).join(' ') }
 for (let y=0; y < outputY; y++) {
 this.thread.y=y;
 const resultX=resultY[y]=new ${constructorString}(outputX);
 ${ this._mapSubKernels(subKernel => `const resultX_${ subKernel.name }=resultY_${subKernel.name}[y]=new ${constructorString}(outputX);\n`).join(' ') }
 for (let x=0; x < outputX; x++) {
 this.thread.x=x;
 ${ kernelString }
 }
 }
 }`;
 }

 _mutableKernel3DResults() {
 const constructorString=this._getKernelResultTypeConstructorString();
 return ` const outputX=_this.output[0];
 const outputY=_this.output[1];
 const outputZ=_this.output[2];
 const result=new Array(outputZ);
 ${ this._mapSubKernels(subKernel => `const result_${ subKernel.name }=new Array(outputZ);\n`).join(' ') }
 ${ this._mapSubKernels(subKernel => `let subKernelResult_${ subKernel.name };\n`).join(' ') }
 for (let z=0; z < outputZ; z++) {
 const resultY=result[z]=new Array(outputY);
 ${ this._mapSubKernels(subKernel => `const resultY_${ subKernel.name }=result_${subKernel.name}[z]=new Array(outputY);\n`).join(' ') }
 for (let y=0; y < outputY; y++) {
 const resultX=resultY[y]=new ${constructorString}(outputX);
 ${ this._mapSubKernels(subKernel => `const resultX_${ subKernel.name }=resultY_${subKernel.name}[y]=new ${constructorString}(outputX);\n`).join(' ') }
 }
 }`;
 }

 _resultMutableKernel3DLoop(kernelString) {
 return ` const outputX=_this.output[0];
 const outputY=_this.output[1];
 const outputZ=_this.output[2];
 for (let z=0; z < outputZ; z++) {
 this.thread.z=z;
 const resultY=result[z];
 for (let y=0; y < outputY; y++) {
 this.thread.y=y;
 const resultX=resultY[y];
 for (let x=0; x < outputX; x++) {
 this.thread.x=x;
 ${ kernelString }
 }
 }
 }`;
 }

 _kernelOutput() {
 if (!this.subKernels) {
return '\n return result;';
 }
 return `\n return {
 result: result,
 ${ this.subKernels.map(subKernel => `${ subKernel.property }: result_${ subKernel.name }`).join(',\n ') }
 };`;
 }

 _mapSubKernels(fn) {
 return this.subKernels === null ? [''] :
this.subKernels.map(fn);
 }

 destroy(removeCanvasReference) {
 if (removeCanvasReference) {
delete this.canvas;
 }
 }

 static destroyContext(context) {}

 toJSON() {
 const json=super.toJSON();
 json.functionNodes=FunctionBuilder.fromKernel(this,CPUFunctionNode).toJSON();
 return json;
 }

 setOutput(output) {
 super.setOutput(output);
 const [width,height]=this.output;
 if (this.graphical) {
this._imageData=this.context.createImageData(width,height);
this._colorData=new Uint8ClampedArray(width * height * 4);
 }
 }

 prependString(value) {
 if (this._kernelString) throw new Error('Kernel already built');
 this._prependedString.push(value);
 }

 hasPrependString(value) {
 return this._prependedString.indexOf(value) > -1;
 }
 }

 module.exports={
 CPUKernel
 };
 },{"../../utils":114,"../function-builder":9,"../kernel":36,"./function-node":6,"./kernel-string":7}],9:[function(require,module,exports){
 class FunctionBuilder {
 static fromKernel(kernel,FunctionNode,extraNodeOptions) {
 const {
kernelArguments,
kernelConstants,
argumentNames,
argumentSizes,
argumentBitRatios,
constants,
constantBitRatios,
debug,
loopMaxIterations,
nativeFunctions,
output,
optimizeFloatMemory,
precision,
plugins,
source,
subKernels,
functions,
leadingReturnStatement,
followingReturnStatement,
dynamicArguments,
dynamicOutput,
 }=kernel;

 const argumentTypes=new Array(kernelArguments.length);
 const constantTypes={};

 for (let i=0; i < kernelArguments.length; i++) {
argumentTypes[i]=kernelArguments[i].type;
 }

 for (let i=0; i < kernelConstants.length; i++) {
const kernelConstant=kernelConstants[i];
constantTypes[kernelConstant.name]=kernelConstant.type;
 }

 const needsArgumentType=(functionName,index) => {
return functionBuilder.needsArgumentType(functionName,index);
 };

 const assignArgumentType=(functionName,index,type) => {
functionBuilder.assignArgumentType(functionName,index,type);
 };

 const lookupReturnType=(functionName,ast,requestingNode) => {
return functionBuilder.lookupReturnType(functionName,ast,requestingNode);
 };

 const lookupFunctionArgumentTypes=(functionName) => {
return functionBuilder.lookupFunctionArgumentTypes(functionName);
 };

 const lookupFunctionArgumentName=(functionName,argumentIndex) => {
return functionBuilder.lookupFunctionArgumentName(functionName,argumentIndex);
 };

 const lookupFunctionArgumentBitRatio=(functionName,argumentName) => {
return functionBuilder.lookupFunctionArgumentBitRatio(functionName,argumentName);
 };

 const triggerImplyArgumentType=(functionName,i,argumentType,requestingNode) => {
functionBuilder.assignArgumentType(functionName,i,argumentType,requestingNode);
 };

 const triggerImplyArgumentBitRatio=(functionName,argumentName,calleeFunctionName,argumentIndex) => {
functionBuilder.assignArgumentBitRatio(functionName,argumentName,calleeFunctionName,argumentIndex);
 };

 const onFunctionCall=(functionName,calleeFunctionName,args) => {
functionBuilder.trackFunctionCall(functionName,calleeFunctionName,args);
 };

 const onNestedFunction=(ast,source) => {
const argumentNames=[];
for (let i=0; i < ast.params.length; i++) {
argumentNames.push(ast.params[i].name);
}
const nestedFunction=new FunctionNode(source,Object.assign({},nodeOptions,{
returnType: null,
ast,
name: ast.id.name,
argumentNames,
lookupReturnType,
lookupFunctionArgumentTypes,
lookupFunctionArgumentName,
lookupFunctionArgumentBitRatio,
needsArgumentType,
assignArgumentType,
triggerImplyArgumentType,
triggerImplyArgumentBitRatio,
onFunctionCall,
}));
nestedFunction.traceFunctionAST(ast);
functionBuilder.addFunctionNode(nestedFunction);
 };

 const nodeOptions=Object.assign({
isRootKernel: false,
onNestedFunction,
lookupReturnType,
lookupFunctionArgumentTypes,
lookupFunctionArgumentName,
lookupFunctionArgumentBitRatio,
needsArgumentType,
assignArgumentType,
triggerImplyArgumentType,
triggerImplyArgumentBitRatio,
onFunctionCall,
optimizeFloatMemory,
precision,
constants,
constantTypes,
constantBitRatios,
debug,
loopMaxIterations,
output,
plugins,
dynamicArguments,
dynamicOutput,
 },extraNodeOptions || {});

 const rootNodeOptions=Object.assign({},nodeOptions,{
isRootKernel: true,
name: 'kernel',
argumentNames,
argumentTypes,
argumentSizes,
argumentBitRatios,
leadingReturnStatement,
followingReturnStatement,
 });

 if (typeof source === 'object' && source.functionNodes) {
return new FunctionBuilder().fromJSON(source.functionNodes,FunctionNode);
 }

 const rootNode=new FunctionNode(source,rootNodeOptions);

 let functionNodes=null;
 if (functions) {
functionNodes=functions.map((fn) => new FunctionNode(fn.source,{
returnType: fn.returnType,
argumentTypes: fn.argumentTypes,
output,
plugins,
constants,
constantTypes,
constantBitRatios,
optimizeFloatMemory,
precision,
lookupReturnType,
lookupFunctionArgumentTypes,
lookupFunctionArgumentName,
lookupFunctionArgumentBitRatio,
needsArgumentType,
assignArgumentType,
triggerImplyArgumentType,
triggerImplyArgumentBitRatio,
onFunctionCall,
onNestedFunction,
}));
 }

 let subKernelNodes=null;
 if (subKernels) {
subKernelNodes=subKernels.map((subKernel) => {
const { name,source }=subKernel;
return new FunctionNode(source,Object.assign({},nodeOptions,{
name,
isSubKernel: true,
isRootKernel: false,
}));
});
 }

 const functionBuilder=new FunctionBuilder({
kernel,
rootNode,
functionNodes,
nativeFunctions,
subKernelNodes
 });

 return functionBuilder;
 }

 constructor(settings) {
 settings=settings || {};
 this.kernel=settings.kernel;
 this.rootNode=settings.rootNode;
 this.functionNodes=settings.functionNodes || [];
 this.subKernelNodes=settings.subKernelNodes || [];
 this.nativeFunctions=settings.nativeFunctions || [];
 this.functionMap={};
 this.nativeFunctionNames=[];
 this.lookupChain=[];
 this.functionNodeDependencies={};
 this.functionCalls={};

 if (this.rootNode) {
this.functionMap['kernel']=this.rootNode;
 }

 if (this.functionNodes) {
for (let i=0; i < this.functionNodes.length; i++) {
this.functionMap[this.functionNodes[i].name]=this.functionNodes[i];
}
 }

 if (this.subKernelNodes) {
for (let i=0; i < this.subKernelNodes.length; i++) {
this.functionMap[this.subKernelNodes[i].name]=this.subKernelNodes[i];
}
 }

 if (this.nativeFunctions) {
for (let i=0; i < this.nativeFunctions.length; i++) {
const nativeFunction=this.nativeFunctions[i];
this.nativeFunctionNames.push(nativeFunction.name);
}
 }
 }

 addFunctionNode(functionNode) {
 if (!functionNode.name) throw new Error('functionNode.name needs set');
 this.functionMap[functionNode.name]=functionNode;
 if (functionNode.isRootKernel) {
this.rootNode=functionNode;
 }
 }

 traceFunctionCalls(functionName,retList) {
 functionName=functionName || 'kernel';
 retList=retList || [];

 if (this.nativeFunctionNames.indexOf(functionName) > -1) {
const nativeFunctionIndex=retList.indexOf(functionName);
if (nativeFunctionIndex === -1) {
retList.push(functionName);
} else {
const dependantNativeFunctionName=retList.splice(nativeFunctionIndex,1)[0];
retList.push(dependantNativeFunctionName);
}
return retList;
 }

 const functionNode=this.functionMap[functionName];
 if (functionNode) {
const functionIndex=retList.indexOf(functionName);
if (functionIndex === -1) {
retList.push(functionName);
functionNode.toString();
for (let i=0; i < functionNode.calledFunctions.length; ++i) {
this.traceFunctionCalls(functionNode.calledFunctions[i],retList);
}
} else {
const dependantFunctionName=retList.splice(functionIndex,1)[0];
retList.push(dependantFunctionName);
}
 }

 return retList;
 }

 getPrototypeString(functionName) {
 return this.getPrototypes(functionName).join('\n');
 }

 getPrototypes(functionName) {
 if (this.rootNode) {
this.rootNode.toString();
 }
 if (functionName) {
return this.getPrototypesFromFunctionNames(this.traceFunctionCalls(functionName,[]).reverse());
 }
 return this.getPrototypesFromFunctionNames(Object.keys(this.functionMap));
 }

 getStringFromFunctionNames(functionList) {
 const ret=[];
 for (let i=0; i < functionList.length; ++i) {
const node=this.functionMap[functionList[i]];
if (node) {
ret.push(this.functionMap[functionList[i]].toString());
}
 }
 return ret.join('\n');
 }

 getPrototypesFromFunctionNames(functionList) {
 const ret=[];
 for (let i=0; i < functionList.length; ++i) {
const functionName=functionList[i];
const functionIndex=this.nativeFunctionNames.indexOf(functionName);
if (functionIndex > -1) {
ret.push(this.nativeFunctions[functionIndex].source);
continue;
}
const node=this.functionMap[functionName];
if (node) {
ret.push(node.toString());
}
 }
 return ret;
 }

 toJSON() {
 return this.traceFunctionCalls(this.rootNode.name).reverse().map(name => {
const nativeIndex=this.nativeFunctions.indexOf(name);
if (nativeIndex > -1) {
return {
name,
source: this.nativeFunctions[nativeIndex].source
};
} else if (this.functionMap[name]) {
return this.functionMap[name].toJSON();
} else {
throw new Error(`function ${ name } not found`);
}
 });
 }

 fromJSON(jsonFunctionNodes,FunctionNode) {
 this.functionMap={};
 for (let i=0; i < jsonFunctionNodes.length; i++) {
const jsonFunctionNode=jsonFunctionNodes[i];
this.functionMap[jsonFunctionNode.settings.name]=new FunctionNode(jsonFunctionNode.ast,jsonFunctionNode.settings);
 }
 return this;
 }

 getString(functionName) {
 if (functionName) {
return this.getStringFromFunctionNames(this.traceFunctionCalls(functionName).reverse());
 }
 return this.getStringFromFunctionNames(Object.keys(this.functionMap));
 }

 lookupReturnType(functionName,ast,requestingNode) {
 if (ast.type !== 'CallExpression') {
throw new Error(`expected ast type of "CallExpression",but is ${ ast.type }`);
 }
 if (this._isNativeFunction(functionName)) {
return this._lookupNativeFunctionReturnType(functionName);
 } else if (this._isFunction(functionName)) {
const node=this._getFunction(functionName);
if (node.returnType) {
return node.returnType;
} else {
for (let i=0; i < this.lookupChain.length; i++) {
if (this.lookupChain[i].ast === ast) {
if (node.argumentTypes.length === 0 && ast.arguments.length > 0) {
 const args=ast.arguments;
 for (let j=0; j < args.length; j++) {
 this.lookupChain.push({
 name: requestingNode.name,
 ast: args[i],
 requestingNode
 });
 node.argumentTypes[j]=requestingNode.getType(args[j]);
 this.lookupChain.pop();
 }
 return node.returnType=node.getType(node.getJsAST());
}

throw new Error('circlical logic detected!');
}
}
this.lookupChain.push({
name: requestingNode.name,
ast,
requestingNode
});
const type=node.getType(node.getJsAST());
this.lookupChain.pop();
return node.returnType=type;
}
 }

 return null;
 }

 _getFunction(functionName) {
 if (!this._isFunction(functionName)) {
new Error(`Function ${functionName} not found`);
 }
 return this.functionMap[functionName];
 }

 _isFunction(functionName) {
 return Boolean(this.functionMap[functionName]);
 }

 _getNativeFunction(functionName) {
 for (let i=0; i < this.nativeFunctions.length; i++) {
if (this.nativeFunctions[i].name === functionName) return this.nativeFunctions[i];
 }
 return null;
 }

 _isNativeFunction(functionName) {
 return Boolean(this._getNativeFunction(functionName));
 }

 _lookupNativeFunctionReturnType(functionName) {
 let nativeFunction=this._getNativeFunction(functionName);
 if (nativeFunction) {
return nativeFunction.returnType;
 }
 throw new Error(`Native function ${ functionName } not found`);
 }

 lookupFunctionArgumentTypes(functionName) {
 if (this._isNativeFunction(functionName)) {
return this._getNativeFunction(functionName).argumentTypes;
 } else if (this._isFunction(functionName)) {
return this._getFunction(functionName).argumentTypes;
 }
 return null;
 }

 lookupFunctionArgumentName(functionName,argumentIndex) {
 return this._getFunction(functionName).argumentNames[argumentIndex];
 }

 lookupFunctionArgumentBitRatio(functionName,argumentName) {
 if (!this._isFunction(functionName)) {
throw new Error('function not found');
 }
 if (this.rootNode.name === functionName) {
const i=this.rootNode.argumentNames.indexOf(argumentName);
if (i !== -1) {
return this.rootNode.argumentBitRatios[i];
}
 }
 const node=this._getFunction(functionName);
 const i=node.argumentNames.indexOf(argumentName);
 if (i === -1) {
throw new Error('argument not found');
 }
 const bitRatio=node.argumentBitRatios[i];
 if (typeof bitRatio !== 'number') {
throw new Error('argument bit ratio not found');
 }
 return bitRatio;
 }

 needsArgumentType(functionName,i) {
 if (!this._isFunction(functionName)) return false;
 const fnNode=this._getFunction(functionName);
 return !fnNode.argumentTypes[i];
 }

 assignArgumentType(functionName,i,argumentType,requestingNode) {
 if (!this._isFunction(functionName)) return;
 const fnNode=this._getFunction(functionName);
 if (!fnNode.argumentTypes[i]) {
fnNode.argumentTypes[i]=argumentType;
 }
 }

 assignArgumentBitRatio(functionName,argumentName,calleeFunctionName,argumentIndex) {
 const node=this._getFunction(functionName);
 if (this._isNativeFunction(calleeFunctionName)) return null;
 const calleeNode=this._getFunction(calleeFunctionName);
 const i=node.argumentNames.indexOf(argumentName);
 if (i === -1) {
throw new Error(`Argument ${argumentName} not found in arguments from function ${functionName}`);
 }
 const bitRatio=node.argumentBitRatios[i];
 if (typeof bitRatio !== 'number') {
throw new Error(`Bit ratio for argument ${argumentName} not found in function ${functionName}`);
 }
 if (!calleeNode.argumentBitRatios) {
calleeNode.argumentBitRatios=new Array(calleeNode.argumentNames.length);
 }
 const calleeBitRatio=calleeNode.argumentBitRatios[i];
 if (typeof calleeBitRatio === 'number') {
if (calleeBitRatio !== bitRatio) {
throw new Error(`Incompatible bit ratio found at function ${functionName} at argument ${argumentName}`);
}
return calleeBitRatio;
 }
 calleeNode.argumentBitRatios[i]=bitRatio;
 return bitRatio;
 }

 trackFunctionCall(functionName,calleeFunctionName,args) {
 if (!this.functionNodeDependencies[functionName]) {
this.functionNodeDependencies[functionName]=new Set();
this.functionCalls[functionName]=[];
 }
 this.functionNodeDependencies[functionName].add(calleeFunctionName);
 this.functionCalls[functionName].push(args);
 }

 getKernelResultType() {
 return this.rootNode.returnType || this.rootNode.getType(this.rootNode.ast);
 }

 getSubKernelResultType(index) {
 const subKernelNode=this.subKernelNodes[index];
 let called=false;
 for (let functionCallIndex=0; functionCallIndex < this.rootNode.functionCalls.length; functionCallIndex++) {
const functionCall=this.rootNode.functionCalls[functionCallIndex];
if (functionCall.ast.callee.name === subKernelNode.name) {
called=true;
}
 }
 if (!called) {
throw new Error(`SubKernel ${ subKernelNode.name } never called by kernel`);
 }
 return subKernelNode.returnType || subKernelNode.getType(subKernelNode.getJsAST());
 }

 getReturnTypes() {
 const result={
[this.rootNode.name]: this.rootNode.getType(this.rootNode.ast),
 };
 const list=this.traceFunctionCalls(this.rootNode.name);
 for (let i=0; i < list.length; i++) {
const functionName=list[i];
const functionNode=this.functionMap[functionName];
result[functionName]=functionNode.getType(functionNode.ast);
 }
 return result;
 }
 }

 module.exports={
 FunctionBuilder
 };
 },{}],10:[function(require,module,exports){
 const acorn=require('acorn');
 const { utils }=require('../utils');
 const { FunctionTracer }=require('./function-tracer');

 class FunctionNode {
 constructor(source,settings) {
 if (!source && !settings.ast) {
throw new Error('source parameter is missing');
 }
 settings=settings || {};
 this.source=source;
 this.ast=null;
 this.name=typeof source === 'string' ? settings.isRootKernel ?
'kernel' :
(settings.name || utils.getFunctionNameFromString(source)) : null;
 this.calledFunctions=[];
 this.constants={};
 this.constantTypes={};
 this.constantBitRatios={};
 this.isRootKernel=false;
 this.isSubKernel=false;
 this.debug=null;
 this.functions=null;
 this.identifiers=null;
 this.contexts=null;
 this.functionCalls=null;
 this.states=[];
 this.needsArgumentType=null;
 this.assignArgumentType=null;
 this.lookupReturnType=null;
 this.lookupFunctionArgumentTypes=null;
 this.lookupFunctionArgumentBitRatio=null;
 this.triggerImplyArgumentType=null;
 this.triggerImplyArgumentBitRatio=null;
 this.onNestedFunction=null;
 this.onFunctionCall=null;
 this.optimizeFloatMemory=null;
 this.precision=null;
 this.loopMaxIterations=null;
 this.argumentNames=(typeof this.source === 'string' ? utils.getArgumentNamesFromString(this.source) : null);
 this.argumentTypes=[];
 this.argumentSizes=[];
 this.argumentBitRatios=null;
 this.returnType=null;
 this.output=[];
 this.plugins=null;
 this.leadingReturnStatement=null;
 this.followingReturnStatement=null;
 this.dynamicOutput=null;
 this.dynamicArguments=null;
 this.strictTypingChecking=false;
 this.fixIntegerDivisionAccuracy=null;

 if (settings) {
for (const p in settings) {
if (!settings.hasOwnProperty(p)) continue;
if (!this.hasOwnProperty(p)) continue;
this[p]=settings[p];
}
 }

 this.literalTypes={};

 this.validate();
 this._string=null;
 this._internalVariableNames={};
 }

 validate() {
 if (typeof this.source !== 'string' && !this.ast) {
throw new Error('this.source not a string');
 }

 if (!this.ast && !utils.isFunctionString(this.source)) {
throw new Error('this.source not a function string');
 }

 if (!this.name) {
throw new Error('this.name could not be set');
 }

 if (this.argumentTypes.length > 0 && this.argumentTypes.length !== this.argumentNames.length) {
throw new Error(`argumentTypes count of ${ this.argumentTypes.length } exceeds ${ this.argumentNames.length }`);
 }

 if (this.output.length < 1) {
throw new Error('this.output is not big enough');
 }
 }

 isIdentifierConstant(name) {
 if (!this.constants) return false;
 return this.constants.hasOwnProperty(name);
 }

 isInput(argumentName) {
 return this.argumentTypes[this.argumentNames.indexOf(argumentName)] === 'Input';
 }

 pushState(state) {
 this.states.push(state);
 }

 popState(state) {
 if (this.state !== state) {
throw new Error(`Cannot popState ${ state } when in ${ this.state }`);
 }
 this.states.pop();
 }

 isState(state) {
 return this.state === state;
 }

 get state() {
 return this.states[this.states.length - 1];
 }

 astMemberExpressionUnroll(ast) {
 if (ast.type === 'Identifier') {
return ast.name;
 } else if (ast.type === 'ThisExpression') {
return 'this';
 }

 if (ast.type === 'MemberExpression') {
if (ast.object && ast.property) {
if (ast.object.hasOwnProperty('name') && ast.object.name !== 'Math') {
return this.astMemberExpressionUnroll(ast.property);
}

return (
this.astMemberExpressionUnroll(ast.object) +
'.' +
this.astMemberExpressionUnroll(ast.property)
);
}
 }

 if (ast.hasOwnProperty('expressions')) {
const firstExpression=ast.expressions[0];
if (firstExpression.type === 'Literal' && firstExpression.value === 0 && ast.expressions.length === 2) {
return this.astMemberExpressionUnroll(ast.expressions[1]);
}
 }

 throw this.astErrorOutput('Unknown astMemberExpressionUnroll',ast);
 }

 getJsAST(inParser) {
 if (this.ast) {
return this.ast;
 }
 if (typeof this.source === 'object') {
this.traceFunctionAST(this.source);
return this.ast=this.source;
 }

 inParser=inParser || acorn;
 if (inParser === null) {
throw new Error('Missing JS to AST parser');
 }

 const ast=Object.freeze(inParser.parse(`const parser_${ this.name }=${ this.source };`,{
locations: true
 }));
 const functionAST=ast.body[0].declarations[0].init;
 this.traceFunctionAST(functionAST);

 if (!ast) {
throw new Error('Failed to parse JS code');
 }

 return this.ast=functionAST;
 }

 traceFunctionAST(ast) {
 const { contexts,declarations,functions,identifiers,functionCalls }=new FunctionTracer(ast);
 this.contexts=contexts;
 this.identifiers=identifiers;
 this.functionCalls=functionCalls;
 this.functions=functions;
 for (let i=0; i < declarations.length; i++) {
const declaration=declarations[i];
const { ast,inForLoopInit,inForLoopTest }=declaration;
const { init }=ast;
const dependencies=this.getDependencies(init);
let valueType=null;

if (inForLoopInit && inForLoopTest) {
valueType='Integer';
} else {
if (init) {
const realType=this.getType(init);
switch (realType) {
case 'Integer':
case 'Float':
case 'Number':
 if (init.type === 'MemberExpression') {
 valueType=realType;
 } else {
 valueType='Number';
 }
 break;
case 'LiteralInteger':
 valueType='Number';
 break;
default:
 valueType=realType;
}
}
}
declaration.valueType=valueType;
declaration.dependencies=dependencies;
declaration.isSafe=this.isSafeDependencies(dependencies);
 }

 for (let i=0; i < functions.length; i++) {
this.onNestedFunction(functions[i],this.source);
 }
 }

 getDeclaration(ast) {
 for (let i=0; i < this.identifiers.length; i++) {
const identifier=this.identifiers[i];
if (ast === identifier.ast) {
return identifier.declaration;
}
 }
 return null;
 }

 getVariableType(ast) {
 if (ast.type !== 'Identifier') {
throw new Error(`ast of ${ast.type} not "Identifier"`);
 }
 let type=null;
 const argumentIndex=this.argumentNames.indexOf(ast.name);
 if (argumentIndex === -1) {
const declaration=this.getDeclaration(ast);
if (declaration) {
return declaration.valueType;
}
 } else {
const argumentType=this.argumentTypes[argumentIndex];
if (argumentType) {
type=argumentType;
}
 }
 if (!type && this.strictTypingChecking) {
throw new Error(`Declaration of ${name} not found`);
 }
 return type;
 }

 getLookupType(type) {
 if (!typeLookupMap.hasOwnProperty(type)) {
throw new Error(`unknown typeLookupMap ${ type }`);
 }
 return typeLookupMap[type];
 }

 getConstantType(constantName) {
 if (this.constantTypes[constantName]) {
const type=this.constantTypes[constantName];
if (type === 'Float') {
return 'Number';
} else {
return type;
}
 }
 throw new Error(`Type for constant "${ constantName }" not declared`);
 }

 toString() {
 if (this._string) return this._string;
 return this._string=this.astGeneric(this.getJsAST(),[]).join('').trim();
 }

 toJSON() {
 const settings={
source: this.source,
name: this.name,
constants: this.constants,
constantTypes: this.constantTypes,
isRootKernel: this.isRootKernel,
isSubKernel: this.isSubKernel,
debug: this.debug,
output: this.output,
loopMaxIterations: this.loopMaxIterations,
argumentNames: this.argumentNames,
argumentTypes: this.argumentTypes,
argumentSizes: this.argumentSizes,
returnType: this.returnType,
leadingReturnStatement: this.leadingReturnStatement,
followingReturnStatement: this.followingReturnStatement,
 };

 return {
ast: this.ast,
settings
 };
 }

 getType(ast) {
 if (Array.isArray(ast)) {
return this.getType(ast[ast.length - 1]);
 }
 switch (ast.type) {
case 'BlockStatement':
return this.getType(ast.body);
case 'ArrayExpression':
const childType=this.getType(ast.elements[0]);
switch (childType) {
case 'Array(2)':
case 'Array(3)':
case 'Array(4)':
return `Matrix(${ast.elements.length})`;
}
return `Array(${ ast.elements.length })`;
case 'Literal':
const literalKey=this.astKey(ast);
if (this.literalTypes[literalKey]) {
return this.literalTypes[literalKey];
}
if (Number.isInteger(ast.value)) {
return 'LiteralInteger';
} else if (ast.value === true || ast.value === false) {
return 'Boolean';
} else {
return 'Number';
}
case 'AssignmentExpression':
return this.getType(ast.left);
case 'CallExpression':
if (this.isAstMathFunction(ast)) {
return 'Number';
}
if (!ast.callee || !ast.callee.name) {
if (ast.callee.type === 'SequenceExpression' && ast.callee.expressions[ast.callee.expressions.length - 1].property.name) {
const functionName=ast.callee.expressions[ast.callee.expressions.length - 1].property.name;
this.inferArgumentTypesIfNeeded(functionName,ast.arguments);
return this.lookupReturnType(functionName,ast,this);
}
if (this.getVariableSignature(ast.callee,true) === 'this.color') {
return null;
}
if (ast.callee.type === 'MemberExpression' && ast.callee.object && ast.callee.property && ast.callee.property.name && ast.arguments) {
const functionName=ast.callee.property.name;
this.inferArgumentTypesIfNeeded(functionName,ast.arguments);
return this.lookupReturnType(functionName,ast,this);
}
throw this.astErrorOutput('Unknown call expression',ast);
}
if (ast.callee && ast.callee.name) {
const functionName=ast.callee.name;
this.inferArgumentTypesIfNeeded(functionName,ast.arguments);
return this.lookupReturnType(functionName,ast,this);
}
throw this.astErrorOutput(`Unhandled getType Type "${ ast.type }"`,ast);
case 'LogicalExpression':
return 'Boolean';
case 'BinaryExpression':
switch (ast.operator) {
case '%':
case '/':
if (this.fixIntegerDivisionAccuracy) {
 return 'Number';
} else {
 break;
}
case '>':
case '<':
return 'Boolean';
case '&':
case '|':
case '^':
case '<<':
case '>>':
case '>>>':
return 'Integer';
}
const type=this.getType(ast.left);
if (this.isState('skip-literal-correction')) return type;
if (type === 'LiteralInteger') {
const rightType=this.getType(ast.right);
if (rightType === 'LiteralInteger') {
if (ast.left.value % 1 === 0) {
 return 'Integer';
} else {
 return 'Float';
}
}
return rightType;
}
return typeLookupMap[type] || type;
case 'UpdateExpression':
return this.getType(ast.argument);
case 'UnaryExpression':
if (ast.operator === '~') {
return 'Integer';
}
return this.getType(ast.argument);
case 'VariableDeclaration': {
const declarations=ast.declarations;
let lastType;
for (let i=0; i < declarations.length; i++) {
const declaration=declarations[i];
lastType=this.getType(declaration);
}
if (!lastType) {
throw this.astErrorOutput(`Unable to find type for declaration`,ast);
}
return lastType;
}
case 'VariableDeclarator':
const declaration=this.getDeclaration(ast.id);
if (!declaration) {
throw this.astErrorOutput(`Unable to find declarator`,ast);
}

if (!declaration.valueType) {
throw this.astErrorOutput(`Unable to find declarator valueType`,ast);
}

return declaration.valueType;
case 'Identifier':
if (ast.name === 'Infinity') {
return 'Number';
}
if (this.isAstVariable(ast)) {
const signature=this.getVariableSignature(ast);
if (signature === 'value') {
return this.getCheckVariableType(ast);
}
}
const origin=this.findIdentifierOrigin(ast);
if (origin && origin.init) {
return this.getType(origin.init);
}
return null;
case 'ReturnStatement':
return this.getType(ast.argument);
case 'MemberExpression':
if (this.isAstMathFunction(ast)) {
switch (ast.property.name) {
case 'ceil':
 return 'Integer';
case 'floor':
 return 'Integer';
case 'round':
 return 'Integer';
}
return 'Number';
}
if (this.isAstVariable(ast)) {
const variableSignature=this.getVariableSignature(ast);
switch (variableSignature) {
case 'value[]':
 return this.getLookupType(this.getCheckVariableType(ast.object));
case 'value[][]':
 return this.getLookupType(this.getCheckVariableType(ast.object.object));
case 'value[][][]':
 return this.getLookupType(this.getCheckVariableType(ast.object.object.object));
case 'value[][][][]':
 return this.getLookupType(this.getCheckVariableType(ast.object.object.object.object));
case 'value.thread.value':
case 'this.thread.value':
 return 'Integer';
case 'this.output.value':
 return this.dynamicOutput ? 'Integer' : 'LiteralInteger';
case 'this.constants.value':
 return this.getConstantType(ast.property.name);
case 'this.constants.value[]':
 return this.getLookupType(this.getConstantType(ast.object.property.name));
case 'this.constants.value[][]':
 return this.getLookupType(this.getConstantType(ast.object.object.property.name));
case 'this.constants.value[][][]':
 return this.getLookupType(this.getConstantType(ast.object.object.object.property.name));
case 'this.constants.value[][][][]':
 return this.getLookupType(this.getConstantType(ast.object.object.object.object.property.name));
case 'fn()[]':
case 'fn()[][]':
case 'fn()[][][]':
 return this.getLookupType(this.getType(ast.object));
case 'value.value':
 if (this.isAstMathVariable(ast)) {
 return 'Number';
 }
 switch (ast.property.name) {
 case 'r':
 case 'g':
 case 'b':
 case 'a':
 return this.getLookupType(this.getCheckVariableType(ast.object));
 }
case '[][]':
 return 'Number';
}
throw this.astErrorOutput('Unhandled getType MemberExpression',ast);
}
throw this.astErrorOutput('Unhandled getType MemberExpression',ast);
case 'ConditionalExpression':
return this.getType(ast.consequent);
case 'FunctionDeclaration':
case 'FunctionExpression':
const lastReturn=this.findLastReturn(ast.body);
if (lastReturn) {
return this.getType(lastReturn);
}
return null;
case 'IfStatement':
return this.getType(ast.consequent);
case 'SequenceExpression':
return this.getType(ast.expressions[ast.expressions.length - 1]);
default:
throw this.astErrorOutput(`Unhandled getType Type "${ ast.type }"`,ast);
 }
 }

 getCheckVariableType(ast) {
 const type=this.getVariableType(ast);
 if (!type) {
throw this.astErrorOutput(`${ast.type} is not defined`,ast);
 }
 return type;
 }

 inferArgumentTypesIfNeeded(functionName,args) {
 for (let i=0; i < args.length; i++) {
if (!this.needsArgumentType(functionName,i)) continue;
const type=this.getType(args[i]);
if (!type) {
throw this.astErrorOutput(`Unable to infer argument ${i}`,args[i]);
}
this.assignArgumentType(functionName,i,type);
 }
 }

 isAstMathVariable(ast) {
 const mathProperties=[
'E',
'PI',
'SQRT2',
'SQRT1_2',
'LN2',
'LN10',
'LOG2E',
'LOG10E',
 ];
 return ast.type === 'MemberExpression' &&
ast.object && ast.object.type === 'Identifier' &&
ast.object.name === 'Math' &&
ast.property &&
ast.property.type === 'Identifier' &&
mathProperties.indexOf(ast.property.name) > -1;
 }

 isAstMathFunction(ast) {
 const mathFunctions=[
'abs',
'acos',
'acosh',
'asin',
'asinh',
'atan',
'atan2',
'atanh',
'cbrt',
'ceil',
'clz32',
'cos',
'cosh',
'expm1',
'exp',
'floor',
'fround',
'imul',
'log',
'log2',
'log10',
'log1p',
'max',
'min',
'pow',
'random',
'round',
'sign',
'sin',
'sinh',
'sqrt',
'tan',
'tanh',
'trunc',
 ];
 return ast.type === 'CallExpression' &&
ast.callee &&
ast.callee.type === 'MemberExpression' &&
ast.callee.object &&
ast.callee.object.type === 'Identifier' &&
ast.callee.object.name === 'Math' &&
ast.callee.property &&
ast.callee.property.type === 'Identifier' &&
mathFunctions.indexOf(ast.callee.property.name) > -1;
 }

 isAstVariable(ast) {
 return ast.type === 'Identifier' || ast.type === 'MemberExpression';
 }

 isSafe(ast) {
 return this.isSafeDependencies(this.getDependencies(ast));
 }

 isSafeDependencies(dependencies) {
 return dependencies && dependencies.every ? dependencies.every(dependency => dependency.isSafe) : true;
 }

 getDependencies(ast,dependencies,isNotSafe) {
 if (!dependencies) {
dependencies=[];
 }
 if (!ast) return null;
 if (Array.isArray(ast)) {
for (let i=0; i < ast.length; i++) {
this.getDependencies(ast[i],dependencies,isNotSafe);
}
return dependencies;
 }
 switch (ast.type) {
case 'AssignmentExpression':
this.getDependencies(ast.left,dependencies,isNotSafe);
this.getDependencies(ast.right,dependencies,isNotSafe);
return dependencies;
case 'ConditionalExpression':
this.getDependencies(ast.test,dependencies,isNotSafe);
this.getDependencies(ast.alternate,dependencies,isNotSafe);
this.getDependencies(ast.consequent,dependencies,isNotSafe);
return dependencies;
case 'Literal':
dependencies.push({
origin: 'literal',
value: ast.value,
isSafe: isNotSafe === true ? false : ast.value > -Infinity && ast.value < Infinity && !isNaN(ast.value)
});
break;
case 'VariableDeclarator':
return this.getDependencies(ast.init,dependencies,isNotSafe);
case 'Identifier':
const declaration=this.getDeclaration(ast);
if (declaration) {
dependencies.push({
name: ast.name,
origin: 'declaration',
isSafe: isNotSafe ? false : this.isSafeDependencies(declaration.dependencies),
});
} else if (this.argumentNames.indexOf(ast.name) > -1) {
dependencies.push({
name: ast.name,
origin: 'argument',
isSafe: false,
});
} else if (this.strictTypingChecking) {
throw new Error(`Cannot find identifier origin "${ast.name}"`);
}
break;
case 'FunctionDeclaration':
return this.getDependencies(ast.body.body[ast.body.body.length - 1],dependencies,isNotSafe);
case 'ReturnStatement':
return this.getDependencies(ast.argument,dependencies);
case 'BinaryExpression':
case 'LogicalExpression':
isNotSafe=(ast.operator === '/' || ast.operator === '*');
this.getDependencies(ast.left,dependencies,isNotSafe);
this.getDependencies(ast.right,dependencies,isNotSafe);
return dependencies;
case 'UnaryExpression':
case 'UpdateExpression':
return this.getDependencies(ast.argument,dependencies,isNotSafe);
case 'VariableDeclaration':
return this.getDependencies(ast.declarations,dependencies,isNotSafe);
case 'ArrayExpression':
dependencies.push({
origin: 'declaration',
isSafe: true,
});
return dependencies;
case 'CallExpression':
dependencies.push({
origin: 'function',
isSafe: true,
});
return dependencies;
case 'MemberExpression':
const details=this.getMemberExpressionDetails(ast);
switch (details.signature) {
case 'value[]':
this.getDependencies(ast.object,dependencies,isNotSafe);
break;
case 'value[][]':
this.getDependencies(ast.object.object,dependencies,isNotSafe);
break;
case 'value[][][]':
this.getDependencies(ast.object.object.object,dependencies,isNotSafe);
break;
case 'this.output.value':
if (this.dynamicOutput) {
 dependencies.push({
 name: details.name,
 origin: 'output',
 isSafe: false,
 });
}
break;
}
if (details) {
if (details.property) {
this.getDependencies(details.property,dependencies,isNotSafe);
}
if (details.xProperty) {
this.getDependencies(details.xProperty,dependencies,isNotSafe);
}
if (details.yProperty) {
this.getDependencies(details.yProperty,dependencies,isNotSafe);
}
if (details.zProperty) {
this.getDependencies(details.zProperty,dependencies,isNotSafe);
}
return dependencies;
}
case 'SequenceExpression':
return this.getDependencies(ast.expressions,dependencies,isNotSafe);
default:
throw this.astErrorOutput(`Unhandled type ${ ast.type } in getDependencies`,ast);
 }
 return dependencies;
 }

 getVariableSignature(ast,returnRawValue) {
 if (!this.isAstVariable(ast)) {
throw new Error(`ast of type "${ ast.type }" is not a variable signature`);
 }
 if (ast.type === 'Identifier') {
return 'value';
 }
 const signature=[];
 while (true) {
if (!ast) break;
if (ast.computed) {
signature.push('[]');
} else if (ast.type === 'ThisExpression') {
signature.unshift('this');
} else if (ast.property && ast.property.name) {
if (
ast.property.name === 'x' ||
ast.property.name === 'y' ||
ast.property.name === 'z'
) {
signature.unshift(returnRawValue ? '.' + ast.property.name : '.value');
} else if (
ast.property.name === 'constants' ||
ast.property.name === 'thread' ||
ast.property.name === 'output'
) {
signature.unshift('.' + ast.property.name);
} else {
signature.unshift(returnRawValue ? '.' + ast.property.name : '.value');
}
} else if (ast.name) {
signature.unshift(returnRawValue ? ast.name : 'value');
} else if (ast.callee && ast.callee.name) {
signature.unshift(returnRawValue ? ast.callee.name + '()' : 'fn()');
} else if (ast.elements) {
signature.unshift('[]');
} else {
signature.unshift('unknown');
}
ast=ast.object;
 }

 const signatureString=signature.join('');
 if (returnRawValue) {
return signatureString;
 }

 const allowedExpressions=[
'value',
'value[]',
'value[][]',
'value[][][]',
'value[][][][]',
'value.value',
'value.thread.value',
'this.thread.value',
'this.output.value',
'this.constants.value',
'this.constants.value[]',
'this.constants.value[][]',
'this.constants.value[][][]',
'this.constants.value[][][][]',
'fn()[]',
'fn()[][]',
'fn()[][][]',
'[][]',
 ];
 if (allowedExpressions.indexOf(signatureString) > -1) {
return signatureString;
 }
 return null;
 }

 build() {
 return this.toString().length > 0;
 }

 astGeneric(ast,retArr) {
 if (ast === null) {
throw this.astErrorOutput('NULL ast',ast);
 } else {
if (Array.isArray(ast)) {
for (let i=0; i < ast.length; i++) {
this.astGeneric(ast[i],retArr);
}
return retArr;
}

switch (ast.type) {
case 'FunctionDeclaration':
return this.astFunctionDeclaration(ast,retArr);
case 'FunctionExpression':
return this.astFunctionExpression(ast,retArr);
case 'ReturnStatement':
return this.astReturnStatement(ast,retArr);
case 'Literal':
return this.astLiteral(ast,retArr);
case 'BinaryExpression':
return this.astBinaryExpression(ast,retArr);
case 'Identifier':
return this.astIdentifierExpression(ast,retArr);
case 'AssignmentExpression':
return this.astAssignmentExpression(ast,retArr);
case 'ExpressionStatement':
return this.astExpressionStatement(ast,retArr);
case 'EmptyStatement':
return this.astEmptyStatement(ast,retArr);
case 'BlockStatement':
return this.astBlockStatement(ast,retArr);
case 'IfStatement':
return this.astIfStatement(ast,retArr);
case 'SwitchStatement':
return this.astSwitchStatement(ast,retArr);
case 'BreakStatement':
return this.astBreakStatement(ast,retArr);
case 'ContinueStatement':
return this.astContinueStatement(ast,retArr);
case 'ForStatement':
return this.astForStatement(ast,retArr);
case 'WhileStatement':
return this.astWhileStatement(ast,retArr);
case 'DoWhileStatement':
return this.astDoWhileStatement(ast,retArr);
case 'VariableDeclaration':
return this.astVariableDeclaration(ast,retArr);
case 'VariableDeclarator':
return this.astVariableDeclarator(ast,retArr);
case 'ThisExpression':
return this.astThisExpression(ast,retArr);
case 'SequenceExpression':
return this.astSequenceExpression(ast,retArr);
case 'UnaryExpression':
return this.astUnaryExpression(ast,retArr);
case 'UpdateExpression':
return this.astUpdateExpression(ast,retArr);
case 'LogicalExpression':
return this.astLogicalExpression(ast,retArr);
case 'MemberExpression':
return this.astMemberExpression(ast,retArr);
case 'CallExpression':
return this.astCallExpression(ast,retArr);
case 'ArrayExpression':
return this.astArrayExpression(ast,retArr);
case 'DebuggerStatement':
return this.astDebuggerStatement(ast,retArr);
case 'ConditionalExpression':
return this.astConditionalExpression(ast,retArr);
}

throw this.astErrorOutput('Unknown ast type : ' + ast.type,ast);
 }
 }
 astErrorOutput(error,ast) {
 if (typeof this.source !== 'string') {
return new Error(error);
 }

 const debugString=utils.getAstString(this.source,ast);
 const leadingSource=this.source.substr(ast.start);
 const splitLines=leadingSource.split(/\n/);
 const lineBefore=splitLines.length > 0 ? splitLines[splitLines.length - 1] : 0;
 return new Error(`${error} on line ${ splitLines.length },position ${ lineBefore.length }:\n ${ debugString }`);
 }

 astDebuggerStatement(arrNode,retArr) {
 return retArr;
 }

 astConditionalExpression(ast,retArr) {
 if (ast.type !== 'ConditionalExpression') {
throw this.astErrorOutput('Not a conditional expression',ast);
 }
 retArr.push('(');
 this.astGeneric(ast.test,retArr);
 retArr.push('?');
 this.astGeneric(ast.consequent,retArr);
 retArr.push(':');
 this.astGeneric(ast.alternate,retArr);
 retArr.push(')');
 return retArr;
 }

 astFunction(ast,retArr) {
 throw new Error(`"astFunction" not defined on ${ this.constructor.name }`);
 }

 astFunctionDeclaration(ast,retArr) {
 if (this.isChildFunction(ast)) {
return retArr;
 }
 return this.astFunction(ast,retArr);
 }
 astFunctionExpression(ast,retArr) {
 if (this.isChildFunction(ast)) {
return retArr;
 }
 return this.astFunction(ast,retArr);
 }
 isChildFunction(ast) {
 for (let i=0; i < this.functions.length; i++) {
if (this.functions[i] === ast) {
return true;
}
 }
 return false;
 }
 astReturnStatement(ast,retArr) {
 return retArr;
 }
 astLiteral(ast,retArr) {
 this.literalTypes[this.astKey(ast)]='Number';
 return retArr;
 }
 astBinaryExpression(ast,retArr) {
 return retArr;
 }
 astIdentifierExpression(ast,retArr) {
 return retArr;
 }
 astAssignmentExpression(ast,retArr) {
 return retArr;
 }
 astExpressionStatement(esNode,retArr) {
 this.astGeneric(esNode.expression,retArr);
 retArr.push(';');
 return retArr;
 }
 astEmptyStatement(eNode,retArr) {
 return retArr;
 }
 astBlockStatement(ast,retArr) {
 return retArr;
 }
 astIfStatement(ast,retArr) {
 return retArr;
 }
 astSwitchStatement(ast,retArr) {
 return retArr;
 }
 astBreakStatement(brNode,retArr) {
 retArr.push('break;');
 return retArr;
 }
 astContinueStatement(crNode,retArr) {
 retArr.push('continue;\n');
 return retArr;
 }
 astForStatement(ast,retArr) {
 return retArr;
 }
 astWhileStatement(ast,retArr) {
 return retArr;
 }
 astDoWhileStatement(ast,retArr) {
 return retArr;
 }
 astVariableDeclarator(iVarDecNode,retArr) {
 this.astGeneric(iVarDecNode.id,retArr);
 if (iVarDecNode.init !== null) {
retArr.push('=');
this.astGeneric(iVarDecNode.init,retArr);
 }
 return retArr;
 }
 astThisExpression(ast,retArr) {
 return retArr;
 }
 astSequenceExpression(sNode,retArr) {
 const { expressions }=sNode;
 const sequenceResult=[];
 for (let i=0; i < expressions.length; i++) {
const expression=expressions[i];
const expressionResult=[];
this.astGeneric(expression,expressionResult);
sequenceResult.push(expressionResult.join(''));
 }
 if (sequenceResult.length > 1) {
retArr.push('(',sequenceResult.join(','),')');
 } else {
retArr.push(sequenceResult[0]);
 }
 return retArr;
 }
 astUnaryExpression(uNode,retArr) {
 const unaryResult=this.checkAndUpconvertBitwiseUnary(uNode,retArr);
 if (unaryResult) {
return retArr;
 }

 if (uNode.prefix) {
retArr.push(uNode.operator);
this.astGeneric(uNode.argument,retArr);
 } else {
this.astGeneric(uNode.argument,retArr);
retArr.push(uNode.operator);
 }

 return retArr;
 }

 checkAndUpconvertBitwiseUnary(uNode,retArr) {}

 astUpdateExpression(uNode,retArr) {
 if (uNode.prefix) {
retArr.push(uNode.operator);
this.astGeneric(uNode.argument,retArr);
 } else {
this.astGeneric(uNode.argument,retArr);
retArr.push(uNode.operator);
 }

 return retArr;
 }
 astLogicalExpression(logNode,retArr) {
 retArr.push('(');
 this.astGeneric(logNode.left,retArr);
 retArr.push(logNode.operator);
 this.astGeneric(logNode.right,retArr);
 retArr.push(')');
 return retArr;
 }
 astMemberExpression(ast,retArr) {
 return retArr;
 }
 astCallExpression(ast,retArr) {
 return retArr;
 }
 astArrayExpression(ast,retArr) {
 return retArr;
 }

 getMemberExpressionDetails(ast) {
 if (ast.type !== 'MemberExpression') {
throw this.astErrorOutput(`Expression ${ ast.type } not a MemberExpression`,ast);
 }
 let name=null;
 let type=null;
 const variableSignature=this.getVariableSignature(ast);
 switch (variableSignature) {
case 'value':
return null;
case 'value.thread.value':
case 'this.thread.value':
case 'this.output.value':
return {
signature: variableSignature,
type: 'Integer',
name: ast.property.name
};
case 'value[]':
if (typeof ast.object.name !== 'string') {
throw this.astErrorOutput('Unexpected expression',ast);
}
name=ast.object.name;
return {
name,
origin: 'user',
signature: variableSignature,
type: this.getVariableType(ast.object),
xProperty: ast.property
};
case 'value[][]':
if (typeof ast.object.object.name !== 'string') {
throw this.astErrorOutput('Unexpected expression',ast);
}
name=ast.object.object.name;
return {
name,
origin: 'user',
signature: variableSignature,
type: this.getVariableType(ast.object.object),
yProperty: ast.object.property,
xProperty: ast.property,
};
case 'value[][][]':
if (typeof ast.object.object.object.name !== 'string') {
throw this.astErrorOutput('Unexpected expression',ast);
}
name=ast.object.object.object.name;
return {
name,
origin: 'user',
signature: variableSignature,
type: this.getVariableType(ast.object.object.object),
zProperty: ast.object.object.property,
yProperty: ast.object.property,
xProperty: ast.property,
};
case 'value[][][][]':
if (typeof ast.object.object.object.object.name !== 'string') {
throw this.astErrorOutput('Unexpected expression',ast);
}
name=ast.object.object.object.object.name;
return {
name,
origin: 'user',
signature: variableSignature,
type: this.getVariableType(ast.object.object.object.object),
zProperty: ast.object.object.property,
yProperty: ast.object.property,
xProperty: ast.property,
};
case 'value.value':
if (typeof ast.property.name !== 'string') {
throw this.astErrorOutput('Unexpected expression',ast);
}
if (this.isAstMathVariable(ast)) {
name=ast.property.name;
return {
name,
origin: 'Math',
type: 'Number',
signature: variableSignature,
};
}
switch (ast.property.name) {
case 'r':
case 'g':
case 'b':
case 'a':
name=ast.object.name;
return {
 name,
 property: ast.property.name,
 origin: 'user',
 signature: variableSignature,
 type: 'Number'
};
default:
throw this.astErrorOutput('Unexpected expression',ast);
}
case 'this.constants.value':
if (typeof ast.property.name !== 'string') {
throw this.astErrorOutput('Unexpected expression',ast);
}
name=ast.property.name;
type=this.getConstantType(name);
if (!type) {
throw this.astErrorOutput('Constant has no type',ast);
}
return {
name,
type,
origin: 'constants',
signature: variableSignature,
};
case 'this.constants.value[]':
if (typeof ast.object.property.name !== 'string') {
throw this.astErrorOutput('Unexpected expression',ast);
}
name=ast.object.property.name;
type=this.getConstantType(name);
if (!type) {
throw this.astErrorOutput('Constant has no type',ast);
}
return {
name,
type,
origin: 'constants',
signature: variableSignature,
xProperty: ast.property,
};
case 'this.constants.value[][]': {
if (typeof ast.object.object.property.name !== 'string') {
throw this.astErrorOutput('Unexpected expression',ast);
}
name=ast.object.object.property.name;
type=this.getConstantType(name);
if (!type) {
throw this.astErrorOutput('Constant has no type',ast);
}
return {
name,
type,
origin: 'constants',
signature: variableSignature,
yProperty: ast.object.property,
xProperty: ast.property,
};
}
case 'this.constants.value[][][]': {
if (typeof ast.object.object.object.property.name !== 'string') {
throw this.astErrorOutput('Unexpected expression',ast);
}
name=ast.object.object.object.property.name;
type=this.getConstantType(name);
if (!type) {
throw this.astErrorOutput('Constant has no type',ast);
}
return {
name,
type,
origin: 'constants',
signature: variableSignature,
zProperty: ast.object.object.property,
yProperty: ast.object.property,
xProperty: ast.property,
};
}
case 'fn()[]':
case 'fn()[][]':
case '[][]':
return {
signature: variableSignature,
property: ast.property,
};
default:
throw this.astErrorOutput('Unexpected expression',ast);
 }
 }

 findIdentifierOrigin(astToFind) {
 const stack=[this.ast];

 while (stack.length > 0) {
const atNode=stack[0];
if (atNode.type === 'VariableDeclarator' && atNode.id && atNode.id.name && atNode.id.name === astToFind.name) {
return atNode;
}
stack.shift();
if (atNode.argument) {
stack.push(atNode.argument);
} else if (atNode.body) {
stack.push(atNode.body);
} else if (atNode.declarations) {
stack.push(atNode.declarations);
} else if (Array.isArray(atNode)) {
for (let i=0; i < atNode.length; i++) {
stack.push(atNode[i]);
}
}
 }
 return null;
 }

 findLastReturn(ast) {
 const stack=[ast || this.ast];

 while (stack.length > 0) {
const atNode=stack.pop();
if (atNode.type === 'ReturnStatement') {
return atNode;
}
if (atNode.type === 'FunctionDeclaration') {
continue;
}
if (atNode.argument) {
stack.push(atNode.argument);
} else if (atNode.body) {
stack.push(atNode.body);
} else if (atNode.declarations) {
stack.push(atNode.declarations);
} else if (Array.isArray(atNode)) {
for (let i=0; i < atNode.length; i++) {
stack.push(atNode[i]);
}
} else if (atNode.consequent) {
stack.push(atNode.consequent);
} else if (atNode.cases) {
stack.push(atNode.cases);
}
 }
 return null;
 }

 getInternalVariableName(name) {
 if (!this._internalVariableNames.hasOwnProperty(name)) {
this._internalVariableNames[name]=0;
 }
 this._internalVariableNames[name]++;
 if (this._internalVariableNames[name] === 1) {
return name;
 }
 return name + this._internalVariableNames[name];
 }

 astKey(ast,separator=',') {
 if (!ast.start || !ast.end) throw new Error('AST start and end needed');
 return `${ast.start}${separator}${ast.end}`;
 }
 }

 const typeLookupMap={
 'Number': 'Number',
 'Float': 'Float',
 'Integer': 'Integer',
 'Array': 'Number',
 'Array(2)': 'Number',
 'Array(3)': 'Number',
 'Array(4)': 'Number',
 'Matrix(2)': 'Number',
 'Matrix(3)': 'Number',
 'Matrix(4)': 'Number',
 'Array2D': 'Number',
 'Array3D': 'Number',
 'Input': 'Number',
 'HTMLCanvas': 'Array(4)',
 'OffscreenCanvas': 'Array(4)',
 'HTMLImage': 'Array(4)',
 'ImageBitmap': 'Array(4)',
 'ImageData': 'Array(4)',
 'HTMLVideo': 'Array(4)',
 'HTMLImageArray': 'Array(4)',
 'NumberTexture': 'Number',
 'MemoryOptimizedNumberTexture': 'Number',
 'Array1D(2)': 'Array(2)',
 'Array1D(3)': 'Array(3)',
 'Array1D(4)': 'Array(4)',
 'Array2D(2)': 'Array(2)',
 'Array2D(3)': 'Array(3)',
 'Array2D(4)': 'Array(4)',
 'Array3D(2)': 'Array(2)',
 'Array3D(3)': 'Array(3)',
 'Array3D(4)': 'Array(4)',
 'ArrayTexture(1)': 'Number',
 'ArrayTexture(2)': 'Array(2)',
 'ArrayTexture(3)': 'Array(3)',
 'ArrayTexture(4)': 'Array(4)',
 };

 module.exports={
 FunctionNode
 };
 },{"../utils":114,"./function-tracer":11,"acorn":1}],11:[function(require,module,exports){
 const { utils }=require('../utils');

 function last(array) {
 return array.length > 0 ? array[array.length - 1] : null;
 }

 const states={
 trackIdentifiers: 'trackIdentifiers',
 memberExpression: 'memberExpression',
 inForLoopInit: 'inForLoopInit'
 };

 class FunctionTracer {
 constructor(ast) {
 this.runningContexts=[];
 this.functionContexts=[];
 this.contexts=[];
 this.functionCalls=[];
 this.declarations=[];
 this.identifiers=[];
 this.functions=[];
 this.returnStatements=[];
 this.trackedIdentifiers=null;
 this.states=[];
 this.newFunctionContext();
 this.scan(ast);
 }

 isState(state) {
 return this.states[this.states.length - 1] === state;
 }

 hasState(state) {
 return this.states.indexOf(state) > -1;
 }

 pushState(state) {
 this.states.push(state);
 }

 popState(state) {
 if (this.isState(state)) {
this.states.pop();
 } else {
throw new Error(`Cannot pop the non-active state "${state}"`);
 }
 }

 get currentFunctionContext() {
 return last(this.functionContexts);
 }

 get currentContext() {
 return last(this.runningContexts);
 }

 newFunctionContext() {
 const newContext={ '@contextType': 'function' };
 this.contexts.push(newContext);
 this.functionContexts.push(newContext);
 }

 newContext(run) {
 const newContext=Object.assign({ '@contextType': 'const/let' },this.currentContext);
 this.contexts.push(newContext);
 this.runningContexts.push(newContext);
 run();
 const { currentFunctionContext }=this;
 for (const p in currentFunctionContext) {
if (!currentFunctionContext.hasOwnProperty(p) || newContext.hasOwnProperty(p)) continue;
newContext[p]=currentFunctionContext[p];
 }
 this.runningContexts.pop();
 return newContext;
 }

 useFunctionContext(run) {
 const functionContext=last(this.functionContexts);
 this.runningContexts.push(functionContext);
 run();
 this.runningContexts.pop();
 }

 getIdentifiers(run) {
 const trackedIdentifiers=this.trackedIdentifiers=[];
 this.pushState(states.trackIdentifiers);
 run();
 this.trackedIdentifiers=null;
 this.popState(states.trackIdentifiers);
 return trackedIdentifiers;
 }

 getDeclaration(name) {
 const { currentContext,currentFunctionContext,runningContexts }=this;
 const declaration=currentContext[name] || currentFunctionContext[name] || null;

 if (
!declaration &&
currentContext === currentFunctionContext &&
runningContexts.length > 0
 ) {
const previousRunningContext=runningContexts[runningContexts.length - 2];
if (previousRunningContext[name]) {
return previousRunningContext[name];
}
 }

 return declaration;
 }

 scan(ast) {
 if (!ast) return;
 if (Array.isArray(ast)) {
for (let i=0; i < ast.length; i++) {
this.scan(ast[i]);
}
return;
 }
 switch (ast.type) {
case 'Program':
this.useFunctionContext(() => {
this.scan(ast.body);
});
break;
case 'BlockStatement':
this.newContext(() => {
this.scan(ast.body);
});
break;
case 'AssignmentExpression':
case 'LogicalExpression':
this.scan(ast.left);
this.scan(ast.right);
break;
case 'BinaryExpression':
this.scan(ast.left);
this.scan(ast.right);
break;
case 'UpdateExpression':
if (ast.operator === '++') {
const declaration=this.getDeclaration(ast.argument.name);
if (declaration) {
declaration.suggestedType='Integer';
}
}
this.scan(ast.argument);
break;
case 'UnaryExpression':
this.scan(ast.argument);
break;
case 'VariableDeclaration':
if (ast.kind === 'var') {
this.useFunctionContext(() => {
ast.declarations=utils.normalizeDeclarations(ast);
this.scan(ast.declarations);
});
} else {
ast.declarations=utils.normalizeDeclarations(ast);
this.scan(ast.declarations);
}
break;
case 'VariableDeclarator': {
const { currentContext }=this;
const inForLoopInit=this.hasState(states.inForLoopInit);
const declaration={
ast: ast,
context: currentContext,
name: ast.id.name,
origin: 'declaration',
inForLoopInit,
inForLoopTest: null,
assignable: currentContext === this.currentFunctionContext || (!inForLoopInit && !currentContext.hasOwnProperty(ast.id.name)),
suggestedType: null,
valueType: null,
dependencies: null,
isSafe: null,
};
if (!currentContext[ast.id.name]) {
currentContext[ast.id.name]=declaration;
}
this.declarations.push(declaration);
this.scan(ast.id);
this.scan(ast.init);
break;
}
case 'FunctionExpression':
case 'FunctionDeclaration':
if (this.runningContexts.length === 0) {
this.scan(ast.body);
} else {
this.functions.push(ast);
}
break;
case 'IfStatement':
this.scan(ast.test);
this.scan(ast.consequent);
if (ast.alternate) this.scan(ast.alternate);
break;
case 'ForStatement': {
let testIdentifiers;
const context=this.newContext(() => {
this.pushState(states.inForLoopInit);
this.scan(ast.init);
this.popState(states.inForLoopInit);

testIdentifiers=this.getIdentifiers(() => {
this.scan(ast.test);
});

this.scan(ast.update);
this.newContext(() => {
this.scan(ast.body);
});
});

if (testIdentifiers) {
for (const p in context) {
if (p === '@contextType') continue;
if (testIdentifiers.indexOf(p) > -1) {
 context[p].inForLoopTest=true;
}
}
}
break;
}
case 'DoWhileStatement':
case 'WhileStatement':
this.newContext(() => {
this.scan(ast.body);
this.scan(ast.test);
});
break;
case 'Identifier': {
if (this.isState(states.trackIdentifiers)) {
this.trackedIdentifiers.push(ast.name);
}
this.identifiers.push({
context: this.currentContext,
declaration: this.getDeclaration(ast.name),
ast,
});
break;
}
case 'ReturnStatement':
this.returnStatements.push(ast);
this.scan(ast.argument);
break;
case 'MemberExpression':
this.pushState(states.memberExpression);
this.scan(ast.object);
this.scan(ast.property);
this.popState(states.memberExpression);
break;
case 'ExpressionStatement':
this.scan(ast.expression);
break;
case 'SequenceExpression':
this.scan(ast.expressions);
break;
case 'CallExpression':
this.functionCalls.push({
context: this.currentContext,
ast,
});
this.scan(ast.arguments);
break;
case 'ArrayExpression':
this.scan(ast.elements);
break;
case 'ConditionalExpression':
this.scan(ast.test);
this.scan(ast.alternate);
this.scan(ast.consequent);
break;
case 'SwitchStatement':
this.scan(ast.discriminant);
this.scan(ast.cases);
break;
case 'SwitchCase':
this.scan(ast.test);
this.scan(ast.consequent);
break;

case 'ThisExpression':
case 'Literal':
case 'DebuggerStatement':
case 'EmptyStatement':
case 'BreakStatement':
case 'ContinueStatement':
break;
default:
throw new Error(`unhandled type "${ast.type}"`);
 }
 }
 }

 module.exports={
 FunctionTracer,
 };
 },{"../utils":114}],12:[function(require,module,exports){
 const { glWiretap }=require('gl-wiretap');
 const { utils }=require('../../utils');

 function toStringWithoutUtils(fn) {
 return fn.toString()
 .replace('=>','')
 .replace(/^function /,'')
 .replace(/utils[.]/g,'/*utils.*/');
 }

 function glKernelString(Kernel,args,originKernel,setupContextString,destroyContextString) {
 if (!originKernel.built) {
 originKernel.build.apply(originKernel,args);
 }
 args=args ? Array.from(args).map(arg => {
 switch (typeof arg) {
case 'boolean':
return new Boolean(arg);
case 'number':
return new Number(arg);
default:
return arg;
 }
 }) : null;
 const uploadedValues=[];
 const postResult=[];
 const context=glWiretap(originKernel.context,{
 useTrackablePrimitives: true,
 onReadPixels: (targetName) => {
if (kernel.subKernels) {
if (!subKernelsResultVariableSetup) {
postResult.push(` const result={ result: ${getRenderString(targetName,kernel)} };`);
subKernelsResultVariableSetup=true;
} else {
const property=kernel.subKernels[subKernelsResultIndex++].property;
postResult.push(` result${isNaN(property) ? '.' + property : `[${property}]`}=${getRenderString(targetName,kernel)};`);
}
if (subKernelsResultIndex === kernel.subKernels.length) {
postResult.push(' return result;');
}
return;
}
if (targetName) {
postResult.push(` return ${getRenderString(targetName,kernel)};`);
} else {
postResult.push(` return null;`);
}
 },
 onUnrecognizedArgumentLookup: (argument) => {
const argumentName=findKernelValue(argument,kernel.kernelArguments,[],context,uploadedValues);
if (argumentName) {
return argumentName;
}
const constantName=findKernelValue(argument,kernel.kernelConstants,constants ? Object.keys(constants).map(key => constants[key]) : [],context,uploadedValues);
if (constantName) {
return constantName;
}
return null;
 }
 });
 let subKernelsResultVariableSetup=false;
 let subKernelsResultIndex=0;
 const {
 source,
 canvas,
 output,
 pipeline,
 graphical,
 loopMaxIterations,
 constants,
 optimizeFloatMemory,
 precision,
 fixIntegerDivisionAccuracy,
 functions,
 nativeFunctions,
 subKernels,
 immutable,
 argumentTypes,
 constantTypes,
 kernelArguments,
 kernelConstants,
 tactic,
 }=originKernel;
 const kernel=new Kernel(source,{
 canvas,
 context,
 checkContext: false,
 output,
 pipeline,
 graphical,
 loopMaxIterations,
 constants,
 optimizeFloatMemory,
 precision,
 fixIntegerDivisionAccuracy,
 functions,
 nativeFunctions,
 subKernels,
 immutable,
 argumentTypes,
 constantTypes,
 tactic,
 });
 let result=[];
 context.setIndent(2);
 kernel.build.apply(kernel,args);
 result.push(context.toString());
 context.reset();

 kernel.kernelArguments.forEach((kernelArgument,i) => {
 switch (kernelArgument.type) {
case 'Integer':
case 'Boolean':
case 'Number':
case 'Float':
case 'Array':
case 'Array(2)':
case 'Array(3)':
case 'Array(4)':
case 'HTMLCanvas':
case 'HTMLImage':
case 'HTMLVideo':
context.insertVariable(`uploadValue_${kernelArgument.name}`,kernelArgument.uploadValue);
break;
case 'HTMLImageArray':
for (let imageIndex=0; imageIndex < args[i].length; imageIndex++) {
const arg=args[i];
context.insertVariable(`uploadValue_${kernelArgument.name}[${imageIndex}]`,arg[imageIndex]);
}
break;
case 'Input':
context.insertVariable(`uploadValue_${kernelArgument.name}`,kernelArgument.uploadValue);
break;
case 'MemoryOptimizedNumberTexture':
case 'NumberTexture':
case 'Array1D(2)':
case 'Array1D(3)':
case 'Array1D(4)':
case 'Array2D(2)':
case 'Array2D(3)':
case 'Array2D(4)':
case 'Array3D(2)':
case 'Array3D(3)':
case 'Array3D(4)':
case 'ArrayTexture(1)':
case 'ArrayTexture(2)':
case 'ArrayTexture(3)':
case 'ArrayTexture(4)':
context.insertVariable(`uploadValue_${kernelArgument.name}`,args[i].texture);
break;
default:
throw new Error(`unhandled kernelArgumentType insertion for glWiretap of type ${kernelArgument.type}`);
 }
 });
 result.push('/** start of injected functions **/');
 result.push(`function ${toStringWithoutUtils(utils.flattenTo)}`);
 result.push(`function ${toStringWithoutUtils(utils.flatten2dArrayTo)}`);
 result.push(`function ${toStringWithoutUtils(utils.flatten3dArrayTo)}`);
 result.push(`function ${toStringWithoutUtils(utils.flatten4dArrayTo)}`);
 result.push(`function ${toStringWithoutUtils(utils.isArray)}`);
 if (kernel.renderOutput !== kernel.renderTexture && kernel.formatValues) {
 result.push(
` const renderOutput=function ${toStringWithoutUtils(kernel.formatValues)};`
 );
 }
 result.push('/** end of injected functions **/');
 result.push(` const innerKernel=function (${kernel.kernelArguments.map(kernelArgument => kernelArgument.varName).join(',')}) {`);
 context.setIndent(4);
 kernel.run.apply(kernel,args);
 if (kernel.renderKernels) {
 kernel.renderKernels();
 } else if (kernel.renderOutput) {
 kernel.renderOutput();
 }
 result.push(' /** start setup uploads for kernel values **/');
 kernel.kernelArguments.forEach(kernelArgument => {
 result.push(' ' + kernelArgument.getStringValueHandler().split('\n').join('\n '));
 });
 result.push(' /** end setup uploads for kernel values **/');
 result.push(context.toString());
 if (kernel.renderOutput === kernel.renderTexture) {
 context.reset();
 const framebufferName=context.getContextVariableName(kernel.framebuffer);
 if (kernel.renderKernels) {
const results=kernel.renderKernels();
const textureName=context.getContextVariableName(kernel.texture.texture);
result.push(` return {
 result: {
 texture: ${ textureName },
 type: '${ results.result.type }',
 toArray: ${ getToArrayString(results.result,textureName,framebufferName) }
 },`);
const { subKernels,mappedTextures }=kernel;
for (let i=0; i < subKernels.length; i++) {
const texture=mappedTextures[i];
const subKernel=subKernels[i];
const subKernelResult=results[subKernel.property];
const subKernelTextureName=context.getContextVariableName(texture.texture);
result.push(`
 ${subKernel.property}: {
 texture: ${ subKernelTextureName },
 type: '${ subKernelResult.type }',
 toArray: ${ getToArrayString(subKernelResult,subKernelTextureName,framebufferName) }
 },`);
}
result.push(` };`);
 } else {
const rendered=kernel.renderOutput();
const textureName=context.getContextVariableName(kernel.texture.texture);
result.push(` return {
 texture: ${ textureName },
 type: '${ rendered.type }',
 toArray: ${ getToArrayString(rendered,textureName,framebufferName) }
 };`);
 }
 }
 result.push(` ${destroyContextString ? '\n' + destroyContextString + ' ': ''}`);
 result.push(postResult.join('\n'));
 result.push(' };');
 if (kernel.graphical) {
 result.push(getGetPixelsString(kernel));
 result.push(` innerKernel.getPixels=getPixels;`);
 }
 result.push(' return innerKernel;');

 let constantsUpload=[];
 kernelConstants.forEach((kernelConstant) => {
 constantsUpload.push(`${kernelConstant.getStringValueHandler()}`);
 });
 return `function kernel(settings) {
 const { context,constants }=settings;
 ${constantsUpload.join('')}
 ${setupContextString ? setupContextString : ''}
${result.join('\n')}
}`;
 }

 function getRenderString(targetName,kernel) {
 const readBackValue=kernel.precision === 'single' ? targetName : `new Float32Array(${targetName}.buffer)`;
 if (kernel.output[2]) {
 return `renderOutput(${readBackValue},${kernel.output[0]},${kernel.output[1]},${kernel.output[2]})`;
 }
 if (kernel.output[1]) {
 return `renderOutput(${readBackValue},${kernel.output[0]},${kernel.output[1]})`;
 }

 return `renderOutput(${readBackValue},${kernel.output[0]})`;
 }

 function getGetPixelsString(kernel) {
 const getPixels=kernel.getPixels.toString();
 const useFunctionKeyword=!/^function/.test(getPixels);
 return utils.flattenFunctionToString(`${useFunctionKeyword ? 'function ' : ''}${ getPixels }`,{
 findDependency: (object,name) => {
if (object === 'utils') {
return `const ${name}=${utils[name].toString()};`;
}
return null;
 },
 thisLookup: (property) => {
if (property === 'context') {
return null;
}
if (kernel.hasOwnProperty(property)) {
return JSON.stringify(kernel[property]);
}
throw new Error(`unhandled thisLookup ${ property }`);
 }
 });
 }

 function getToArrayString(kernelResult,textureName,framebufferName) {
 const toArray=kernelResult.toArray.toString();
 const useFunctionKeyword=!/^function/.test(toArray);
 const flattenedFunctions=utils.flattenFunctionToString(`${useFunctionKeyword ? 'function ' : ''}${ toArray }`,{
 findDependency: (object,name) => {
if (object === 'utils') {
return `const ${name}=${utils[name].toString()};`;
} else if (object === 'this') {
if (name === 'framebuffer') {
return '';
}
return `${useFunctionKeyword ? 'function ' : ''}${kernelResult[name].toString()}`;
} else {
throw new Error('unhandled fromObject');
}
 },
 thisLookup: (property,isDeclaration) => {
if (property === 'texture') {
return textureName;
}
if (property === 'context') {
if (isDeclaration) return null;
return 'gl';
}
if (kernelResult.hasOwnProperty(property)) {
return JSON.stringify(kernelResult[property]);
}
throw new Error(`unhandled thisLookup ${ property }`);
 }
 });
 return `() => {
 function framebuffer() { return ${framebufferName}; };
 ${flattenedFunctions}
 return toArray();
 }`;
 }

 function findKernelValue(argument,kernelValues,values,context,uploadedValues) {
 if (argument === null) return null;
 if (kernelValues === null) return null;
 switch (typeof argument) {
 case 'boolean':
 case 'number':
return null;
 }
 if (
 typeof HTMLImageElement !== 'undefined' &&
 argument instanceof HTMLImageElement
 ) {
 for (let i=0; i < kernelValues.length; i++) {
const kernelValue=kernelValues[i];
if (kernelValue.type !== 'HTMLImageArray' && kernelValue) continue;
if (kernelValue.uploadValue !== argument) continue;
const variableIndex=values[i].indexOf(argument);
if (variableIndex === -1) continue;
const variableName=`uploadValue_${kernelValue.name}[${variableIndex}]`;
context.insertVariable(variableName,argument);
return variableName;
 }
 }

 for (let i=0; i < kernelValues.length; i++) {
 const kernelValue=kernelValues[i];
 if (argument !== kernelValue.uploadValue) continue;
 const variable=`uploadValue_${kernelValue.name}`;
 context.insertVariable(variable,kernelValue);
 return variable;
 }
 return null;
 }

 module.exports={
 glKernelString
 };
 },{"../../utils":114,"gl-wiretap":3}],13:[function(require,module,exports){
 const { Kernel }=require('../kernel');
 const { utils }=require('../../utils');
 const { GLTextureArray2Float }=require('./texture/array-2-float');
 const { GLTextureArray2Float2D }=require('./texture/array-2-float-2d');
 const { GLTextureArray2Float3D }=require('./texture/array-2-float-3d');
 const { GLTextureArray3Float }=require('./texture/array-3-float');
 const { GLTextureArray3Float2D }=require('./texture/array-3-float-2d');
 const { GLTextureArray3Float3D }=require('./texture/array-3-float-3d');
 const { GLTextureArray4Float }=require('./texture/array-4-float');
 const { GLTextureArray4Float2D }=require('./texture/array-4-float-2d');
 const { GLTextureArray4Float3D }=require('./texture/array-4-float-3d');
 const { GLTextureFloat }=require('./texture/float');
 const { GLTextureFloat2D }=require('./texture/float-2d');
 const { GLTextureFloat3D }=require('./texture/float-3d');
 const { GLTextureMemoryOptimized }=require('./texture/memory-optimized');
 const { GLTextureMemoryOptimized2D }=require('./texture/memory-optimized-2d');
 const { GLTextureMemoryOptimized3D }=require('./texture/memory-optimized-3d');
 const { GLTextureUnsigned }=require('./texture/unsigned');
 const { GLTextureUnsigned2D }=require('./texture/unsigned-2d');
 const { GLTextureUnsigned3D }=require('./texture/unsigned-3d');
 const { GLTextureGraphical }=require('./texture/graphical');

 class GLKernel extends Kernel {
 static get mode() {
 return 'gpu';
 }

 static getIsFloatRead() {
 const kernelString=`function kernelFunction() {
 return 1;
 }`;
 const kernel=new this(kernelString,{
context: this.testContext,
canvas: this.testCanvas,
validate: false,
output: [1],
precision: 'single',
returnType: 'Number',
tactic: 'speed',
 });
 kernel.build();
 kernel.run();
 const result=kernel.renderOutput();
 kernel.destroy(true);
 return result[0] === 1;
 }

 static getIsIntegerDivisionAccurate() {
 function kernelFunction(v1,v2) {
return v1[this.thread.x] / v2[this.thread.x];
 }
 const kernel=new this(kernelFunction.toString(),{
context: this.testContext,
canvas: this.testCanvas,
validate: false,
output: [2],
returnType: 'Number',
precision: 'unsigned',
tactic: 'speed',
 });
 const args=[
[6,6030401],
[3,3991]
 ];
 kernel.build.apply(kernel,args);
 kernel.run.apply(kernel,args);
 const result=kernel.renderOutput();
 kernel.destroy(true);
 return result[0] === 2 && result[1] === 1511;
 }

 static getIsSpeedTacticSupported() {
 function kernelFunction(value) {
return value[this.thread.x];
 }
 const kernel=new this(kernelFunction.toString(),{
context: this.testContext,
canvas: this.testCanvas,
validate: false,
output: [4],
returnType: 'Number',
precision: 'unsigned',
tactic: 'speed',
 });
 const args=[
[0,1,2,3]
 ];
 kernel.build.apply(kernel,args);
 kernel.run.apply(kernel,args);
 const result=kernel.renderOutput();
 kernel.destroy(true);
 return Math.round(result[0]) === 0 && Math.round(result[1]) === 1 && Math.round(result[2]) === 2 && Math.round(result[3]) === 3;
 }

 static get testCanvas() {
 throw new Error(`"testCanvas" not defined on ${ this.name }`);
 }

 static get testContext() {
 throw new Error(`"testContext" not defined on ${ this.name }`);
 }

 static getFeatures() {
 const gl=this.testContext;
 const isDrawBuffers=this.getIsDrawBuffers();
 return Object.freeze({
isFloatRead: this.getIsFloatRead(),
isIntegerDivisionAccurate: this.getIsIntegerDivisionAccurate(),
isSpeedTacticSupported: this.getIsSpeedTacticSupported(),
isTextureFloat: this.getIsTextureFloat(),
isDrawBuffers,
kernelMap: isDrawBuffers,
channelCount: this.getChannelCount(),
maxTextureSize: this.getMaxTextureSize(),
lowIntPrecision: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER,gl.LOW_INT),
lowFloatPrecision: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER,gl.LOW_FLOAT),
mediumIntPrecision: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER,gl.MEDIUM_INT),
mediumFloatPrecision: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER,gl.MEDIUM_FLOAT),
highIntPrecision: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER,gl.HIGH_INT),
highFloatPrecision: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER,gl.HIGH_FLOAT),
 });
 }

 static setupFeatureChecks() {
 throw new Error(`"setupFeatureChecks" not defined on ${ this.name }`);
 }

 static getSignature(kernel,argumentTypes) {
 return kernel.getVariablePrecisionString() + (argumentTypes.length > 0 ? ':' + argumentTypes.join(',') : '');
 }

 setFixIntegerDivisionAccuracy(fix) {
 this.fixIntegerDivisionAccuracy=fix;
 return this;
 }

 setPrecision(flag) {
 this.precision=flag;
 return this;
 }

 setFloatTextures(flag) {
 utils.warnDeprecated('method','setFloatTextures','setOptimizeFloatMemory');
 this.floatTextures=flag;
 return this;
 }

 static nativeFunctionArguments(source) {
 const argumentTypes=[];
 const argumentNames=[];
 const states=[];
 const isStartingVariableName=/^[a-zA-Z_]/;
 const isVariableChar=/[a-zA-Z_0-9]/;
 let i=0;
 let argumentName=null;
 let argumentType=null;
 while (i < source.length) {
const char=source[i];
const nextChar=source[i + 1];
const state=states.length > 0 ? states[states.length - 1] : null;

if (state === 'FUNCTION_ARGUMENTS' && char === '/' && nextChar === '*') {
states.push('MULTI_LINE_COMMENT');
i += 2;
continue;
} else if (state === 'MULTI_LINE_COMMENT' && char === '*' && nextChar === '/') {
states.pop();
i += 2;
continue;
}

else if (state === 'FUNCTION_ARGUMENTS' && char === '/' && nextChar === '/') {
states.push('COMMENT');
i += 2;
continue;
} else if (state === 'COMMENT' && char === '\n') {
states.pop();
i++;
continue;
}

else if (state === null && char === '(') {
states.push('FUNCTION_ARGUMENTS');
i++;
continue;
} else if (state === 'FUNCTION_ARGUMENTS') {
if (char === ')') {
states.pop();
break;
}
if (char === 'f' && nextChar === 'l' && source[i + 2] === 'o' && source[i + 3] === 'a' && source[i + 4] === 't' && source[i + 5] === ' ') {
states.push('DECLARE_VARIABLE');
argumentType='float';
argumentName='';
i += 6;
continue;
} else if (char === 'i' && nextChar === 'n' && source[i + 2] === 't' && source[i + 3] === ' ') {
states.push('DECLARE_VARIABLE');
argumentType='int';
argumentName='';
i += 4;
continue;
} else if (char === 'v' && nextChar === 'e' && source[i + 2] === 'c' && source[i + 3] === '2' && source[i + 4] === ' ') {
states.push('DECLARE_VARIABLE');
argumentType='vec2';
argumentName='';
i += 5;
continue;
} else if (char === 'v' && nextChar === 'e' && source[i + 2] === 'c' && source[i + 3] === '3' && source[i + 4] === ' ') {
states.push('DECLARE_VARIABLE');
argumentType='vec3';
argumentName='';
i += 5;
continue;
} else if (char === 'v' && nextChar === 'e' && source[i + 2] === 'c' && source[i + 3] === '4' && source[i + 4] === ' ') {
states.push('DECLARE_VARIABLE');
argumentType='vec4';
argumentName='';
i += 5;
continue;
}
}

else if (state === 'DECLARE_VARIABLE') {
if (argumentName === '') {
if (char === ' ') {
i++;
continue;
}
if (!isStartingVariableName.test(char)) {
throw new Error('variable name is not expected string');
}
}
argumentName += char;
if (!isVariableChar.test(nextChar)) {
states.pop();
argumentNames.push(argumentName);
argumentTypes.push(typeMap[argumentType]);
}
}

i++;
 }
 if (states.length > 0) {
throw new Error('GLSL function was not parsable');
 }
 return {
argumentNames,
argumentTypes,
 };
 }

 static nativeFunctionReturnType(source) {
 return typeMap[source.match(/int|float|vec[2-4]/)[0]];
 }

 static combineKernels(combinedKernel,lastKernel) {
 combinedKernel.apply(null,arguments);
 const {
texSize,
context,
threadDim
 }=lastKernel.texSize;
 let result;
 if (lastKernel.precision === 'single') {
const w=texSize[0];
const h=Math.ceil(texSize[1] / 4);
result=new Float32Array(w * h * 4 * 4);
context.readPixels(0,0,w,h * 4,context.RGBA,context.FLOAT,result);
 } else {
const bytes=new Uint8Array(texSize[0] * texSize[1] * 4);
context.readPixels(0,0,texSize[0],texSize[1],context.RGBA,context.UNSIGNED_BYTE,bytes);
result=new Float32Array(bytes.buffer);
 }

 result=result.subarray(0,threadDim[0] * threadDim[1] * threadDim[2]);

 if (lastKernel.output.length === 1) {
return result;
 } else if (lastKernel.output.length === 2) {
return utils.splitArray(result,lastKernel.output[0]);
 } else if (lastKernel.output.length === 3) {
const cube=utils.splitArray(result,lastKernel.output[0] * lastKernel.output[1]);
return cube.map(function(x) {
return utils.splitArray(x,lastKernel.output[0]);
});
 }
 }

 constructor(source,settings) {
 super(source,settings);
 this.transferValues=null;
 this.formatValues=null;
 this.TextureConstructor=null;
 this.renderOutput=null;
 this.renderRawOutput=null;
 this.texSize=null;
 this.translatedSource=null;
 this.compiledFragmentShader=null;
 this.compiledVertexShader=null;
 this.switchingKernels=null;
 this._textureSwitched=null;
 this._mappedTextureSwitched=null;
 }

 checkTextureSize() {
 const { features }=this.constructor;
 if (this.texSize[0] > features.maxTextureSize || this.texSize[1] > features.maxTextureSize) {
throw new Error(`Texture size [${this.texSize[0]},${this.texSize[1]}] generated by kernel is larger than supported size [${features.maxTextureSize},${features.maxTextureSize}]`);
 }
 }

 translateSource() {
 throw new Error(`"translateSource" not defined on ${this.constructor.name}`);
 }

 pickRenderStrategy(args) {
 if (this.graphical) {
this.renderRawOutput=this.readPackedPixelsToUint8Array;
this.transferValues=(pixels) => pixels;
this.TextureConstructor=GLTextureGraphical;
return null;
 }
 if (this.precision === 'unsigned') {
this.renderRawOutput=this.readPackedPixelsToUint8Array;
this.transferValues=this.readPackedPixelsToFloat32Array;
if (this.pipeline) {
this.renderOutput=this.renderTexture;
if (this.subKernels !== null) {
this.renderKernels=this.renderKernelsToTextures;
}
switch (this.returnType) {
case 'LiteralInteger':
case 'Float':
case 'Number':
case 'Integer':
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureUnsigned3D;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureUnsigned2D;
 return null;
} else {
 this.TextureConstructor=GLTextureUnsigned;
 return null;
}
case 'Array(2)':
case 'Array(3)':
case 'Array(4)':
return this.requestFallback(args);
}
} else {
if (this.subKernels !== null) {
this.renderKernels=this.renderKernelsToArrays;
}
switch (this.returnType) {
case 'LiteralInteger':
case 'Float':
case 'Number':
case 'Integer':
this.renderOutput=this.renderValues;
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureUnsigned3D;
 this.formatValues=utils.erect3DPackedFloat;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureUnsigned2D;
 this.formatValues=utils.erect2DPackedFloat;
 return null;
} else {
 this.TextureConstructor=GLTextureUnsigned;
 this.formatValues=utils.erectPackedFloat;
 return null;
}
case 'Array(2)':
case 'Array(3)':
case 'Array(4)':
return this.requestFallback(args);
}
}
 } else if (this.precision === 'single') {
this.renderRawOutput=this.readFloatPixelsToFloat32Array;
this.transferValues=this.readFloatPixelsToFloat32Array;
if (this.pipeline) {
this.renderOutput=this.renderTexture;
if (this.subKernels !== null) {
this.renderKernels=this.renderKernelsToTextures;
}
switch (this.returnType) {
case 'LiteralInteger':
case 'Float':
case 'Number':
case 'Integer': {
if (this.optimizeFloatMemory) {
 if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureMemoryOptimized3D;
 return null;
 } else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureMemoryOptimized2D;
 return null;
 } else {
 this.TextureConstructor=GLTextureMemoryOptimized;
 return null;
 }
} else {
 if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureFloat3D;
 return null;
 } else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureFloat2D;
 return null;
 } else {
 this.TextureConstructor=GLTextureFloat;
 return null;
 }
}
}
case 'Array(2)': {
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureArray2Float3D;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureArray2Float2D;
 return null;
} else {
 this.TextureConstructor=GLTextureArray2Float;
 return null;
}
}
case 'Array(3)': {
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureArray3Float3D;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureArray3Float2D;
 return null;
} else {
 this.TextureConstructor=GLTextureArray3Float;
 return null;
}
}
case 'Array(4)': {
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureArray4Float3D;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureArray4Float2D;
 return null;
} else {
 this.TextureConstructor=GLTextureArray4Float;
 return null;
}
}
}
}
this.renderOutput=this.renderValues;
if (this.subKernels !== null) {
this.renderKernels=this.renderKernelsToArrays;
}
if (this.optimizeFloatMemory) {
switch (this.returnType) {
case 'LiteralInteger':
case 'Float':
case 'Number':
case 'Integer': {
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureMemoryOptimized3D;
 this.formatValues=utils.erectMemoryOptimized3DFloat;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureMemoryOptimized2D;
 this.formatValues=utils.erectMemoryOptimized2DFloat;
 return null;
} else {
 this.TextureConstructor=GLTextureMemoryOptimized;
 this.formatValues=utils.erectMemoryOptimizedFloat;
 return null;
}
}
case 'Array(2)': {
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureArray2Float3D;
 this.formatValues=utils.erect3DArray2;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureArray2Float2D;
 this.formatValues=utils.erect2DArray2;
 return null;
} else {
 this.TextureConstructor=GLTextureArray2Float;
 this.formatValues=utils.erectArray2;
 return null;
}
}
case 'Array(3)': {
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureArray3Float3D;
 this.formatValues=utils.erect3DArray3;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureArray3Float2D;
 this.formatValues=utils.erect2DArray3;
 return null;
} else {
 this.TextureConstructor=GLTextureArray3Float;
 this.formatValues=utils.erectArray3;
 return null;
}
}
case 'Array(4)': {
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureArray4Float3D;
 this.formatValues=utils.erect3DArray4;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureArray4Float2D;
 this.formatValues=utils.erect2DArray4;
 return null;
} else {
 this.TextureConstructor=GLTextureArray4Float;
 this.formatValues=utils.erectArray4;
 return null;
}
}
}
} else {
switch (this.returnType) {
case 'LiteralInteger':
case 'Float':
case 'Number':
case 'Integer': {
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureFloat3D;
 this.formatValues=utils.erect3DFloat;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureFloat2D;
 this.formatValues=utils.erect2DFloat;
 return null;
} else {
 this.TextureConstructor=GLTextureFloat;
 this.formatValues=utils.erectFloat;
 return null;
}
}
case 'Array(2)': {
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureArray2Float3D;
 this.formatValues=utils.erect3DArray2;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureArray2Float2D;
 this.formatValues=utils.erect2DArray2;
 return null;
} else {
 this.TextureConstructor=GLTextureArray2Float;
 this.formatValues=utils.erectArray2;
 return null;
}
}
case 'Array(3)': {
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureArray3Float3D;
 this.formatValues=utils.erect3DArray3;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureArray3Float2D;
 this.formatValues=utils.erect2DArray3;
 return null;
} else {
 this.TextureConstructor=GLTextureArray3Float;
 this.formatValues=utils.erectArray3;
 return null;
}
}
case 'Array(4)': {
if (this.output[2] > 0) {
 this.TextureConstructor=GLTextureArray4Float3D;
 this.formatValues=utils.erect3DArray4;
 return null;
} else if (this.output[1] > 0) {
 this.TextureConstructor=GLTextureArray4Float2D;
 this.formatValues=utils.erect2DArray4;
 return null;
} else {
 this.TextureConstructor=GLTextureArray4Float;
 this.formatValues=utils.erectArray4;
 return null;
}
}
}
}
 } else {
throw new Error(`unhandled precision of "${this.precision}"`);
 }

 throw new Error(`unhandled return type "${this.returnType}"`);
 }

 getKernelString() {
 throw new Error(`abstract method call`);
 }

 getMainResultTexture() {
 switch (this.returnType) {
case 'LiteralInteger':
case 'Float':
case 'Integer':
case 'Number':
return this.getMainResultNumberTexture();
case 'Array(2)':
return this.getMainResultArray2Texture();
case 'Array(3)':
return this.getMainResultArray3Texture();
case 'Array(4)':
return this.getMainResultArray4Texture();
default:
throw new Error(`unhandled returnType type ${ this.returnType }`);
 }
 }

 getMainResultKernelNumberTexture() {
 throw new Error(`abstract method call`);
 }
 getMainResultSubKernelNumberTexture() {
 throw new Error(`abstract method call`);
 }
 getMainResultKernelArray2Texture() {
 throw new Error(`abstract method call`);
 }
 getMainResultSubKernelArray2Texture() {
 throw new Error(`abstract method call`);
 }
 getMainResultKernelArray3Texture() {
 throw new Error(`abstract method call`);
 }
 getMainResultSubKernelArray3Texture() {
 throw new Error(`abstract method call`);
 }
 getMainResultKernelArray4Texture() {
 throw new Error(`abstract method call`);
 }
 getMainResultSubKernelArray4Texture() {
 throw new Error(`abstract method call`);
 }
 getMainResultGraphical() {
 throw new Error(`abstract method call`);
 }
 getMainResultMemoryOptimizedFloats() {
 throw new Error(`abstract method call`);
 }
 getMainResultPackedPixels() {
 throw new Error(`abstract method call`);
 }

 getMainResultString() {
 if (this.graphical) {
return this.getMainResultGraphical();
 } else if (this.precision === 'single') {
if (this.optimizeFloatMemory) {
return this.getMainResultMemoryOptimizedFloats();
}
return this.getMainResultTexture();
 } else {
return this.getMainResultPackedPixels();
 }
 }

 getMainResultNumberTexture() {
 return utils.linesToString(this.getMainResultKernelNumberTexture()) +
utils.linesToString(this.getMainResultSubKernelNumberTexture());
 }

 getMainResultArray2Texture() {
 return utils.linesToString(this.getMainResultKernelArray2Texture()) +
utils.linesToString(this.getMainResultSubKernelArray2Texture());
 }

 getMainResultArray3Texture() {
 return utils.linesToString(this.getMainResultKernelArray3Texture()) +
utils.linesToString(this.getMainResultSubKernelArray3Texture());
 }

 getMainResultArray4Texture() {
 return utils.linesToString(this.getMainResultKernelArray4Texture()) +
utils.linesToString(this.getMainResultSubKernelArray4Texture());
 }

 getFloatTacticDeclaration() {
 const variablePrecision=this.getVariablePrecisionString(this.texSize,this.tactic);
 return `precision ${variablePrecision} float;\n`;
 }

 getIntTacticDeclaration() {
 return `precision ${this.getVariablePrecisionString(this.texSize,this.tactic,true)} int;\n`;
 }

 getSampler2DTacticDeclaration() {
 return `precision ${this.getVariablePrecisionString(this.texSize,this.tactic)} sampler2D;\n`;
 }

 getSampler2DArrayTacticDeclaration() {
 return `precision ${this.getVariablePrecisionString(this.texSize,this.tactic)} sampler2DArray;\n`;
 }

 renderTexture() {
 return this.immutable ? this.texture.clone() : this.texture;
 }
 readPackedPixelsToUint8Array() {
 if (this.precision !== 'unsigned') throw new Error('Requires this.precision to be "unsigned"');
 const {
texSize,
context: gl
 }=this;
 const result=new Uint8Array(texSize[0] * texSize[1] * 4);
 gl.readPixels(0,0,texSize[0],texSize[1],gl.RGBA,gl.UNSIGNED_BYTE,result);
 return result;
 }

 readPackedPixelsToFloat32Array() {
 return new Float32Array(this.readPackedPixelsToUint8Array().buffer);
 }

 readFloatPixelsToFloat32Array() {
 if (this.precision !== 'single') throw new Error('Requires this.precision to be "single"');
 const {
texSize,
context: gl
 }=this;
 const w=texSize[0];
 const h=texSize[1];
 const result=new Float32Array(w * h * 4);
 gl.readPixels(0,0,w,h,gl.RGBA,gl.FLOAT,result);
 return result;
 }

 getPixels(flip) {
 const {
context: gl,
output
 }=this;
 const [width,height]=output;
 const pixels=new Uint8Array(width * height * 4);
 gl.readPixels(0,0,width,height,gl.RGBA,gl.UNSIGNED_BYTE,pixels);
 return new Uint8ClampedArray((flip ? pixels : utils.flipPixels(pixels,width,height)).buffer);
 }

 renderKernelsToArrays() {
 const result={
result: this.renderOutput(),
 };
 for (let i=0; i < this.subKernels.length; i++) {
result[this.subKernels[i].property]=this.mappedTextures[i].toArray();
 }
 return result;
 }

 renderKernelsToTextures() {
 const result={
result: this.renderOutput(),
 };
 if (this.immutable) {
for (let i=0; i < this.subKernels.length; i++) {
result[this.subKernels[i].property]=this.mappedTextures[i].clone();
}
 } else {
for (let i=0; i < this.subKernels.length; i++) {
result[this.subKernels[i].property]=this.mappedTextures[i];
}
 }
 return result;
 }

 resetSwitchingKernels() {
 const existingValue=this.switchingKernels;
 this.switchingKernels=null;
 return existingValue;
 }

 setOutput(output) {
 const newOutput=this.toKernelOutput(output);
 if (this.program) {
if (!this.dynamicOutput) {
throw new Error('Resizing a kernel with dynamicOutput: false is not possible');
}
const newThreadDim=[newOutput[0],newOutput[1] || 1,newOutput[2] || 1];
const newTexSize=utils.getKernelTextureSize({
optimizeFloatMemory: this.optimizeFloatMemory,
precision: this.precision,
},newThreadDim);
const oldTexSize=this.texSize;
if (oldTexSize) {
const oldPrecision=this.getVariablePrecisionString(oldTexSize,this.tactic);
const newPrecision=this.getVariablePrecisionString(newTexSize,this.tactic);
if (oldPrecision !== newPrecision) {
if (this.debug) {
console.warn('Precision requirement changed,asking GPU instance to recompile');
}
this.switchKernels({
type: 'outputPrecisionMismatch',
precision: newPrecision,
needed: output
});
return;
}
}
this.output=newOutput;
this.threadDim=newThreadDim;
this.texSize=newTexSize;
const { context: gl }=this;
gl.bindFramebuffer(gl.FRAMEBUFFER,this.framebuffer);
this.updateMaxTexSize();
this.framebuffer.width=this.texSize[0];
this.framebuffer.height=this.texSize[1];
gl.viewport(0,0,this.maxTexSize[0],this.maxTexSize[1]);
this.canvas.width=this.maxTexSize[0];
this.canvas.height=this.maxTexSize[1];
if (this.texture) {
this.texture.delete();
}
this.texture=null;
this._setupOutputTexture();
if (this.mappedTextures && this.mappedTextures.length > 0) {
for (let i=0; i < this.mappedTextures.length; i++) {
this.mappedTextures[i].delete();
}
this.mappedTextures=null;
this._setupSubOutputTextures();
}
 } else {
this.output=newOutput;
 }
 return this;
 }
 renderValues() {
 return this.formatValues(
this.transferValues(),
this.output[0],
this.output[1],
this.output[2]
 );
 }
 switchKernels(reason) {
 if (this.switchingKernels) {
this.switchingKernels.push(reason);
 } else {
this.switchingKernels=[reason];
 }
 }
 getVariablePrecisionString(textureSize=this.texSize,tactic=this.tactic,isInt=false) {
 if (!tactic) {
if (!this.constructor.features.isSpeedTacticSupported) return 'highp';
const low=this.constructor.features[isInt ? 'lowIntPrecision' : 'lowFloatPrecision'];
const medium=this.constructor.features[isInt ? 'mediumIntPrecision' : 'mediumFloatPrecision'];
const high=this.constructor.features[isInt ? 'highIntPrecision' : 'highFloatPrecision'];
const requiredSize=Math.log2(textureSize[0] * textureSize[1]);
if (requiredSize <= low.rangeMax) {
return 'lowp';
} else if (requiredSize <= medium.rangeMax) {
return 'mediump';
} else if (requiredSize <= high.rangeMax) {
return 'highp';
} else {
throw new Error(`The required size exceeds that of the ability of your system`);
}
 }
 switch (tactic) {
case 'speed':
return 'lowp';
case 'balanced':
return 'mediump';
case 'precision':
return 'highp';
default:
throw new Error(`Unknown tactic "${tactic}" use "speed","balanced","precision",or empty for auto`);
 }
 }

 updateTextureArgumentRefs(kernelValue,arg) {
 if (!this.immutable) return;
 if (this.texture.texture === arg.texture) {
const { prevArg }=kernelValue;
if (prevArg) {
if (prevArg.texture._refs === 1) {
this.texture.delete();
this.texture=prevArg.clone();
this._textureSwitched=true;
}
prevArg.delete();
}
kernelValue.prevArg=arg.clone();
 } else if (this.mappedTextures && this.mappedTextures.length > 0) {
const { mappedTextures }=this;
for (let i=0; i < mappedTextures.length; i++) {
const mappedTexture=mappedTextures[i];
if (mappedTexture.texture === arg.texture) {
const { prevArg }=kernelValue;
if (prevArg) {
if (prevArg.texture._refs === 1) {
 mappedTexture.delete();
 mappedTextures[i]=prevArg.clone();
 this._mappedTextureSwitched[i]=true;
}
prevArg.delete();
}
kernelValue.prevArg=arg.clone();
return;
}
}
 }
 }

 onActivate(previousKernel) {
 this._textureSwitched=true;
 this.texture=previousKernel.texture;
 if (this.mappedTextures) {
for (let i=0; i < this.mappedTextures.length; i++) {
this._mappedTextureSwitched[i]=true;
}
this.mappedTextures=previousKernel.mappedTextures;
 }
 }

 initCanvas() {}
 }

 const typeMap={
 int: 'Integer',
 float: 'Number',
 vec2: 'Array(2)',
 vec3: 'Array(3)',
 vec4: 'Array(4)',
 };

 module.exports={
 GLKernel
 };
 },{"../../utils":114,"../kernel":36,"./texture/array-2-float":16,"./texture/array-2-float-2d":14,"./texture/array-2-float-3d":15,"./texture/array-3-float":19,"./texture/array-3-float-2d":17,"./texture/array-3-float-3d":18,"./texture/array-4-float":22,"./texture/array-4-float-2d":20,"./texture/array-4-float-3d":21,"./texture/float":25,"./texture/float-2d":23,"./texture/float-3d":24,"./texture/graphical":26,"./texture/memory-optimized":30,"./texture/memory-optimized-2d":28,"./texture/memory-optimized-3d":29,"./texture/unsigned":33,"./texture/unsigned-2d":31,"./texture/unsigned-3d":32}],14:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureArray2Float2D extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(2)';
 }
 toArray() {
 return utils.erect2DArray2(this.renderValues(),this.output[0],this.output[1]);
 }
 }

 module.exports={
 GLTextureArray2Float2D
 };
 },{"../../../utils":114,"./float":25}],15:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureArray2Float3D extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(2)';
 }
 toArray() {
 return utils.erect3DArray2(this.renderValues(),this.output[0],this.output[1],this.output[2]);
 }
 }

 module.exports={
 GLTextureArray2Float3D
 };
 },{"../../../utils":114,"./float":25}],16:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureArray2Float extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(2)';
 }
 toArray() {
 return utils.erectArray2(this.renderValues(),this.output[0],this.output[1]);
 }
 }

 module.exports={
 GLTextureArray2Float
 };
 },{"../../../utils":114,"./float":25}],17:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureArray3Float2D extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(3)';
 }
 toArray() {
 return utils.erect2DArray3(this.renderValues(),this.output[0],this.output[1]);
 }
 }

 module.exports={
 GLTextureArray3Float2D
 };
 },{"../../../utils":114,"./float":25}],18:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureArray3Float3D extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(3)';
 }
 toArray() {
 return utils.erect3DArray3(this.renderValues(),this.output[0],this.output[1],this.output[2]);
 }
 }

 module.exports={
 GLTextureArray3Float3D
 };
 },{"../../../utils":114,"./float":25}],19:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureArray3Float extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(3)';
 }
 toArray() {
 return utils.erectArray3(this.renderValues(),this.output[0]);
 }
 }

 module.exports={
 GLTextureArray3Float
 };
 },{"../../../utils":114,"./float":25}],20:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureArray4Float2D extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(4)';
 }
 toArray() {
 return utils.erect2DArray4(this.renderValues(),this.output[0],this.output[1]);
 }
 }

 module.exports={
 GLTextureArray4Float2D
 };
 },{"../../../utils":114,"./float":25}],21:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureArray4Float3D extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(4)';
 }
 toArray() {
 return utils.erect3DArray4(this.renderValues(),this.output[0],this.output[1],this.output[2]);
 }
 }

 module.exports={
 GLTextureArray4Float3D
 };
 },{"../../../utils":114,"./float":25}],22:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureArray4Float extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(4)';
 }
 toArray() {
 return utils.erectArray4(this.renderValues(),this.output[0]);
 }
 }

 module.exports={
 GLTextureArray4Float
 };
 },{"../../../utils":114,"./float":25}],23:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureFloat2D extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(1)';
 }
 toArray() {
 return utils.erect2DFloat(this.renderValues(),this.output[0],this.output[1]);
 }
 }

 module.exports={
 GLTextureFloat2D
 };
 },{"../../../utils":114,"./float":25}],24:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureFloat3D extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(1)';
 }
 toArray() {
 return utils.erect3DFloat(this.renderValues(),this.output[0],this.output[1],this.output[2]);
 }
 }

 module.exports={
 GLTextureFloat3D
 };
 },{"../../../utils":114,"./float":25}],25:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTexture }=require('./index');

 class GLTextureFloat extends GLTexture {
 get textureType() {
 return this.context.FLOAT;
 }
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(1)';
 }
 renderRawOutput() {
 const gl=this.context;
 const size=this.size;
 gl.bindFramebuffer(gl.FRAMEBUFFER,this.framebuffer());
 gl.framebufferTexture2D(
gl.FRAMEBUFFER,
gl.COLOR_ATTACHMENT0,
gl.TEXTURE_2D,
this.texture,
0
 );
 const result=new Float32Array(size[0] * size[1] * 4);
 gl.readPixels(0,0,size[0],size[1],gl.RGBA,gl.FLOAT,result);
 return result;
 }
 renderValues() {
 if (this._deleted) return null;
 return this.renderRawOutput();
 }
 toArray() {
 return utils.erectFloat(this.renderValues(),this.output[0]);
 }
 }

 module.exports={
 GLTextureFloat
 };
 },{"../../../utils":114,"./index":27}],26:[function(require,module,exports){
 const { GLTextureUnsigned }=require('./unsigned');

 class GLTextureGraphical extends GLTextureUnsigned {
 constructor(settings) {
 super(settings);
 this.type='ArrayTexture(4)';
 }
 toArray() {
 return this.renderValues();
 }
 }

 module.exports={
 GLTextureGraphical
 };
 },{"./unsigned":33}],27:[function(require,module,exports){
 const { Texture }=require('../../../texture');

 class GLTexture extends Texture {
 get textureType() {
 throw new Error(`"textureType" not implemented on ${ this.name }`);
 }

 clone() {
 return new this.constructor(this);
 }

 beforeMutate() {
 if (this.texture._refs > 1) {
this.newTexture();
return true;
 }
 return false;
 }

 cloneTexture() {
 this.texture._refs--;
 const { context: gl,size,texture,kernel }=this;
 if (kernel.debug) {
console.warn('cloning internal texture');
 }
 gl.bindFramebuffer(gl.FRAMEBUFFER,this.framebuffer());
 selectTexture(gl,texture);
 gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,texture,0);
 const target=gl.createTexture();
 selectTexture(gl,target);
 gl.texImage2D(gl.TEXTURE_2D,0,this.internalFormat,size[0],size[1],0,this.textureFormat,this.textureType,null);
 gl.copyTexSubImage2D(gl.TEXTURE_2D,0,0,0,0,0,size[0],size[1]);
 target._refs=1;
 this.texture=target;
 }

 newTexture() {
 this.texture._refs--;
 const gl=this.context;
 const size=this.size;
 const kernel=this.kernel;
 if (kernel.debug) {
console.warn('new internal texture');
 }
 const target=gl.createTexture();
 selectTexture(gl,target);
 gl.texImage2D(gl.TEXTURE_2D,0,this.internalFormat,size[0],size[1],0,this.textureFormat,this.textureType,null);
 target._refs=1;
 this.texture=target;
 }

 clear() {
 if (this.texture._refs) {
this.texture._refs--;
const gl=this.context;
const target=this.texture=gl.createTexture();
selectTexture(gl,target);
const size=this.size;
target._refs=1;
gl.texImage2D(gl.TEXTURE_2D,0,this.internalFormat,size[0],size[1],0,this.textureFormat,this.textureType,null);
 }
 const { context: gl,texture }=this;
 gl.bindFramebuffer(gl.FRAMEBUFFER,this.framebuffer());
 gl.bindTexture(gl.TEXTURE_2D,texture);
 selectTexture(gl,texture);
 gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,texture,0);
 gl.clearColor(0,0,0,0);
 gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
 }

 delete() {
 if (this._deleted) return;
 this._deleted=true;
 if (this.texture._refs) {
this.texture._refs--;
if (this.texture._refs) return;
 }
 this.context.deleteTexture(this.texture);
 }

 framebuffer() {
 if (!this._framebuffer) {
this._framebuffer=this.kernel.getRawValueFramebuffer(this.size[0],this.size[1]);
 }
 return this._framebuffer;
 }
 }

 function selectTexture(gl,texture) {
 gl.activeTexture(gl.TEXTURE15);
 gl.bindTexture(gl.TEXTURE_2D,texture);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.CLAMP_TO_EDGE);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.NEAREST);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.NEAREST);
 }

 module.exports={ GLTexture };
 },{"../../../texture":113}],28:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureMemoryOptimized2D extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='MemoryOptimizedNumberTexture';
 }
 toArray() {
 return utils.erectMemoryOptimized2DFloat(this.renderValues(),this.output[0],this.output[1]);
 }
 }

 module.exports={
 GLTextureMemoryOptimized2D
 };
 },{"../../../utils":114,"./float":25}],29:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureMemoryOptimized3D extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='MemoryOptimizedNumberTexture';
 }
 toArray() {
 return utils.erectMemoryOptimized3DFloat(this.renderValues(),this.output[0],this.output[1],this.output[2]);
 }
 }

 module.exports={
 GLTextureMemoryOptimized3D
 };
 },{"../../../utils":114,"./float":25}],30:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureFloat }=require('./float');

 class GLTextureMemoryOptimized extends GLTextureFloat {
 constructor(settings) {
 super(settings);
 this.type='MemoryOptimizedNumberTexture';
 }
 toArray() {
 return utils.erectMemoryOptimizedFloat(this.renderValues(),this.output[0]);
 }
 }

 module.exports={
 GLTextureMemoryOptimized
 };
 },{"../../../utils":114,"./float":25}],31:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureUnsigned }=require('./unsigned');

 class GLTextureUnsigned2D extends GLTextureUnsigned {
 constructor(settings) {
 super(settings);
 this.type='NumberTexture';
 }
 toArray() {
 return utils.erect2DPackedFloat(this.renderValues(),this.output[0],this.output[1]);
 }
 }

 module.exports={
 GLTextureUnsigned2D
 };
 },{"../../../utils":114,"./unsigned":33}],32:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTextureUnsigned }=require('./unsigned');

 class GLTextureUnsigned3D extends GLTextureUnsigned {
 constructor(settings) {
 super(settings);
 this.type='NumberTexture';
 }
 toArray() {
 return utils.erect3DPackedFloat(this.renderValues(),this.output[0],this.output[1],this.output[2]);
 }
 }

 module.exports={
 GLTextureUnsigned3D
 };
 },{"../../../utils":114,"./unsigned":33}],33:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { GLTexture }=require('./index');

 class GLTextureUnsigned extends GLTexture {
 get textureType() {
 return this.context.UNSIGNED_BYTE;
 }
 constructor(settings) {
 super(settings);
 this.type='NumberTexture';
 }
 renderRawOutput() {
 const { context: gl }=this;
 gl.bindFramebuffer(gl.FRAMEBUFFER,this.framebuffer());
 gl.framebufferTexture2D(
gl.FRAMEBUFFER,
gl.COLOR_ATTACHMENT0,
gl.TEXTURE_2D,
this.texture,
0
 );
 const result=new Uint8Array(this.size[0] * this.size[1] * 4);
 gl.readPixels(0,0,this.size[0],this.size[1],gl.RGBA,gl.UNSIGNED_BYTE,result);
 return result;
 }
 renderValues() {
 if (this._deleted) return null;
 return new Float32Array(this.renderRawOutput().buffer);
 }
 toArray() {
 return utils.erectPackedFloat(this.renderValues(),this.output[0]);
 }
 }

 module.exports={
 GLTextureUnsigned
 };
 },{"../../../utils":114,"./index":27}],34:[function(require,module,exports){
 const getContext=require('gl');
 const { WebGLKernel }=require('../web-gl/kernel');
 const { glKernelString }=require('../gl/kernel-string');

 let isSupported=null;
 let testCanvas=null;
 let testContext=null;
 let testExtensions=null;
 let features=null;

 class HeadlessGLKernel extends WebGLKernel {
 static get isSupported() {
 if (isSupported !== null) return isSupported;
 this.setupFeatureChecks();
 isSupported=testContext !== null;
 return isSupported;
 }

 static setupFeatureChecks() {
 testCanvas=null;
 testExtensions=null;
 if (typeof getContext !== 'function') return;
 try {
testContext=getContext(2,2,{
preserveDrawingBuffer: true
});
if (!testContext || !testContext.getExtension) return;
testExtensions={
STACKGL_resize_drawingbuffer: testContext.getExtension('STACKGL_resize_drawingbuffer'),
STACKGL_destroy_context: testContext.getExtension('STACKGL_destroy_context'),
OES_texture_float: testContext.getExtension('OES_texture_float'),
OES_texture_float_linear: testContext.getExtension('OES_texture_float_linear'),
OES_element_index_uint: testContext.getExtension('OES_element_index_uint'),
WEBGL_draw_buffers: testContext.getExtension('WEBGL_draw_buffers'),
WEBGL_color_buffer_float: testContext.getExtension('WEBGL_color_buffer_float'),
};
features=this.getFeatures();
 } catch (e) {
console.warn(e);
 }
 }

 static isContextMatch(context) {
 try {
return context.getParameter(context.RENDERER) === 'ANGLE';
 } catch (e) {
return false;
 }
 }

 static getIsTextureFloat() {
 return Boolean(testExtensions.OES_texture_float);
 }

 static getIsDrawBuffers() {
 return Boolean(testExtensions.WEBGL_draw_buffers);
 }

 static getChannelCount() {
 return testExtensions.WEBGL_draw_buffers ?
testContext.getParameter(testExtensions.WEBGL_draw_buffers.MAX_DRAW_BUFFERS_WEBGL) :
1;
 }

 static getMaxTextureSize() {
 return testContext.getParameter(testContext.MAX_TEXTURE_SIZE);
 }

 static get testCanvas() {
 return testCanvas;
 }

 static get testContext() {
 return testContext;
 }

 static get features() {
 return features;
 }

 initCanvas() {
 return {};
 }

 initContext() {
 return getContext(2,2,{
preserveDrawingBuffer: true
 });
 }

 initExtensions() {
 this.extensions={
STACKGL_resize_drawingbuffer: this.context.getExtension('STACKGL_resize_drawingbuffer'),
STACKGL_destroy_context: this.context.getExtension('STACKGL_destroy_context'),
OES_texture_float: this.context.getExtension('OES_texture_float'),
OES_texture_float_linear: this.context.getExtension('OES_texture_float_linear'),
OES_element_index_uint: this.context.getExtension('OES_element_index_uint'),
WEBGL_draw_buffers: this.context.getExtension('WEBGL_draw_buffers'),
 };
 }

 build() {
 super.build.apply(this,arguments);
 if (!this.fallbackRequested) {
this.extensions.STACKGL_resize_drawingbuffer.resize(this.maxTexSize[0],this.maxTexSize[1]);
 }
 }

 destroyExtensions() {
 this.extensions.STACKGL_resize_drawingbuffer=null;
 this.extensions.STACKGL_destroy_context=null;
 this.extensions.OES_texture_float=null;
 this.extensions.OES_texture_float_linear=null;
 this.extensions.OES_element_index_uint=null;
 this.extensions.WEBGL_draw_buffers=null;
 }

 static destroyContext(context) {
 const extension=context.getExtension('STACKGL_destroy_context');
 if (extension && extension.destroy) {
extension.destroy();
 }
 }

 toString() {
 const setupContextString=`const gl=context || require('gl')(1,1);\n`;
 const destroyContextString=` if (!context) { gl.getExtension('STACKGL_destroy_context').destroy(); }\n`;
 return glKernelString(this.constructor,arguments,this,setupContextString,destroyContextString);
 }

 setOutput(output) {
 super.setOutput(output);
 if (this.graphical && this.extensions.STACKGL_resize_drawingbuffer) {
this.extensions.STACKGL_resize_drawingbuffer.resize(this.maxTexSize[0],this.maxTexSize[1]);
 }
 return this;
 }
 }

 module.exports={
 HeadlessGLKernel
 };
 },{"../gl/kernel-string":12,"../web-gl/kernel":70,"gl":2}],35:[function(require,module,exports){
 class KernelValue {
 constructor(value,settings) {
 const {
name,
kernel,
context,
checkContext,
onRequestContextHandle,
onUpdateValueMismatch,
origin,
strictIntegers,
type,
tactic,
 }=settings;
 if (!name) {
throw new Error('name not set');
 }
 if (!type) {
throw new Error('type not set');
 }
 if (!origin) {
throw new Error('origin not set');
 }
 if (origin !== 'user' && origin !== 'constants') {
throw new Error(`origin must be "user" or "constants" value is "${ origin }"`);
 }
 if (!onRequestContextHandle) {
throw new Error('onRequestContextHandle is not set');
 }
 this.name=name;
 this.origin=origin;
 this.tactic=tactic;
 this.varName=origin === 'constants' ? `constants.${name}` : name;
 this.kernel=kernel;
 this.strictIntegers=strictIntegers;
 this.type=value.type || type;
 this.size=value.size || null;
 this.index=null;
 this.context=context;
 this.checkContext=checkContext !== null && checkContext !== undefined ? checkContext : true;
 this.contextHandle=null;
 this.onRequestContextHandle=onRequestContextHandle;
 this.onUpdateValueMismatch=onUpdateValueMismatch;
 this.forceUploadEachRun=null;
 }

 get id() {
 return `${this.origin}_${name}`;
 }

 getSource() {
 throw new Error(`"getSource" not defined on ${ this.constructor.name }`);
 }

 updateValue(value) {
 throw new Error(`"updateValue" not defined on ${ this.constructor.name }`);
 }
 }

 module.exports={
 KernelValue
 };
 },{}],36:[function(require,module,exports){
 const { utils }=require('../utils');
 const { Input }=require('../input');

 class Kernel {
 static get isSupported() {
 throw new Error(`"isSupported" not implemented on ${ this.name }`);
 }

 static isContextMatch(context) {
 throw new Error(`"isContextMatch" not implemented on ${ this.name }`);
 }

 static getFeatures() {
 throw new Error(`"getFeatures" not implemented on ${ this.name }`);
 }

 static destroyContext(context) {
 throw new Error(`"destroyContext" called on ${ this.name }`);
 }

 static nativeFunctionArguments() {
 throw new Error(`"nativeFunctionArguments" called on ${ this.name }`);
 }

 static nativeFunctionReturnType() {
 throw new Error(`"nativeFunctionReturnType" called on ${ this.name }`);
 }

 static combineKernels() {
 throw new Error(`"combineKernels" called on ${ this.name }`);
 }

 constructor(source,settings) {
 if (typeof source !== 'object') {
if (typeof source !== 'string') {
throw new Error('source not a string');
}
if (!utils.isFunctionString(source)) {
throw new Error('source not a function string');
}
 }
 this.useLegacyEncoder=false;
 this.fallbackRequested=false;
 this.onRequestFallback=null;

 this.argumentNames=typeof source === 'string' ? utils.getArgumentNamesFromString(source) : null;
 this.argumentTypes=null;
 this.argumentSizes=null;
 this.argumentBitRatios=null;
 this.kernelArguments=null;
 this.kernelConstants=null;
 this.forceUploadKernelConstants=null;


 this.source=source;

 this.output=null;

 this.debug=false;

 this.graphical=false;

 this.loopMaxIterations=0;

 this.constants=null;

 this.constantTypes=null;

 this.constantBitRatios=null;

 this.dynamicArguments=false;

 this.dynamicOutput=false;

 this.canvas=null;

 this.context=null;

 this.checkContext=null;

 this.gpu=null;

 this.functions=null;

 this.nativeFunctions=null;

 this.injectedNative=null;

 this.subKernels=null;

 this.validate=true;

 this.immutable=false;

 this.pipeline=false;

 this.precision=null;

 this.tactic=null;

 this.plugins=null;

 this.returnType=null;
 this.leadingReturnStatement=null;
 this.followingReturnStatement=null;
 this.optimizeFloatMemory=null;
 this.strictIntegers=false;
 this.fixIntegerDivisionAccuracy=null;
 this.built=false;
 this.signature=null;
 }

 mergeSettings(settings) {
 for (let p in settings) {
if (!settings.hasOwnProperty(p) || !this.hasOwnProperty(p)) continue;
switch (p) {
case 'output':
if (!Array.isArray(settings.output)) {
this.setOutput(settings.output);
continue;
}
break;
case 'functions':
this.functions=[];
for (let i=0; i < settings.functions.length; i++) {
this.addFunction(settings.functions[i]);
}
continue;
case 'graphical':
if (settings[p] && !settings.hasOwnProperty('precision')) {
this.precision='unsigned';
}
this[p]=settings[p];
continue;
case 'nativeFunctions':
if (!settings.nativeFunctions) continue;
this.nativeFunctions=[];
for (let i=0; i < settings.nativeFunctions.length; i++) {
const s=settings.nativeFunctions[i];
const { name,source }=s;
this.addNativeFunction(name,source,s);
}
continue;
}
this[p]=settings[p];
 }

 if (!this.canvas) this.canvas=this.initCanvas();
 if (!this.context) this.context=this.initContext();
 if (!this.plugins) this.plugins=this.initPlugins(settings);
 }
 build() {
 throw new Error(`"build" not defined on ${ this.constructor.name }`);
 }

 run() {
 throw new Error(`"run" not defined on ${ this.constructor.name }`)
 }

 initCanvas() {
 throw new Error(`"initCanvas" not defined on ${ this.constructor.name }`);
 }

 initContext() {
 throw new Error(`"initContext" not defined on ${ this.constructor.name }`);
 }

 initPlugins(settings) {
 throw new Error(`"initPlugins" not defined on ${ this.constructor.name }`);
 }

 addFunction(source,settings={}) {
 if (source.name && source.source && source.argumentTypes && 'returnType' in source) {
this.functions.push(source);
 } else if ('settings' in source && 'source' in source) {
this.functions.push(this.functionToIGPUFunction(source.source,source.settings));
 } else if (typeof source === 'string' || typeof source === 'function') {
this.functions.push(this.functionToIGPUFunction(source,settings));
 } else {
throw new Error(`function not properly defined`);
 }
 return this;
 }

 addNativeFunction(name,source,settings={}) {
 const { argumentTypes,argumentNames }=settings.argumentTypes ?
splitArgumentTypes(settings.argumentTypes) :
this.constructor.nativeFunctionArguments(source) || {};
 this.nativeFunctions.push({
name,
source,
settings,
argumentTypes,
argumentNames,
returnType: settings.returnType || this.constructor.nativeFunctionReturnType(source)
 });
 return this;
 }

 setupArguments(args) {
 this.kernelArguments=[];
 if (!this.argumentTypes) {
if (!this.argumentTypes) {
this.argumentTypes=[];
for (let i=0; i < args.length; i++) {
const argType=utils.getVariableType(args[i],this.strictIntegers);
const type=argType === 'Integer' ? 'Number' : argType;
this.argumentTypes.push(type);
this.kernelArguments.push({
type
});
}
}
 } else {
for (let i=0; i < this.argumentTypes.length; i++) {
this.kernelArguments.push({
type: this.argumentTypes[i]
});
}
 }

 this.argumentSizes=new Array(args.length);
 this.argumentBitRatios=new Int32Array(args.length);

 for (let i=0; i < args.length; i++) {
const arg=args[i];
this.argumentSizes[i]=arg.constructor === Input ? arg.size : null;
this.argumentBitRatios[i]=this.getBitRatio(arg);
 }

 if (this.argumentNames.length !== args.length) {
throw new Error(`arguments are miss-aligned`);
 }
 }

 setupConstants() {
 this.kernelConstants=[];
 let needsConstantTypes=this.constantTypes === null;
 if (needsConstantTypes) {
this.constantTypes={};
 }
 this.constantBitRatios={};
 if (this.constants) {
for (let name in this.constants) {
if (needsConstantTypes) {
const type=utils.getVariableType(this.constants[name],this.strictIntegers);
this.constantTypes[name]=type;
this.kernelConstants.push({
name,
type
});
} else {
this.kernelConstants.push({
name,
type: this.constantTypes[name]
});
}
this.constantBitRatios[name]=this.getBitRatio(this.constants[name]);
}
 }
 }

 setOptimizeFloatMemory(flag) {
 this.optimizeFloatMemory=flag;
 return this;
 }

 toKernelOutput(output) {
 if (output.hasOwnProperty('x')) {
if (output.hasOwnProperty('y')) {
if (output.hasOwnProperty('z')) {
return [output.x,output.y,output.z];
} else {
return [output.x,output.y];
}
} else {
return [output.x];
}
 } else {
return output;
 }
 }

 setOutput(output) {
 this.output=this.toKernelOutput(output);
 return this;
 }

 setDebug(flag) {
 this.debug=flag;
 return this;
 }

 setGraphical(flag) {
 this.graphical=flag;
 this.precision='unsigned';
 return this;
 }

 setLoopMaxIterations(max) {
 this.loopMaxIterations=max;
 return this;
 }

 setConstants(constants) {
 this.constants=constants;
 return this;
 }

 setConstantTypes(constantTypes) {
 this.constantTypes=constantTypes;
 return this;
 }

 setFunctions(functions) {
 for (let i=0; i < functions.length; i++) {
this.addFunction(functions[i]);
 }
 return this;
 }

 setNativeFunctions(nativeFunctions) {
 for (let i=0; i < nativeFunctions.length; i++) {
const settings=nativeFunctions[i];
const { name,source }=settings;
this.addNativeFunction(name,source,settings);
 }
 return this;
 }

 setInjectedNative(injectedNative) {
 this.injectedNative=injectedNative;
 return this;
 }

 setPipeline(flag) {
 this.pipeline=flag;
 return this;
 }

 setPrecision(flag) {
 this.precision=flag;
 return this;
 }

 setDimensions(flag) {
 utils.warnDeprecated('method','setDimensions','setOutput');
 this.output=flag;
 return this;
 }

 setOutputToTexture(flag) {
 utils.warnDeprecated('method','setOutputToTexture','setPipeline');
 this.pipeline=flag;
 return this;
 }

 setImmutable(flag) {
 this.immutable=flag;
 return this;
 }

 setCanvas(canvas) {
 this.canvas=canvas;
 return this;
 }

 setStrictIntegers(flag) {
 this.strictIntegers=flag;
 return this;
 }

 setDynamicOutput(flag) {
 this.dynamicOutput=flag;
 return this;
 }

 setHardcodeConstants(flag) {
 utils.warnDeprecated('method','setHardcodeConstants');
 this.setDynamicOutput(flag);
 this.setDynamicArguments(flag);
 return this;
 }

 setDynamicArguments(flag) {
 this.dynamicArguments=flag;
 return this;
 }

 setUseLegacyEncoder(flag) {
 this.useLegacyEncoder=flag;
 return this;
 }

 setWarnVarUsage(flag) {
 utils.warnDeprecated('method','setWarnVarUsage');
 return this;
 }

 getCanvas() {
 utils.warnDeprecated('method','getCanvas');
 return this.canvas;
 }

 getWebGl() {
 utils.warnDeprecated('method','getWebGl');
 return this.context;
 }

 setContext(context) {
 this.context=context;
 return this;
 }

 setArgumentTypes(argumentTypes) {
 if (Array.isArray(argumentTypes)) {
this.argumentTypes=argumentTypes;
 } else {
this.argumentTypes=[];
for (const p in argumentTypes) {
if (!argumentTypes.hasOwnProperty(p)) continue;
const argumentIndex=this.argumentNames.indexOf(p);
if (argumentIndex === -1) throw new Error(`unable to find argument ${ p }`);
this.argumentTypes[argumentIndex]=argumentTypes[p];
}
 }
 return this;
 }

 setTactic(tactic) {
 this.tactic=tactic;
 return this;
 }

 requestFallback(args) {
 if (!this.onRequestFallback) {
throw new Error(`"onRequestFallback" not defined on ${ this.constructor.name }`);
 }
 this.fallbackRequested=true;
 return this.onRequestFallback(args);
 }

 validateSettings() {
 throw new Error(`"validateSettings" not defined on ${ this.constructor.name }`);
 }

 addSubKernel(subKernel) {
 if (this.subKernels === null) {
this.subKernels=[];
 }
 if (!subKernel.source) throw new Error('subKernel missing "source" property');
 if (!subKernel.property && isNaN(subKernel.property)) throw new Error('subKernel missing "property" property');
 if (!subKernel.name) throw new Error('subKernel missing "name" property');
 this.subKernels.push(subKernel);
 return this;
 }

 destroy(removeCanvasReferences) {
 throw new Error(`"destroy" called on ${ this.constructor.name }`);
 }

 getBitRatio(value) {
 if (this.precision === 'single') {
return 4;
 } else if (Array.isArray(value[0])) {
return this.getBitRatio(value[0]);
 } else if (value.constructor === Input) {
return this.getBitRatio(value.value);
 }
 switch (value.constructor) {
case Uint8ClampedArray:
case Uint8Array:
case Int8Array:
return 1;
case Uint16Array:
case Int16Array:
return 2;
case Float32Array:
case Int32Array:
default:
return 4;
 }
 }

 getPixels(flip) {
 throw new Error(`"getPixels" called on ${ this.constructor.name }`);
 }

 checkOutput() {
 if (!this.output || !utils.isArray(this.output)) throw new Error('kernel.output not an array');
 if (this.output.length < 1) throw new Error('kernel.output is empty,needs at least 1 value');
 for (let i=0; i < this.output.length; i++) {
if (isNaN(this.output[i]) || this.output[i] < 1) {
throw new Error(`${ this.constructor.name }.output[${ i }] incorrectly defined as \`${ this.output[i] }\`,needs to be numeric,and greater than 0`);
}
 }
 }

 prependString(value) {
 throw new Error(`"prependString" called on ${ this.constructor.name }`);
 }

 hasPrependString(value) {
 throw new Error(`"hasPrependString" called on ${ this.constructor.name }`);
 }

 toJSON() {
 return {
settings: {
output: this.output,
pipeline: this.pipeline,
argumentNames: this.argumentNames,
argumentsTypes: this.argumentTypes,
constants: this.constants,
pluginNames: this.plugins ? this.plugins.map(plugin => plugin.name) : null,
returnType: this.returnType,
}
 };
 }

 buildSignature(args) {
 const Constructor=this.constructor;
 this.signature=Constructor.getSignature(this,Constructor.getArgumentTypes(this,args));
 }

 static getArgumentTypes(kernel,args) {
 const argumentTypes=new Array(args.length);
 for (let i=0; i < args.length; i++) {
const arg=args[i];
const type=kernel.argumentTypes[i];
if (arg.type) {
argumentTypes[i]=arg.type;
} else {
switch (type) {
case 'Number':
case 'Integer':
case 'Float':
case 'ArrayTexture(1)':
argumentTypes[i]=utils.getVariableType(arg);
break;
default:
argumentTypes[i]=type;
}
}
 }
 return argumentTypes;
 }

 static getSignature(kernel,argumentTypes) {
 throw new Error(`"getSignature" not implemented on ${ this.name }`);
 }

 functionToIGPUFunction(source,settings={}) {
 if (typeof source !== 'string' && typeof source !== 'function') throw new Error('source not a string or function');
 const sourceString=typeof source === 'string' ? source : source.toString();
 let argumentTypes=[];

 if (Array.isArray(settings.argumentTypes)) {
argumentTypes=settings.argumentTypes;
 } else if (typeof settings.argumentTypes === 'object') {
argumentTypes=utils.getArgumentNamesFromString(sourceString)
.map(name => settings.argumentTypes[name]) || [];
 } else {
argumentTypes=settings.argumentTypes || [];
 }

 return {
name: utils.getFunctionNameFromString(sourceString) || null,
source: sourceString,
argumentTypes,
returnType: settings.returnType || null,
 };
 }

 onActivate(previousKernel) {}
 }

 function splitArgumentTypes(argumentTypesObject) {
 const argumentNames=Object.keys(argumentTypesObject);
 const argumentTypes=[];
 for (let i=0; i < argumentNames.length; i++) {
 const argumentName=argumentNames[i];
 argumentTypes.push(argumentTypesObject[argumentName]);
 }
 return { argumentTypes,argumentNames };
 }

 module.exports={
 Kernel
 };
 },{"../input":110,"../utils":114}],37:[function(require,module,exports){
 const fragmentShader=`__HEADER__;
__FLOAT_TACTIC_DECLARATION__;
__INT_TACTIC_DECLARATION__;
__SAMPLER_2D_TACTIC_DECLARATION__;

const int LOOP_MAX=__LOOP_MAX__;

__PLUGINS__;
__CONSTANTS__;

varying vec2 vTexCoord;

float acosh(float x) {
 return log(x + sqrt(x * x - 1.0));
}

float sinh(float x) {
 return (pow(${Math.E},x) - pow(${Math.E},-x)) / 2.0;
}

float asinh(float x) {
 return log(x + sqrt(x * x + 1.0));
}

float atan2(float v1,float v2) {
 if (v1 == 0.0 || v2 == 0.0) return 0.0;
 return atan(v1 / v2);
}

float atanh(float x) {
 x=(x + 1.0) / (x - 1.0);
 if (x < 0.0) {
 return 0.5 * log(-x);
 }
 return 0.5 * log(x);
}

float cbrt(float x) {
 if (x >= 0.0) {
 return pow(x,1.0 / 3.0);
 } else {
 return -pow(x,1.0 / 3.0);
 }
}

float cosh(float x) {
 return (pow(${Math.E},x) + pow(${Math.E},-x)) / 2.0; 
}

float expm1(float x) {
 return pow(${Math.E},x) - 1.0; 
}

float fround(highp float x) {
 return x;
}

float imul(float v1,float v2) {
 return float(int(v1) * int(v2));
}

float log10(float x) {
 return log2(x) * (1.0 / log2(10.0));
}

float log1p(float x) {
 return log(1.0 + x);
}

float _pow(float v1,float v2) {
 if (v2 == 0.0) return 1.0;
 return pow(v1,v2);
}

float tanh(float x) {
 float e=exp(2.0 * x);
 return (e - 1.0) / (e + 1.0);
}

float trunc(float x) {
 if (x >= 0.0) {
 return floor(x); 
 } else {
 return ceil(x);
 }
}

vec4 _round(vec4 x) {
 return floor(x + 0.5);
}

float _round(float x) {
 return floor(x + 0.5);
}

const int BIT_COUNT=32;
int modi(int x,int y) {
 return x - y * (x / y);
}

int bitwiseOr(int a,int b) {
 int result=0;
 int n=1;
 
 for (int i=0; i < BIT_COUNT; i++) {
 if ((modi(a,2) == 1) || (modi(b,2) == 1)) {
 result += n;
 }
 a=a / 2;
 b=b / 2;
 n=n * 2;
 if(!(a > 0 || b > 0)) {
 break;
 }
 }
 return result;
}
int bitwiseXOR(int a,int b) {
 int result=0;
 int n=1;
 
 for (int i=0; i < BIT_COUNT; i++) {
 if ((modi(a,2) == 1) != (modi(b,2) == 1)) {
 result += n;
 }
 a=a / 2;
 b=b / 2;
 n=n * 2;
 if(!(a > 0 || b > 0)) {
 break;
 }
 }
 return result;
}
int bitwiseAnd(int a,int b) {
 int result=0;
 int n=1;
 for (int i=0; i < BIT_COUNT; i++) {
 if ((modi(a,2) == 1) && (modi(b,2) == 1)) {
 result += n;
 }
 a=a / 2;
 b=b / 2;
 n=n * 2;
 if(!(a > 0 && b > 0)) {
 break;
 }
 }
 return result;
}
int bitwiseNot(int a) {
 int result=0;
 int n=1;
 
 for (int i=0; i < BIT_COUNT; i++) {
 if (modi(a,2) == 0) {
 result += n; 
 }
 a=a / 2;
 n=n * 2;
 }
 return result;
}
int bitwiseZeroFillLeftShift(int n,int shift) {
 int maxBytes=BIT_COUNT;
 for (int i=0; i < BIT_COUNT; i++) {
 if (maxBytes >= n) {
 break;
 }
 maxBytes *= 2;
 }
 for (int i=0; i < BIT_COUNT; i++) {
 if (i >= shift) {
 break;
 }
 n *= 2;
 }

 int result=0;
 int byteVal=1;
 for (int i=0; i < BIT_COUNT; i++) {
 if (i >= maxBytes) break;
 if (modi(n,2) > 0) { result += byteVal; }
 n=int(n / 2);
 byteVal *= 2;
 }
 return result;
}

int bitwiseSignedRightShift(int num,int shifts) {
 return int(floor(float(num) / pow(2.0,float(shifts))));
}

int bitwiseZeroFillRightShift(int n,int shift) {
 int maxBytes=BIT_COUNT;
 for (int i=0; i < BIT_COUNT; i++) {
 if (maxBytes >= n) {
 break;
 }
 maxBytes *= 2;
 }
 for (int i=0; i < BIT_COUNT; i++) {
 if (i >= shift) {
 break;
 }
 n /= 2;
 }
 int result=0;
 int byteVal=1;
 for (int i=0; i < BIT_COUNT; i++) {
 if (i >= maxBytes) break;
 if (modi(n,2) > 0) { result += byteVal; }
 n=int(n / 2);
 byteVal *= 2;
 }
 return result;
}

vec2 integerMod(vec2 x,float y) {
 vec2 res=floor(mod(x,y));
 return res * step(1.0 - floor(y),-res);
}

vec3 integerMod(vec3 x,float y) {
 vec3 res=floor(mod(x,y));
 return res * step(1.0 - floor(y),-res);
}

vec4 integerMod(vec4 x,vec4 y) {
 vec4 res=floor(mod(x,y));
 return res * step(1.0 - floor(y),-res);
}

float integerMod(float x,float y) {
 float res=floor(mod(x,y));
 return res * (res > floor(y) - 1.0 ? 0.0 : 1.0);
}

int integerMod(int x,int y) {
 return x - (y * int(x / y));
}

__DIVIDE_WITH_INTEGER_CHECK__;

// Here be dragons!
// DO NOT OPTIMIZE THIS CODE
// YOU WILL BREAK SOMETHING ON SOMEBODY\'S MACHINE
// LEAVE IT AS IT IS,LEST YOU WASTE YOUR OWN TIME
const vec2 MAGIC_VEC=vec2(1.0,-256.0);
const vec4 SCALE_FACTOR=vec4(1.0,256.0,65536.0,0.0);
const vec4 SCALE_FACTOR_INV=vec4(1.0,0.00390625,0.0000152587890625,0.0); // 1,1/256,1/65536
float decode32(vec4 texel) {
 __DECODE32_ENDIANNESS__;
 texel *= 255.0;
 vec2 gte128;
 gte128.x=texel.b >= 128.0 ? 1.0 : 0.0;
 gte128.y=texel.a >= 128.0 ? 1.0 : 0.0;
 float exponent=2.0 * texel.a - 127.0 + dot(gte128,MAGIC_VEC);
 float res=exp2(_round(exponent));
 texel.b=texel.b - 128.0 * gte128.x;
 res=dot(texel,SCALE_FACTOR) * exp2(_round(exponent-23.0)) + res;
 res *= gte128.y * -2.0 + 1.0;
 return res;
}

float decode16(vec4 texel,int index) {
 int channel=integerMod(index,2);
 if (channel == 0) return texel.r * 255.0 + texel.g * 65280.0;
 if (channel == 1) return texel.b * 255.0 + texel.a * 65280.0;
 return 0.0;
}

float decode8(vec4 texel,int index) {
 int channel=integerMod(index,4);
 if (channel == 0) return texel.r * 255.0;
 if (channel == 1) return texel.g * 255.0;
 if (channel == 2) return texel.b * 255.0;
 if (channel == 3) return texel.a * 255.0;
 return 0.0;
}

vec4 legacyEncode32(float f) {
 float F=abs(f);
 float sign=f < 0.0 ? 1.0 : 0.0;
 float exponent=floor(log2(F));
 float mantissa=(exp2(-exponent) * F);
 // exponent += floor(log2(mantissa));
 vec4 texel=vec4(F * exp2(23.0-exponent)) * SCALE_FACTOR_INV;
 texel.rg=integerMod(texel.rg,256.0);
 texel.b=integerMod(texel.b,128.0);
 texel.a=exponent*0.5 + 63.5;
 texel.ba += vec2(integerMod(exponent+127.0,2.0),sign) * 128.0;
 texel=floor(texel);
 texel *= 0.003921569; // 1/255
 __ENCODE32_ENDIANNESS__;
 return texel;
}

// https://github.com/gpujs/gpu.js/wiki/Encoder-details
vec4 encode32(float value) {
 if (value == 0.0) return vec4(0,0,0,0);

 float exponent;
 float mantissa;
 vec4 result;
 float sgn;

 sgn=step(0.0,-value);
 value=abs(value);

 exponent=floor(log2(value));

 mantissa=value*pow(2.0,-exponent)-1.0;
 exponent=exponent+127.0;
 result=vec4(0,0,0,0);

 result.a=floor(exponent/2.0);
 exponent=exponent - result.a*2.0;
 result.a=result.a + 128.0*sgn;

 result.b=floor(mantissa * 128.0);
 mantissa=mantissa - result.b / 128.0;
 result.b=result.b + exponent*128.0;

 result.g=floor(mantissa*32768.0);
 mantissa=mantissa - result.g/32768.0;

 result.r=floor(mantissa*8388608.0);
 return result/255.0;
}
// Dragons end here

int index;
ivec3 threadId;

ivec3 indexTo3D(int idx,ivec3 texDim) {
 int z=int(idx / (texDim.x * texDim.y));
 idx -= z * int(texDim.x * texDim.y);
 int y=int(idx / texDim.x);
 int x=int(integerMod(idx,texDim.x));
 return ivec3(x,y,z);
}

float get32(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + texDim.x * (y + texDim.y * z);
 int w=texSize.x;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 vec4 texel=texture2D(tex,st / vec2(texSize));
 return decode32(texel);
}

float get16(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + texDim.x * (y + texDim.y * z);
 int w=texSize.x * 2;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 vec4 texel=texture2D(tex,st / vec2(texSize.x * 2,texSize.y));
 return decode16(texel,index);
}

float get8(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + texDim.x * (y + texDim.y * z);
 int w=texSize.x * 4;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 vec4 texel=texture2D(tex,st / vec2(texSize.x * 4,texSize.y));
 return decode8(texel,index);
}

float getMemoryOptimized32(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + texDim.x * (y + texDim.y * z);
 int channel=integerMod(index,4);
 index=index / 4;
 int w=texSize.x;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 vec4 texel=texture2D(tex,st / vec2(texSize));
 if (channel == 0) return texel.r;
 if (channel == 1) return texel.g;
 if (channel == 2) return texel.b;
 if (channel == 3) return texel.a;
 return 0.0;
}

vec4 getImage2D(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + texDim.x * (y + texDim.y * z);
 int w=texSize.x;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 return texture2D(tex,st / vec2(texSize));
}

float getFloatFromSampler2D(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 vec4 result=getImage2D(tex,texSize,texDim,z,y,x);
 return result[0];
}

vec2 getVec2FromSampler2D(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 vec4 result=getImage2D(tex,texSize,texDim,z,y,x);
 return vec2(result[0],result[1]);
}

vec2 getMemoryOptimizedVec2(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + (texDim.x * (y + (texDim.y * z)));
 int channel=integerMod(index,2);
 index=index / 2;
 int w=texSize.x;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 vec4 texel=texture2D(tex,st / vec2(texSize));
 if (channel == 0) return vec2(texel.r,texel.g);
 if (channel == 1) return vec2(texel.b,texel.a);
 return vec2(0.0,0.0);
}

vec3 getVec3FromSampler2D(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 vec4 result=getImage2D(tex,texSize,texDim,z,y,x);
 return vec3(result[0],result[1],result[2]);
}

vec3 getMemoryOptimizedVec3(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int fieldIndex=3 * (x + texDim.x * (y + texDim.y * z));
 int vectorIndex=fieldIndex / 4;
 int vectorOffset=fieldIndex - vectorIndex * 4;
 int readY=vectorIndex / texSize.x;
 int readX=vectorIndex - readY * texSize.x;
 vec4 tex1=texture2D(tex,(vec2(readX,readY) + 0.5) / vec2(texSize));
 
 if (vectorOffset == 0) {
 return tex1.xyz;
 } else if (vectorOffset == 1) {
 return tex1.yzw;
 } else {
 readX++;
 if (readX >= texSize.x) {
 readX=0;
 readY++;
 }
 vec4 tex2=texture2D(tex,vec2(readX,readY) / vec2(texSize));
 if (vectorOffset == 2) {
 return vec3(tex1.z,tex1.w,tex2.x);
 } else {
 return vec3(tex1.w,tex2.x,tex2.y);
 }
 }
}

vec4 getVec4FromSampler2D(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 return getImage2D(tex,texSize,texDim,z,y,x);
}

vec4 getMemoryOptimizedVec4(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + texDim.x * (y + texDim.y * z);
 int channel=integerMod(index,2);
 int w=texSize.x;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 vec4 texel=texture2D(tex,st / vec2(texSize));
 return vec4(texel.r,texel.g,texel.b,texel.a);
}

vec4 actualColor;
void color(float r,float g,float b,float a) {
 actualColor=vec4(r,g,b,a);
}

void color(float r,float g,float b) {
 color(r,g,b,1.0);
}

void color(sampler2D image) {
 actualColor=texture2D(image,vTexCoord);
}

float modulo(float number,float divisor) {
 if (number < 0.0) {
 number=abs(number);
 if (divisor < 0.0) {
 divisor=abs(divisor);
 }
 return -mod(number,divisor);
 }
 if (divisor < 0.0) {
 divisor=abs(divisor);
 }
 return mod(number,divisor);
}

__INJECTED_NATIVE__;
__MAIN_CONSTANTS__;
__MAIN_ARGUMENTS__;
__KERNEL__;

void main(void) {
 index=int(vTexCoord.s * float(uTexSize.x)) + int(vTexCoord.t * float(uTexSize.y)) * uTexSize.x;
 __MAIN_RESULT__;
}`;

 module.exports={
 fragmentShader
 };
 },{}],38:[function(require,module,exports){
 const { utils }=require('../../utils');
 const { FunctionNode }=require('../function-node');

 class WebGLFunctionNode extends FunctionNode {
 constructor(source,settings) {
 super(source,settings);
 if (settings && settings.hasOwnProperty('fixIntegerDivisionAccuracy')) {
this.fixIntegerDivisionAccuracy=settings.fixIntegerDivisionAccuracy;
 }
 }

 astConditionalExpression(ast,retArr) {
 if (ast.type !== 'ConditionalExpression') {
throw this.astErrorOutput('Not a conditional expression',ast);
 }
 const consequentType=this.getType(ast.consequent);
 const alternateType=this.getType(ast.alternate);
 if (consequentType === null && alternateType === null) {
retArr.push('if (');
this.astGeneric(ast.test,retArr);
retArr.push(') {');
this.astGeneric(ast.consequent,retArr);
retArr.push(';');
retArr.push('} else {');
this.astGeneric(ast.alternate,retArr);
retArr.push(';');
retArr.push('}');
return retArr;
 }
 retArr.push('(');
 this.astGeneric(ast.test,retArr);
 retArr.push('?');
 this.astGeneric(ast.consequent,retArr);
 retArr.push(':');
 this.astGeneric(ast.alternate,retArr);
 retArr.push(')');
 return retArr;
 }

 astFunction(ast,retArr) {
 if (this.isRootKernel) {
retArr.push('void');
 } else {
if (!this.returnType) {
const lastReturn=this.findLastReturn();
if (lastReturn) {
this.returnType=this.getType(ast.body);
if (this.returnType === 'LiteralInteger') {
this.returnType='Number';
}
}
}

const { returnType }=this;
if (!returnType) {
retArr.push('void');
} else {
const type=typeMap[returnType];
if (!type) {
throw new Error(`unknown type ${returnType}`);
}
retArr.push(type);
}
 }
 retArr.push(' ');
 retArr.push(this.name);
 retArr.push('(');

 if (!this.isRootKernel) {
for (let i=0; i < this.argumentNames.length; ++i) {
const argumentName=this.argumentNames[i];

if (i > 0) {
retArr.push(',');
}
let argumentType=this.argumentTypes[this.argumentNames.indexOf(argumentName)];
if (!argumentType) {
throw this.astErrorOutput(`Unknown argument ${argumentName} type`,ast);
}
if (argumentType === 'LiteralInteger') {
this.argumentTypes[i]=argumentType='Number';
}
const type=typeMap[argumentType];
if (!type) {
throw this.astErrorOutput('Unexpected expression',ast);
}
const name=utils.sanitizeName(argumentName);
if (type === 'sampler2D' || type === 'sampler2DArray') {
retArr.push(`${type} user_${name},ivec2 user_${name}Size,ivec3 user_${name}Dim`);
} else {
retArr.push(`${type} user_${name}`);
}
}
 }

 retArr.push(') {\n');

 for (let i=0; i < ast.body.body.length; ++i) {
this.astGeneric(ast.body.body[i],retArr);
retArr.push('\n');
 }

 retArr.push('}\n');
 return retArr;
 }

 astReturnStatement(ast,retArr) {
 if (!ast.argument) throw this.astErrorOutput('Unexpected return statement',ast);
 this.pushState('skip-literal-correction');
 const type=this.getType(ast.argument);
 this.popState('skip-literal-correction');

 const result=[];

 if (!this.returnType) {
if (type === 'LiteralInteger' || type === 'Integer') {
this.returnType='Number';
} else {
this.returnType=type;
}
 }

 switch (this.returnType) {
case 'LiteralInteger':
case 'Number':
case 'Float':
switch (type) {
case 'Integer':
result.push('float(');
this.astGeneric(ast.argument,result);
result.push(')');
break;
case 'LiteralInteger':
this.castLiteralToFloat(ast.argument,result);

if (this.getType(ast) === 'Integer') {
 result.unshift('float(');
 result.push(')');
}
break;
default:
this.astGeneric(ast.argument,result);
}
break;
case 'Integer':
switch (type) {
case 'Float':
case 'Number':
this.castValueToInteger(ast.argument,result);
break;
case 'LiteralInteger':
this.castLiteralToInteger(ast.argument,result);
break;
default:
this.astGeneric(ast.argument,result);
}
break;
case 'Array(4)':
case 'Array(3)':
case 'Array(2)':
case 'Matrix(2)':
case 'Matrix(3)':
case 'Matrix(4)':
case 'Input':
this.astGeneric(ast.argument,result);
break;
default:
throw this.astErrorOutput(`unhandled return type ${this.returnType}`,ast);
 }

 if (this.isRootKernel) {
retArr.push(`kernelResult=${ result.join('') };`);
retArr.push('return;');
 } else if (this.isSubKernel) {
retArr.push(`subKernelResult_${ this.name }=${ result.join('') };`);
retArr.push(`return subKernelResult_${ this.name };`);
 } else {
retArr.push(`return ${ result.join('') };`);
 }
 return retArr;
 }

 astLiteral(ast,retArr) {
 if (isNaN(ast.value)) {
throw this.astErrorOutput(
'Non-numeric literal not supported : ' + ast.value,
ast
);
 }

 const key=this.astKey(ast);
 if (Number.isInteger(ast.value)) {
if (this.isState('casting-to-integer') || this.isState('building-integer')) {
this.literalTypes[key]='Integer';
retArr.push(`${ast.value}`);
} else if (this.isState('casting-to-float') || this.isState('building-float')) {
this.literalTypes[key]='Number';
retArr.push(`${ast.value}.0`);
} else {
this.literalTypes[key]='Number';
retArr.push(`${ast.value}.0`);
}
 } else if (this.isState('casting-to-integer') || this.isState('building-integer')) {
this.literalTypes[key]='Integer';
retArr.push(Math.round(ast.value));
 } else {
this.literalTypes[key]='Number';
retArr.push(`${ast.value}`);
 }
 return retArr;
 }

 astBinaryExpression(ast,retArr) {
 if (this.checkAndUpconvertOperator(ast,retArr)) {
return retArr;
 }

 if (this.fixIntegerDivisionAccuracy && ast.operator === '/') {
retArr.push('divWithIntCheck(');
this.pushState('building-float');
switch (this.getType(ast.left)) {
case 'Integer':
this.castValueToFloat(ast.left,retArr);
break;
case 'LiteralInteger':
this.castLiteralToFloat(ast.left,retArr);
break;
default:
this.astGeneric(ast.left,retArr);
}
retArr.push(',');
switch (this.getType(ast.right)) {
case 'Integer':
this.castValueToFloat(ast.right,retArr);
break;
case 'LiteralInteger':
this.castLiteralToFloat(ast.right,retArr);
break;
default:
this.astGeneric(ast.right,retArr);
}
this.popState('building-float');
retArr.push(')');
return retArr;
 }

 retArr.push('(');
 const leftType=this.getType(ast.left) || 'Number';
 const rightType=this.getType(ast.right) || 'Number';
 if (!leftType || !rightType) {
throw this.astErrorOutput(`Unhandled binary expression`,ast);
 }
 const key=leftType + ' & ' + rightType;
 switch (key) {
case 'Integer & Integer':
this.pushState('building-integer');
this.astGeneric(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.astGeneric(ast.right,retArr);
this.popState('building-integer');
break;
case 'Number & Float':
case 'Float & Number':
case 'Float & Float':
case 'Number & Number':
this.pushState('building-float');
this.astGeneric(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.astGeneric(ast.right,retArr);
this.popState('building-float');
break;
case 'LiteralInteger & LiteralInteger':
if (this.isState('casting-to-integer') || this.isState('building-integer')) {
this.pushState('building-integer');
this.astGeneric(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.astGeneric(ast.right,retArr);
this.popState('building-integer');
} else {
this.pushState('building-float');
this.castLiteralToFloat(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.castLiteralToFloat(ast.right,retArr);
this.popState('building-float');
}
break;

case 'Integer & Float':
case 'Integer & Number':
if (ast.operator === '>' || ast.operator === '<' && ast.right.type === 'Literal') {
if (!Number.isInteger(ast.right.value)) {
this.pushState('building-float');
this.castValueToFloat(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.astGeneric(ast.right,retArr);
this.popState('building-float');
break;
}
}
this.pushState('building-integer');
this.astGeneric(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.pushState('casting-to-integer');
if (ast.right.type === 'Literal') {
const literalResult=[];
this.astGeneric(ast.right,literalResult);
const literalType=this.getType(ast.right);
if (literalType === 'Integer') {
retArr.push(literalResult.join(''));
} else {
throw this.astErrorOutput(`Unhandled binary expression with literal`,ast);
}
} else {
retArr.push('int(');
this.astGeneric(ast.right,retArr);
retArr.push(')');
}
this.popState('casting-to-integer');
this.popState('building-integer');
break;
case 'Integer & LiteralInteger':
this.pushState('building-integer');
this.astGeneric(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.castLiteralToInteger(ast.right,retArr);
this.popState('building-integer');
break;

case 'Number & Integer':
this.pushState('building-float');
this.astGeneric(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.castValueToFloat(ast.right,retArr);
this.popState('building-float');
break;
case 'Float & LiteralInteger':
case 'Number & LiteralInteger':
this.pushState('building-float');
this.astGeneric(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.castLiteralToFloat(ast.right,retArr);
this.popState('building-float');
break;
case 'LiteralInteger & Float':
case 'LiteralInteger & Number':
if (this.isState('casting-to-integer')) {
this.pushState('building-integer');
this.castLiteralToInteger(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.castValueToInteger(ast.right,retArr);
this.popState('building-integer');
} else {
this.pushState('building-float');
this.astGeneric(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.pushState('casting-to-float');
this.astGeneric(ast.right,retArr);
this.popState('casting-to-float');
this.popState('building-float');
}
break;
case 'LiteralInteger & Integer':
this.pushState('building-integer');
this.castLiteralToInteger(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.astGeneric(ast.right,retArr);
this.popState('building-integer');
break;

case 'Boolean & Boolean':
this.pushState('building-boolean');
this.astGeneric(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.astGeneric(ast.right,retArr);
this.popState('building-boolean');
break;

case 'Float & Integer':
this.pushState('building-float');
this.astGeneric(ast.left,retArr);
retArr.push(operatorMap[ast.operator] || ast.operator);
this.castValueToFloat(ast.right,retArr);
this.popState('building-float');
break;

default:
throw this.astErrorOutput(`Unhandled binary expression between ${key}`,ast);
 }
 retArr.push(')');

 return retArr;
 }

 checkAndUpconvertOperator(ast,retArr) {
 const bitwiseResult=this.checkAndUpconvertBitwiseOperators(ast,retArr);
 if (bitwiseResult) {
return bitwiseResult;
 }
 const upconvertableOperators={
'%': this.fixIntegerDivisionAccuracy ? 'integerCorrectionModulo' : 'modulo',
'**': 'pow',
 };
 const foundOperator=upconvertableOperators[ast.operator];
 if (!foundOperator) return null;
 retArr.push(foundOperator);
 retArr.push('(');
 switch (this.getType(ast.left)) {
case 'Integer':
this.castValueToFloat(ast.left,retArr);
break;
case 'LiteralInteger':
this.castLiteralToFloat(ast.left,retArr);
break;
default:
this.astGeneric(ast.left,retArr);
 }
 retArr.push(',');
 switch (this.getType(ast.right)) {
case 'Integer':
this.castValueToFloat(ast.right,retArr);
break;
case 'LiteralInteger':
this.castLiteralToFloat(ast.right,retArr);
break;
default:
this.astGeneric(ast.right,retArr);
 }
 retArr.push(')');
 return retArr;
 }

 checkAndUpconvertBitwiseOperators(ast,retArr) {
 const upconvertableOperators={
'&': 'bitwiseAnd',
'|': 'bitwiseOr',
'^': 'bitwiseXOR',
'<<': 'bitwiseZeroFillLeftShift',
'>>': 'bitwiseSignedRightShift',
'>>>': 'bitwiseZeroFillRightShift',
 };
 const foundOperator=upconvertableOperators[ast.operator];
 if (!foundOperator) return null;
 retArr.push(foundOperator);
 retArr.push('(');
 const leftType=this.getType(ast.left);
 switch (leftType) {
case 'Number':
case 'Float':
this.castValueToInteger(ast.left,retArr);
break;
case 'LiteralInteger':
this.castLiteralToInteger(ast.left,retArr);
break;
default:
this.astGeneric(ast.left,retArr);
 }
 retArr.push(',');
 const rightType=this.getType(ast.right);
 switch (rightType) {
case 'Number':
case 'Float':
this.castValueToInteger(ast.right,retArr);
break;
case 'LiteralInteger':
this.castLiteralToInteger(ast.right,retArr);
break;
default:
this.astGeneric(ast.right,retArr);
 }
 retArr.push(')');
 return retArr;
 }

 checkAndUpconvertBitwiseUnary(ast,retArr) {
 const upconvertableOperators={
'~': 'bitwiseNot',
 };
 const foundOperator=upconvertableOperators[ast.operator];
 if (!foundOperator) return null;
 retArr.push(foundOperator);
 retArr.push('(');
 switch (this.getType(ast.argument)) {
case 'Number':
case 'Float':
this.castValueToInteger(ast.argument,retArr);
break;
case 'LiteralInteger':
this.castLiteralToInteger(ast.argument,retArr);
break;
default:
this.astGeneric(ast.argument,retArr);
 }
 retArr.push(')');
 return retArr;
 }

 castLiteralToInteger(ast,retArr) {
 this.pushState('casting-to-integer');
 this.astGeneric(ast,retArr);
 this.popState('casting-to-integer');
 return retArr;
 }

 castLiteralToFloat(ast,retArr) {
 this.pushState('casting-to-float');
 this.astGeneric(ast,retArr);
 this.popState('casting-to-float');
 return retArr;
 }

 castValueToInteger(ast,retArr) {
 this.pushState('casting-to-integer');
 retArr.push('int(');
 this.astGeneric(ast,retArr);
 retArr.push(')');
 this.popState('casting-to-integer');
 return retArr;
 }

 castValueToFloat(ast,retArr) {
 this.pushState('casting-to-float');
 retArr.push('float(');
 this.astGeneric(ast,retArr);
 retArr.push(')');
 this.popState('casting-to-float');
 return retArr;
 }

 astIdentifierExpression(idtNode,retArr) {
 if (idtNode.type !== 'Identifier') {
throw this.astErrorOutput('IdentifierExpression - not an Identifier',idtNode);
 }

 const type=this.getType(idtNode);

 const name=utils.sanitizeName(idtNode.name);
 if (idtNode.name === 'Infinity') {
retArr.push('3.402823466e+38');
 } else if (type === 'Boolean') {
if (this.argumentNames.indexOf(name) > -1) {
retArr.push(`bool(user_${name})`);
} else {
retArr.push(`user_${name}`);
}
 } else {
retArr.push(`user_${name}`);
 }

 return retArr;
 }

 astForStatement(forNode,retArr) {
 if (forNode.type !== 'ForStatement') {
throw this.astErrorOutput('Invalid for statement',forNode);
 }

 const initArr=[];
 const testArr=[];
 const updateArr=[];
 const bodyArr=[];
 let isSafe=null;

 if (forNode.init) {
const { declarations }=forNode.init;
if (declarations.length > 1) {
isSafe=false;
}
this.astGeneric(forNode.init,initArr);
for (let i=0; i < declarations.length; i++) {
if (declarations[i].init && declarations[i].init.type !== 'Literal') {
isSafe=false;
}
}
 } else {
isSafe=false;
 }

 if (forNode.test) {
this.astGeneric(forNode.test,testArr);
 } else {
isSafe=false;
 }

 if (forNode.update) {
this.astGeneric(forNode.update,updateArr);
 } else {
isSafe=false;
 }

 if (forNode.body) {
this.pushState('loop-body');
this.astGeneric(forNode.body,bodyArr);
this.popState('loop-body');
 }

 if (isSafe === null) {
isSafe=this.isSafe(forNode.init) && this.isSafe(forNode.test);
 }

 if (isSafe) {
const initString=initArr.join('');
const initNeedsSemiColon=initString[initString.length - 1] !== ';';
retArr.push(`for (${initString}${initNeedsSemiColon ? ';' : ''}${testArr.join('')};${updateArr.join('')}){\n`);
retArr.push(bodyArr.join(''));
retArr.push('}\n');
 } else {
const iVariableName=this.getInternalVariableName('safeI');
if (initArr.length > 0) {
retArr.push(initArr.join(''),'\n');
}
retArr.push(`for (int ${iVariableName}=0;${iVariableName}<LOOP_MAX;${iVariableName}++){\n`);
if (testArr.length > 0) {
retArr.push(`if (!${testArr.join('')}) break;\n`);
}
retArr.push(bodyArr.join(''));
retArr.push(`\n${updateArr.join('')};`);
retArr.push('}\n');
 }
 return retArr;
 }

 astWhileStatement(whileNode,retArr) {
 if (whileNode.type !== 'WhileStatement') {
throw this.astErrorOutput('Invalid while statement',whileNode);
 }

 const iVariableName=this.getInternalVariableName('safeI');
 retArr.push(`for (int ${iVariableName}=0;${iVariableName}<LOOP_MAX;${iVariableName}++){\n`);
 retArr.push('if (!');
 this.astGeneric(whileNode.test,retArr);
 retArr.push(') break;\n');
 this.astGeneric(whileNode.body,retArr);
 retArr.push('}\n');

 return retArr;
 }

 astDoWhileStatement(doWhileNode,retArr) {
 if (doWhileNode.type !== 'DoWhileStatement') {
throw this.astErrorOutput('Invalid while statement',doWhileNode);
 }

 const iVariableName=this.getInternalVariableName('safeI');
 retArr.push(`for (int ${iVariableName}=0;${iVariableName}<LOOP_MAX;${iVariableName}++){\n`);
 this.astGeneric(doWhileNode.body,retArr);
 retArr.push('if (!');
 this.astGeneric(doWhileNode.test,retArr);
 retArr.push(') break;\n');
 retArr.push('}\n');

 return retArr;
 }


 astAssignmentExpression(assNode,retArr) {
 if (assNode.operator === '%=') {
this.astGeneric(assNode.left,retArr);
retArr.push('=');
retArr.push('mod(');
this.astGeneric(assNode.left,retArr);
retArr.push(',');
this.astGeneric(assNode.right,retArr);
retArr.push(')');
 } else if (assNode.operator === '**=') {
this.astGeneric(assNode.left,retArr);
retArr.push('=');
retArr.push('pow(');
this.astGeneric(assNode.left,retArr);
retArr.push(',');
this.astGeneric(assNode.right,retArr);
retArr.push(')');
 } else {
const leftType=this.getType(assNode.left);
const rightType=this.getType(assNode.right);
this.astGeneric(assNode.left,retArr);
retArr.push(assNode.operator);
if (leftType !== 'Integer' && rightType === 'Integer') {
retArr.push('float(');
this.astGeneric(assNode.right,retArr);
retArr.push(')');
} else {
this.astGeneric(assNode.right,retArr);
}
return retArr;
 }
 }

 astBlockStatement(bNode,retArr) {
 if (this.isState('loop-body')) {
this.pushState('block-body');
for (let i=0; i < bNode.body.length; i++) {
this.astGeneric(bNode.body[i],retArr);
}
this.popState('block-body');
 } else {
retArr.push('{\n');
for (let i=0; i < bNode.body.length; i++) {
this.astGeneric(bNode.body[i],retArr);
}
retArr.push('}\n');
 }
 return retArr;
 }

 astVariableDeclaration(varDecNode,retArr) {
 const declarations=varDecNode.declarations;
 if (!declarations || !declarations[0] || !declarations[0].init) {
throw this.astErrorOutput('Unexpected expression',varDecNode);
 }
 const result=[];
 let lastType=null;
 const declarationSets=[];
 let declarationSet=[];
 for (let i=0; i < declarations.length; i++) {
const declaration=declarations[i];
const init=declaration.init;
const info=this.getDeclaration(declaration.id);
const actualType=this.getType(declaration.init);
let type=actualType;
if (type === 'LiteralInteger') {
if (info.suggestedType === 'Integer') {
type='Integer';
} else {
type='Number';
}
}
const markupType=typeMap[type];
if (!markupType) {
throw this.astErrorOutput(`Markup type ${ type } not handled`,varDecNode);
}
const declarationResult=[];
if (actualType === 'Integer' && type === 'Integer') {
info.valueType='Number';
if (i === 0 || lastType === null) {
declarationResult.push('float ');
} else if (type !== lastType) {
throw new Error('Unhandled declaration');
}
lastType=type;
declarationResult.push(`user_${utils.sanitizeName(declaration.id.name)}=`);
declarationResult.push('float(');
this.astGeneric(init,declarationResult);
declarationResult.push(')');
} else {
info.valueType=type;
if (i === 0 || lastType === null) {
declarationResult.push(`${markupType} `);
} else if (type !== lastType) {
declarationSets.push(declarationSet.join(','));
declarationSet=[];
declarationResult.push(`${markupType} `);
}
lastType=type;
declarationResult.push(`user_${utils.sanitizeName(declaration.id.name)}=`);
if (actualType === 'Number' && type === 'Integer') {
if (init.left && init.left.type === 'Literal') {
this.astGeneric(init,declarationResult);
} else {
declarationResult.push('int(');
this.astGeneric(init,declarationResult);
declarationResult.push(')');
}
} else if (actualType === 'LiteralInteger' && type === 'Integer') {
this.castLiteralToInteger(init,declarationResult);
} else {
this.astGeneric(init,declarationResult);
}
}
declarationSet.push(declarationResult.join(''));
 }

 if (declarationSet.length > 0) {
declarationSets.push(declarationSet.join(','));
 }

 result.push(declarationSets.join(';'));

 retArr.push(result.join(''));
 retArr.push(';');
 return retArr;
 }

 astIfStatement(ifNode,retArr) {
 retArr.push('if (');
 this.astGeneric(ifNode.test,retArr);
 retArr.push(')');
 if (ifNode.consequent.type === 'BlockStatement') {
this.astGeneric(ifNode.consequent,retArr);
 } else {
retArr.push(' {\n');
this.astGeneric(ifNode.consequent,retArr);
retArr.push('\n}\n');
 }

 if (ifNode.alternate) {
retArr.push('else ');
if (ifNode.alternate.type === 'BlockStatement' || ifNode.alternate.type === 'IfStatement') {
this.astGeneric(ifNode.alternate,retArr);
} else {
retArr.push(' {\n');
this.astGeneric(ifNode.alternate,retArr);
retArr.push('\n}\n');
}
 }
 return retArr;
 }

 astSwitchStatement(ast,retArr) {
 if (ast.type !== 'SwitchStatement') {
throw this.astErrorOutput('Invalid switch statement',ast);
 }
 const { discriminant,cases }=ast;
 const type=this.getType(discriminant);
 const varName=`switchDiscriminant${this.astKey(ast,'_')}`;
 switch (type) {
case 'Float':
case 'Number':
retArr.push(`float ${varName}=`);
this.astGeneric(discriminant,retArr);
retArr.push(';\n');
break;
case 'Integer':
retArr.push(`int ${varName}=`);
this.astGeneric(discriminant,retArr);
retArr.push(';\n');
break;
 }
 if (cases.length === 1 && !cases[0].test) {
this.astGeneric(cases[0].consequent,retArr);
return retArr;
 }

 let fallingThrough=false;
 let defaultResult=[];
 let movingDefaultToEnd=false;
 let pastFirstIf=false;
 for (let i=0; i < cases.length; i++) {
if (!cases[i].test) {
if (cases.length > i + 1) {
movingDefaultToEnd=true;
this.astGeneric(cases[i].consequent,defaultResult);
continue;
} else {
retArr.push(' else {\n');
}
} else {
if (i === 0 || !pastFirstIf) {
pastFirstIf=true;
retArr.push(`if (${varName} == `);
} else {
if (fallingThrough) {
retArr.push(`${varName} == `);
fallingThrough=false;
} else {
retArr.push(` else if (${varName} == `);
}
}
if (type === 'Integer') {
const testType=this.getType(cases[i].test);
switch (testType) {
case 'Number':
case 'Float':
 this.castValueToInteger(cases[i].test,retArr);
 break;
case 'LiteralInteger':
 this.castLiteralToInteger(cases[i].test,retArr);
 break;
}
} else if (type === 'Float') {
const testType=this.getType(cases[i].test);
switch (testType) {
case 'LiteralInteger':
 this.castLiteralToFloat(cases[i].test,retArr);
 break;
case 'Integer':
 this.castValueToFloat(cases[i].test,retArr);
 break;
}
} else {
throw new Error('unhanlded');
}
if (!cases[i].consequent || cases[i].consequent.length === 0) {
fallingThrough=true;
retArr.push(' || ');
continue;
}
retArr.push(`) {\n`);
}
this.astGeneric(cases[i].consequent,retArr);
retArr.push('\n}');
 }
 if (movingDefaultToEnd) {
retArr.push(' else {');
retArr.push(defaultResult.join(''));
retArr.push('}');
 }
 return retArr;
 }

 astThisExpression(tNode,retArr) {
 retArr.push('this');
 return retArr;
 }

 astMemberExpression(mNode,retArr) {
 const {
property,
name,
signature,
origin,
type,
xProperty,
yProperty,
zProperty
 }=this.getMemberExpressionDetails(mNode);
 switch (signature) {
case 'value.thread.value':
case 'this.thread.value':
if (name !== 'x' && name !== 'y' && name !== 'z') {
throw this.astErrorOutput('Unexpected expression,expected `this.thread.x`,`this.thread.y`,or `this.thread.z`',mNode);
}
retArr.push(`threadId.${name}`);
return retArr;
case 'this.output.value':
if (this.dynamicOutput) {
switch (name) {
case 'x':
 if (this.isState('casting-to-float')) {
 retArr.push('float(uOutputDim.x)');
 } else {
 retArr.push('uOutputDim.x');
 }
 break;
case 'y':
 if (this.isState('casting-to-float')) {
 retArr.push('float(uOutputDim.y)');
 } else {
 retArr.push('uOutputDim.y');
 }
 break;
case 'z':
 if (this.isState('casting-to-float')) {
 retArr.push('float(uOutputDim.z)');
 } else {
 retArr.push('uOutputDim.z');
 }
 break;
default:
 throw this.astErrorOutput('Unexpected expression',mNode);
}
} else {
switch (name) {
case 'x':
 if (this.isState('casting-to-integer')) {
 retArr.push(this.output[0]);
 } else {
 retArr.push(this.output[0],'.0');
 }
 break;
case 'y':
 if (this.isState('casting-to-integer')) {
 retArr.push(this.output[1]);
 } else {
 retArr.push(this.output[1],'.0');
 }
 break;
case 'z':
 if (this.isState('casting-to-integer')) {
 retArr.push(this.output[2]);
 } else {
 retArr.push(this.output[2],'.0');
 }
 break;
default:
 throw this.astErrorOutput('Unexpected expression',mNode);
}
}
return retArr;
case 'value':
throw this.astErrorOutput('Unexpected expression',mNode);
case 'value[]':
case 'value[][]':
case 'value[][][]':
case 'value[][][][]':
case 'value.value':
if (origin === 'Math') {
retArr.push(Math[name]);
return retArr;
}
const cleanName=utils.sanitizeName(name);
switch (property) {
case 'r':
retArr.push(`user_${ cleanName }.r`);
return retArr;
case 'g':
retArr.push(`user_${ cleanName }.g`);
return retArr;
case 'b':
retArr.push(`user_${ cleanName }.b`);
return retArr;
case 'a':
retArr.push(`user_${ cleanName }.a`);
return retArr;
}
break;
case 'this.constants.value':
if (typeof xProperty === 'undefined') {
switch (type) {
case 'Array(2)':
case 'Array(3)':
case 'Array(4)':
 retArr.push(`constants_${ utils.sanitizeName(name) }`);
 return retArr;
}
}
case 'this.constants.value[]':
case 'this.constants.value[][]':
case 'this.constants.value[][][]':
case 'this.constants.value[][][][]':
break;
case 'fn()[]':
this.astCallExpression(mNode.object,retArr);
retArr.push('[');
retArr.push(this.memberExpressionPropertyMarkup(property));
retArr.push(']');
return retArr;
case 'fn()[][]':
this.astCallExpression(mNode.object.object,retArr);
retArr.push('[');
retArr.push(this.memberExpressionPropertyMarkup(mNode.object.property));
retArr.push(']');
retArr.push('[');
retArr.push(this.memberExpressionPropertyMarkup(mNode.property));
retArr.push(']');
return retArr;
case '[][]':
this.astArrayExpression(mNode.object,retArr);
retArr.push('[');
retArr.push(this.memberExpressionPropertyMarkup(property));
retArr.push(']');
return retArr;
default:
throw this.astErrorOutput('Unexpected expression',mNode);
 }

 if (mNode.computed === false) {
switch (type) {
case 'Number':
case 'Integer':
case 'Float':
case 'Boolean':
retArr.push(`${origin}_${utils.sanitizeName(name)}`);
return retArr;
}
 }

 const markupName=`${origin}_${utils.sanitizeName(name)}`;

 switch (type) {
case 'Array(2)':
case 'Array(3)':
case 'Array(4)':
this.astGeneric(mNode.object,retArr);
retArr.push('[');
retArr.push(this.memberExpressionPropertyMarkup(xProperty));
retArr.push(']');
break;
case 'HTMLImageArray':
retArr.push(`getImage3D(${ markupName },${ markupName }Size,${ markupName }Dim,`);
this.memberExpressionXYZ(xProperty,yProperty,zProperty,retArr);
retArr.push(')');
break;
case 'ArrayTexture(1)':
retArr.push(`getFloatFromSampler2D(${ markupName },${ markupName }Size,${ markupName }Dim,`);
this.memberExpressionXYZ(xProperty,yProperty,zProperty,retArr);
retArr.push(')');
break;
case 'Array1D(2)':
case 'Array2D(2)':
case 'Array3D(2)':
retArr.push(`getMemoryOptimizedVec2(${ markupName },${ markupName }Size,${ markupName }Dim,`);
this.memberExpressionXYZ(xProperty,yProperty,zProperty,retArr);
retArr.push(')');
break;
case 'ArrayTexture(2)':
retArr.push(`getVec2FromSampler2D(${ markupName },${ markupName }Size,${ markupName }Dim,`);
this.memberExpressionXYZ(xProperty,yProperty,zProperty,retArr);
retArr.push(')');
break;
case 'Array1D(3)':
case 'Array2D(3)':
case 'Array3D(3)':
retArr.push(`getMemoryOptimizedVec3(${ markupName },${ markupName }Size,${ markupName }Dim,`);
this.memberExpressionXYZ(xProperty,yProperty,zProperty,retArr);
retArr.push(')');
break;
case 'ArrayTexture(3)':
retArr.push(`getVec3FromSampler2D(${ markupName },${ markupName }Size,${ markupName }Dim,`);
this.memberExpressionXYZ(xProperty,yProperty,zProperty,retArr);
retArr.push(')');
break;
case 'Array1D(4)':
case 'Array2D(4)':
case 'Array3D(4)':
retArr.push(`getMemoryOptimizedVec4(${ markupName },${ markupName }Size,${ markupName }Dim,`);
this.memberExpressionXYZ(xProperty,yProperty,zProperty,retArr);
retArr.push(')');
break;
case 'ArrayTexture(4)':
case 'HTMLCanvas':
case 'OffscreenCanvas':
case 'HTMLImage':
case 'ImageBitmap':
case 'ImageData':
case 'HTMLVideo':
retArr.push(`getVec4FromSampler2D(${ markupName },${ markupName }Size,${ markupName }Dim,`);
this.memberExpressionXYZ(xProperty,yProperty,zProperty,retArr);
retArr.push(')');
break;
case 'NumberTexture':
case 'Array':
case 'Array2D':
case 'Array3D':
case 'Array4D':
case 'Input':
case 'Number':
case 'Float':
case 'Integer':
if (this.precision === 'single') {
retArr.push(`getMemoryOptimized32(${markupName},${markupName}Size,${markupName}Dim,`);
this.memberExpressionXYZ(xProperty,yProperty,zProperty,retArr);
retArr.push(')');
} else {
const bitRatio=(origin === 'user' ?
 this.lookupFunctionArgumentBitRatio(this.name,name) :
 this.constantBitRatios[name]
);
switch (bitRatio) {
case 1:
 retArr.push(`get8(${markupName},${markupName}Size,${markupName}Dim,`);
 break;
case 2:
 retArr.push(`get16(${markupName},${markupName}Size,${markupName}Dim,`);
 break;
case 4:
case 0:
 retArr.push(`get32(${markupName},${markupName}Size,${markupName}Dim,`);
 break;
default:
 throw new Error(`unhandled bit ratio of ${bitRatio}`);
}
this.memberExpressionXYZ(xProperty,yProperty,zProperty,retArr);
retArr.push(')');
}
break;
case 'MemoryOptimizedNumberTexture':
retArr.push(`getMemoryOptimized32(${ markupName },${ markupName }Size,${ markupName }Dim,`);
this.memberExpressionXYZ(xProperty,yProperty,zProperty,retArr);
retArr.push(')');
break;
case 'Matrix(2)':
case 'Matrix(3)':
case 'Matrix(4)':
retArr.push(`${markupName}[${this.memberExpressionPropertyMarkup(yProperty)}]`);
if (yProperty) {
retArr.push(`[${this.memberExpressionPropertyMarkup(xProperty)}]`);
}
break;
default:
throw new Error(`unhandled member expression "${ type }"`);
 }
 return retArr;
 }

 astCallExpression(ast,retArr) {
 if (!ast.callee) {
throw this.astErrorOutput('Unknown CallExpression',ast);
 }

 let functionName=null;
 const isMathFunction=this.isAstMathFunction(ast);

 if (isMathFunction || (ast.callee.object && ast.callee.object.type === 'ThisExpression')) {
functionName=ast.callee.property.name;
 }
 else if (ast.callee.type === 'SequenceExpression' && ast.callee.expressions[0].type === 'Literal' && !isNaN(ast.callee.expressions[0].raw)) {
functionName=ast.callee.expressions[1].property.name;
 } else {
functionName=ast.callee.name;
 }

 if (!functionName) {
throw this.astErrorOutput(`Unhandled function,couldn't find name`,ast);
 }

 switch (functionName) {
case 'pow':
functionName='_pow';
break;
case 'round':
functionName='_round';
break;
 }

 if (this.calledFunctions.indexOf(functionName) < 0) {
this.calledFunctions.push(functionName);
 }

 if (functionName === 'random' && this.plugins && this.plugins.length > 0) {
for (let i=0; i < this.plugins.length; i++) {
const plugin=this.plugins[i];
if (plugin.functionMatch === 'Math.random()' && plugin.functionReplace) {
retArr.push(plugin.functionReplace);
return retArr;
}
}
 }

 if (this.onFunctionCall) {
this.onFunctionCall(this.name,functionName,ast.arguments);
 }

 retArr.push(functionName);

 retArr.push('(');

 if (isMathFunction) {
for (let i=0; i < ast.arguments.length; ++i) {
const argument=ast.arguments[i];
const argumentType=this.getType(argument);
if (i > 0) {
retArr.push(',');
}

switch (argumentType) {
case 'Integer':
this.castValueToFloat(argument,retArr);
break;
default:
this.astGeneric(argument,retArr);
break;
}
}
 } else {
const targetTypes=this.lookupFunctionArgumentTypes(functionName) || [];
for (let i=0; i < ast.arguments.length; ++i) {
const argument=ast.arguments[i];
let targetType=targetTypes[i];
if (i > 0) {
retArr.push(',');
}
const argumentType=this.getType(argument);
if (!targetType) {
this.triggerImplyArgumentType(functionName,i,argumentType,this);
targetType=argumentType;
}
switch (argumentType) {
case 'Boolean':
this.astGeneric(argument,retArr);
continue;
case 'Number':
case 'Float':
if (targetType === 'Integer') {
 retArr.push('int(');
 this.astGeneric(argument,retArr);
 retArr.push(')');
 continue;
} else if (targetType === 'Number' || targetType === 'Float') {
 this.astGeneric(argument,retArr);
 continue;
} else if (targetType === 'LiteralInteger') {
 this.castLiteralToFloat(argument,retArr);
 continue;
}
break;
case 'Integer':
if (targetType === 'Number' || targetType === 'Float') {
 retArr.push('float(');
 this.astGeneric(argument,retArr);
 retArr.push(')');
 continue;
} else if (targetType === 'Integer') {
 this.astGeneric(argument,retArr);
 continue;
}
break;
case 'LiteralInteger':
if (targetType === 'Integer') {
 this.castLiteralToInteger(argument,retArr);
 continue;
} else if (targetType === 'Number' || targetType === 'Float') {
 this.castLiteralToFloat(argument,retArr);
 continue;
} else if (targetType === 'LiteralInteger') {
 this.astGeneric(argument,retArr);
 continue;
}
break;
case 'Array(2)':
case 'Array(3)':
case 'Array(4)':
if (targetType === argumentType) {
 if (argument.type === 'Identifier') {
 retArr.push(`user_${utils.sanitizeName(argument.name)}`);
 } else if (argument.type === 'ArrayExpression' || argument.type === 'MemberExpression' || argument.type === 'CallExpression') {
 this.astGeneric(argument,retArr);
 } else {
 throw this.astErrorOutput(`Unhandled argument type ${ argument.type }`,ast);
 }
 continue;
}
break;
case 'HTMLCanvas':
case 'OffscreenCanvas':
case 'HTMLImage':
case 'ImageBitmap':
case 'ImageData':
case 'HTMLImageArray':
case 'HTMLVideo':
case 'ArrayTexture(1)':
case 'ArrayTexture(2)':
case 'ArrayTexture(3)':
case 'ArrayTexture(4)':
case 'Array':
case 'Input':
if (targetType === argumentType) {
 if (argument.type !== 'Identifier') throw this.astErrorOutput(`Unhandled argument type ${ argument.type }`,ast);
 this.triggerImplyArgumentBitRatio(this.name,argument.name,functionName,i);
 const name=utils.sanitizeName(argument.name);
 retArr.push(`user_${name},user_${name}Size,user_${name}Dim`);
 continue;
}
break;
}
throw this.astErrorOutput(`Unhandled argument combination of ${ argumentType } and ${ targetType } for argument named "${ argument.name }"`,ast);
}
 }
 retArr.push(')');

 return retArr;
 }

 astArrayExpression(arrNode,retArr) {
 const returnType=this.getType(arrNode);

 const arrLen=arrNode.elements.length;

 switch (returnType) {
case 'Matrix(2)':
case 'Matrix(3)':
case 'Matrix(4)':
retArr.push(`mat${arrLen}(`);
break;
default:
retArr.push(`vec${arrLen}(`);
 }
 for (let i=0; i < arrLen; ++i) {
if (i > 0) {
retArr.push(',');
}
const subNode=arrNode.elements[i];
this.astGeneric(subNode,retArr)
 }
 retArr.push(')');

 return retArr;
 }

 memberExpressionXYZ(x,y,z,retArr) {
 if (z) {
retArr.push(this.memberExpressionPropertyMarkup(z),',');
 } else {
retArr.push('0,');
 }
 if (y) {
retArr.push(this.memberExpressionPropertyMarkup(y),',');
 } else {
retArr.push('0,');
 }
 retArr.push(this.memberExpressionPropertyMarkup(x));
 return retArr;
 }

 memberExpressionPropertyMarkup(property) {
 if (!property) {
throw new Error('Property not set');
 }
 const type=this.getType(property);
 const result=[];
 switch (type) {
case 'Number':
case 'Float':
this.castValueToInteger(property,result);
break;
case 'LiteralInteger':
this.castLiteralToInteger(property,result);
break;
default:
this.astGeneric(property,result);
 }
 return result.join('');
 }
 }

 const typeMap={
 'Array': 'sampler2D',
 'Array(2)': 'vec2',
 'Array(3)': 'vec3',
 'Array(4)': 'vec4',
 'Matrix(2)': 'mat2',
 'Matrix(3)': 'mat3',
 'Matrix(4)': 'mat4',
 'Array2D': 'sampler2D',
 'Array3D': 'sampler2D',
 'Boolean': 'bool',
 'Float': 'float',
 'Input': 'sampler2D',
 'Integer': 'int',
 'Number': 'float',
 'LiteralInteger': 'float',
 'NumberTexture': 'sampler2D',
 'MemoryOptimizedNumberTexture': 'sampler2D',
 'ArrayTexture(1)': 'sampler2D',
 'ArrayTexture(2)': 'sampler2D',
 'ArrayTexture(3)': 'sampler2D',
 'ArrayTexture(4)': 'sampler2D',
 'HTMLVideo': 'sampler2D',
 'HTMLCanvas': 'sampler2D',
 'OffscreenCanvas': 'sampler2D',
 'HTMLImage': 'sampler2D',
 'ImageBitmap': 'sampler2D',
 'ImageData': 'sampler2D',
 'HTMLImageArray': 'sampler2DArray',
 };

 const operatorMap={
 '===': '==',
 '!==': '!='
 };

 module.exports={
 WebGLFunctionNode
 };
 },{"../../utils":114,"../function-node":10}],39:[function(require,module,exports){
 const { WebGLKernelValueBoolean }=require('./kernel-value/boolean');
 const { WebGLKernelValueFloat }=require('./kernel-value/float');
 const { WebGLKernelValueInteger }=require('./kernel-value/integer');

 const { WebGLKernelValueHTMLImage }=require('./kernel-value/html-image');
 const { WebGLKernelValueDynamicHTMLImage }=require('./kernel-value/dynamic-html-image');

 const { WebGLKernelValueHTMLVideo }=require('./kernel-value/html-video');
 const { WebGLKernelValueDynamicHTMLVideo }=require('./kernel-value/dynamic-html-video');

 const { WebGLKernelValueSingleInput }=require('./kernel-value/single-input');
 const { WebGLKernelValueDynamicSingleInput }=require('./kernel-value/dynamic-single-input');

 const { WebGLKernelValueUnsignedInput }=require('./kernel-value/unsigned-input');
 const { WebGLKernelValueDynamicUnsignedInput }=require('./kernel-value/dynamic-unsigned-input');

 const { WebGLKernelValueMemoryOptimizedNumberTexture }=require('./kernel-value/memory-optimized-number-texture');
 const { WebGLKernelValueDynamicMemoryOptimizedNumberTexture }=require('./kernel-value/dynamic-memory-optimized-number-texture');

 const { WebGLKernelValueNumberTexture }=require('./kernel-value/number-texture');
 const { WebGLKernelValueDynamicNumberTexture }=require('./kernel-value/dynamic-number-texture');

 const { WebGLKernelValueSingleArray }=require('./kernel-value/single-array');
 const { WebGLKernelValueDynamicSingleArray }=require('./kernel-value/dynamic-single-array');

 const { WebGLKernelValueSingleArray1DI }=require('./kernel-value/single-array1d-i');
 const { WebGLKernelValueDynamicSingleArray1DI }=require('./kernel-value/dynamic-single-array1d-i');

 const { WebGLKernelValueSingleArray2DI }=require('./kernel-value/single-array2d-i');
 const { WebGLKernelValueDynamicSingleArray2DI }=require('./kernel-value/dynamic-single-array2d-i');

 const { WebGLKernelValueSingleArray3DI }=require('./kernel-value/single-array3d-i');
 const { WebGLKernelValueDynamicSingleArray3DI }=require('./kernel-value/dynamic-single-array3d-i');

 const { WebGLKernelValueArray2 }=require('./kernel-value/array2');
 const { WebGLKernelValueArray3 }=require('./kernel-value/array3');
 const { WebGLKernelValueArray4 }=require('./kernel-value/array4');

 const { WebGLKernelValueUnsignedArray }=require('./kernel-value/unsigned-array');
 const { WebGLKernelValueDynamicUnsignedArray }=require('./kernel-value/dynamic-unsigned-array');

 const kernelValueMaps={
 unsigned: {
 dynamic: {
'Boolean': WebGLKernelValueBoolean,
'Integer': WebGLKernelValueInteger,
'Float': WebGLKernelValueFloat,
'Array': WebGLKernelValueDynamicUnsignedArray,
'Array(2)': WebGLKernelValueArray2,
'Array(3)': WebGLKernelValueArray3,
'Array(4)': WebGLKernelValueArray4,
'Array1D(2)': false,
'Array1D(3)': false,
'Array1D(4)': false,
'Array2D(2)': false,
'Array2D(3)': false,
'Array2D(4)': false,
'Array3D(2)': false,
'Array3D(3)': false,
'Array3D(4)': false,
'Input': WebGLKernelValueDynamicUnsignedInput,
'NumberTexture': WebGLKernelValueDynamicNumberTexture,
'ArrayTexture(1)': WebGLKernelValueDynamicNumberTexture,
'ArrayTexture(2)': WebGLKernelValueDynamicNumberTexture,
'ArrayTexture(3)': WebGLKernelValueDynamicNumberTexture,
'ArrayTexture(4)': WebGLKernelValueDynamicNumberTexture,
'MemoryOptimizedNumberTexture': WebGLKernelValueDynamicMemoryOptimizedNumberTexture,
'HTMLCanvas': WebGLKernelValueDynamicHTMLImage,
'OffscreenCanvas': WebGLKernelValueDynamicHTMLImage,
'HTMLImage': WebGLKernelValueDynamicHTMLImage,
'ImageBitmap': WebGLKernelValueDynamicHTMLImage,
'ImageData': WebGLKernelValueDynamicHTMLImage,
'HTMLImageArray': false,
'HTMLVideo': WebGLKernelValueDynamicHTMLVideo,
 },
 static: {
'Boolean': WebGLKernelValueBoolean,
'Float': WebGLKernelValueFloat,
'Integer': WebGLKernelValueInteger,
'Array': WebGLKernelValueUnsignedArray,
'Array(2)': WebGLKernelValueArray2,
'Array(3)': WebGLKernelValueArray3,
'Array(4)': WebGLKernelValueArray4,
'Array1D(2)': false,
'Array1D(3)': false,
'Array1D(4)': false,
'Array2D(2)': false,
'Array2D(3)': false,
'Array2D(4)': false,
'Array3D(2)': false,
'Array3D(3)': false,
'Array3D(4)': false,
'Input': WebGLKernelValueUnsignedInput,
'NumberTexture': WebGLKernelValueNumberTexture,
'ArrayTexture(1)': WebGLKernelValueNumberTexture,
'ArrayTexture(2)': WebGLKernelValueNumberTexture,
'ArrayTexture(3)': WebGLKernelValueNumberTexture,
'ArrayTexture(4)': WebGLKernelValueNumberTexture,
'MemoryOptimizedNumberTexture': WebGLKernelValueMemoryOptimizedNumberTexture,
'HTMLCanvas': WebGLKernelValueHTMLImage,
'OffscreenCanvas': WebGLKernelValueHTMLImage,
'HTMLImage': WebGLKernelValueHTMLImage,
'ImageBitmap': WebGLKernelValueHTMLImage,
'ImageData': WebGLKernelValueHTMLImage,
'HTMLImageArray': false,
'HTMLVideo': WebGLKernelValueHTMLVideo,
 }
 },
 single: {
 dynamic: {
'Boolean': WebGLKernelValueBoolean,
'Integer': WebGLKernelValueInteger,
'Float': WebGLKernelValueFloat,
'Array': WebGLKernelValueDynamicSingleArray,
'Array(2)': WebGLKernelValueArray2,
'Array(3)': WebGLKernelValueArray3,
'Array(4)': WebGLKernelValueArray4,
'Array1D(2)': WebGLKernelValueDynamicSingleArray1DI,
'Array1D(3)': WebGLKernelValueDynamicSingleArray1DI,
'Array1D(4)': WebGLKernelValueDynamicSingleArray1DI,
'Array2D(2)': WebGLKernelValueDynamicSingleArray2DI,
'Array2D(3)': WebGLKernelValueDynamicSingleArray2DI,
'Array2D(4)': WebGLKernelValueDynamicSingleArray2DI,
'Array3D(2)': WebGLKernelValueDynamicSingleArray3DI,
'Array3D(3)': WebGLKernelValueDynamicSingleArray3DI,
'Array3D(4)': WebGLKernelValueDynamicSingleArray3DI,
'Input': WebGLKernelValueDynamicSingleInput,
'NumberTexture': WebGLKernelValueDynamicNumberTexture,
'ArrayTexture(1)': WebGLKernelValueDynamicNumberTexture,
'ArrayTexture(2)': WebGLKernelValueDynamicNumberTexture,
'ArrayTexture(3)': WebGLKernelValueDynamicNumberTexture,
'ArrayTexture(4)': WebGLKernelValueDynamicNumberTexture,
'MemoryOptimizedNumberTexture': WebGLKernelValueDynamicMemoryOptimizedNumberTexture,
'HTMLCanvas': WebGLKernelValueDynamicHTMLImage,
'OffscreenCanvas': WebGLKernelValueDynamicHTMLImage,
'HTMLImage': WebGLKernelValueDynamicHTMLImage,
'ImageBitmap': WebGLKernelValueDynamicHTMLImage,
'ImageData': WebGLKernelValueDynamicHTMLImage,
'HTMLImageArray': false,
'HTMLVideo': WebGLKernelValueDynamicHTMLVideo,
 },
 static: {
'Boolean': WebGLKernelValueBoolean,
'Float': WebGLKernelValueFloat,
'Integer': WebGLKernelValueInteger,
'Array': WebGLKernelValueSingleArray,
'Array(2)': WebGLKernelValueArray2,
'Array(3)': WebGLKernelValueArray3,
'Array(4)': WebGLKernelValueArray4,
'Array1D(2)': WebGLKernelValueSingleArray1DI,
'Array1D(3)': WebGLKernelValueSingleArray1DI,
'Array1D(4)': WebGLKernelValueSingleArray1DI,
'Array2D(2)': WebGLKernelValueSingleArray2DI,
'Array2D(3)': WebGLKernelValueSingleArray2DI,
'Array2D(4)': WebGLKernelValueSingleArray2DI,
'Array3D(2)': WebGLKernelValueSingleArray3DI,
'Array3D(3)': WebGLKernelValueSingleArray3DI,
'Array3D(4)': WebGLKernelValueSingleArray3DI,
'Input': WebGLKernelValueSingleInput,
'NumberTexture': WebGLKernelValueNumberTexture,
'ArrayTexture(1)': WebGLKernelValueNumberTexture,
'ArrayTexture(2)': WebGLKernelValueNumberTexture,
'ArrayTexture(3)': WebGLKernelValueNumberTexture,
'ArrayTexture(4)': WebGLKernelValueNumberTexture,
'MemoryOptimizedNumberTexture': WebGLKernelValueMemoryOptimizedNumberTexture,
'HTMLCanvas': WebGLKernelValueHTMLImage,
'OffscreenCanvas': WebGLKernelValueHTMLImage,
'HTMLImage': WebGLKernelValueHTMLImage,
'ImageBitmap': WebGLKernelValueHTMLImage,
'ImageData': WebGLKernelValueHTMLImage,
'HTMLImageArray': false,
'HTMLVideo': WebGLKernelValueHTMLVideo,
 }
 },
 };

 function lookupKernelValueType(type,dynamic,precision,value) {
 if (!type) {
 throw new Error('type missing');
 }
 if (!dynamic) {
 throw new Error('dynamic missing');
 }
 if (!precision) {
 throw new Error('precision missing');
 }
 if (value.type) {
 type=value.type;
 }
 const types=kernelValueMaps[precision][dynamic];
 if (types[type] === false) {
 return null;
 } else if (types[type] === undefined) {
 throw new Error(`Could not find a KernelValue for ${ type }`);
 }
 return types[type];
 }

 module.exports={
 lookupKernelValueType,
 kernelValueMaps,
 };
 },{"./kernel-value/array2":41,"./kernel-value/array3":42,"./kernel-value/array4":43,"./kernel-value/boolean":44,"./kernel-value/dynamic-html-image":45,"./kernel-value/dynamic-html-video":46,"./kernel-value/dynamic-memory-optimized-number-texture":47,"./kernel-value/dynamic-number-texture":48,"./kernel-value/dynamic-single-array":49,"./kernel-value/dynamic-single-array1d-i":50,"./kernel-value/dynamic-single-array2d-i":51,"./kernel-value/dynamic-single-array3d-i":52,"./kernel-value/dynamic-single-input":53,"./kernel-value/dynamic-unsigned-array":54,"./kernel-value/dynamic-unsigned-input":55,"./kernel-value/float":56,"./kernel-value/html-image":57,"./kernel-value/html-video":58,"./kernel-value/integer":60,"./kernel-value/memory-optimized-number-texture":61,"./kernel-value/number-texture":62,"./kernel-value/single-array":63,"./kernel-value/single-array1d-i":64,"./kernel-value/single-array2d-i":65,"./kernel-value/single-array3d-i":66,"./kernel-value/single-input":67,"./kernel-value/unsigned-array":68,"./kernel-value/unsigned-input":69}],40:[function(require,module,exports){
 const { WebGLKernelValue }=require('./index');
 const { Input }=require('../../../input');

 class WebGLKernelArray extends WebGLKernelValue {
 checkSize(width,height) {
 if (!this.kernel.validate) return;
 const { maxTextureSize }=this.kernel.constructor.features;
 if (width > maxTextureSize || height > maxTextureSize) {
if (width > height) {
throw new Error(`Argument texture width of ${width} larger than maximum size of ${maxTextureSize} for your GPU`);
} else if (width < height) {
throw new Error(`Argument texture height of ${height} larger than maximum size of ${maxTextureSize} for your GPU`);
} else {
throw new Error(`Argument texture height and width of ${height} larger than maximum size of ${maxTextureSize} for your GPU`);
}
 }
 }

 setup() {
 this.requestTexture();
 this.setupTexture();
 this.defineTexture();
 }

 requestTexture() {
 this.texture=this.onRequestTexture();
 }

 defineTexture() {
 const { context: gl }=this;
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.CLAMP_TO_EDGE);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.NEAREST);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.NEAREST);
 }

 setupTexture() {
 this.contextHandle=this.onRequestContextHandle();
 this.index=this.onRequestIndex();
 this.dimensionsId=this.id + 'Dim';
 this.sizeId=this.id + 'Size';
 }

 getBitRatio(value) {
 if (Array.isArray(value[0])) {
return this.getBitRatio(value[0]);
 } else if (value.constructor === Input) {
return this.getBitRatio(value.value);
 }
 switch (value.constructor) {
case Uint8ClampedArray:
case Uint8Array:
case Int8Array:
return 1;
case Uint16Array:
case Int16Array:
return 2;
case Float32Array:
case Int32Array:
default:
return 4;
 }
 }

 destroy() {
 if (this.prevArg) {
this.prevArg.delete();
 }
 this.context.deleteTexture(this.texture);
 }
 }

 module.exports={
 WebGLKernelArray
 };
 },{"../../../input":110,"./index":59}],41:[function(require,module,exports){
 const { WebGLKernelValue }=require('./index');

 class WebGLKernelValueArray2 extends WebGLKernelValue {
 constructor(value,settings) {
 super(value,settings);
 this.uploadValue=value;
 }
 getSource(value) {
 if (this.origin === 'constants') {
return `const vec2 ${this.id}=vec2(${value[0]},${value[1]});\n`;
 }
 return `uniform vec2 ${this.id};\n`;
 }

 getStringValueHandler() {
 if (this.origin === 'constants') return '';
 return `const uploadValue_${this.name}=${this.varName};\n`;
 }

 updateValue(value) {
 if (this.origin === 'constants') return;
 this.kernel.setUniform2fv(this.id,this.uploadValue=value);
 }
 }

 module.exports={
 WebGLKernelValueArray2
 };
 },{"./index":59}],42:[function(require,module,exports){
 const { WebGLKernelValue }=require('./index');

 class WebGLKernelValueArray3 extends WebGLKernelValue {
 constructor(value,settings) {
 super(value,settings);
 this.uploadValue=value;
 }
 getSource(value) {
 if (this.origin === 'constants') {
return `const vec3 ${this.id}=vec3(${value[0]},${value[1]},${value[2]});\n`;
 }
 return `uniform vec3 ${this.id};\n`;
 }

 getStringValueHandler() {
 if (this.origin === 'constants') return '';
 return `const uploadValue_${this.name}=${this.varName};\n`;
 }

 updateValue(value) {
 if (this.origin === 'constants') return;
 this.kernel.setUniform3fv(this.id,this.uploadValue=value);
 }
 }

 module.exports={
 WebGLKernelValueArray3
 };
 },{"./index":59}],43:[function(require,module,exports){
 const { WebGLKernelValue }=require('./index');

 class WebGLKernelValueArray4 extends WebGLKernelValue {
 constructor(value,settings) {
 super(value,settings);
 this.uploadValue=value;
 }
 getSource(value) {
 if (this.origin === 'constants') {
return `const vec4 ${this.id}=vec4(${value[0]},${value[1]},${value[2]},${value[3]});\n`;
 }
 return `uniform vec4 ${this.id};\n`;
 }

 getStringValueHandler() {
 if (this.origin === 'constants') return '';
 return `const uploadValue_${this.name}=${this.varName};\n`;
 }

 updateValue(value) {
 if (this.origin === 'constants') return;
 this.kernel.setUniform4fv(this.id,this.uploadValue=value);
 }
 }

 module.exports={
 WebGLKernelValueArray4
 };
 },{"./index":59}],44:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValue }=require('./index');

 class WebGLKernelValueBoolean extends WebGLKernelValue {
 constructor(value,settings) {
 super(value,settings);
 this.uploadValue=value;
 }
 getSource(value) {
 if (this.origin === 'constants') {
return `const bool ${this.id}=${value};\n`;
 }
 return `uniform bool ${this.id};\n`;
 }

 getStringValueHandler() {
 return `const uploadValue_${this.name}=${this.varName};\n`;
 }

 updateValue(value) {
 if (this.origin === 'constants') return;
 this.kernel.setUniform1i(this.id,this.uploadValue=value);
 }
 }

 module.exports={
 WebGLKernelValueBoolean
 };
 },{"../../../utils":114,"./index":59}],45:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueHTMLImage }=require('./html-image');

 class WebGLKernelValueDynamicHTMLImage extends WebGLKernelValueHTMLImage {
 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`uniform ivec2 ${this.sizeId}`,
`uniform ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 const { width,height }=value;
 this.checkSize(width,height);
 this.dimensions=[width,height,1];
 this.textureSize=[width,height];
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGLKernelValueDynamicHTMLImage
 };
 },{"../../../utils":114,"./html-image":57}],46:[function(require,module,exports){
 const { WebGLKernelValueDynamicHTMLImage }=require('./dynamic-html-image');

 class WebGLKernelValueDynamicHTMLVideo extends WebGLKernelValueDynamicHTMLImage {}

 module.exports={
 WebGLKernelValueDynamicHTMLVideo
 };
 },{"./dynamic-html-image":45}],47:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueMemoryOptimizedNumberTexture }=require('./memory-optimized-number-texture');

 class WebGLKernelValueDynamicMemoryOptimizedNumberTexture extends WebGLKernelValueMemoryOptimizedNumberTexture {
 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`uniform ivec2 ${this.sizeId}`,
`uniform ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(inputTexture) {
 this.dimensions=inputTexture.dimensions;
 this.checkSize(inputTexture.size[0],inputTexture.size[1]);
 this.textureSize=inputTexture.size;
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(inputTexture);
 }
 }

 module.exports={
 WebGLKernelValueDynamicMemoryOptimizedNumberTexture
 };
 },{"../../../utils":114,"./memory-optimized-number-texture":61}],48:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueNumberTexture }=require('./number-texture');

 class WebGLKernelValueDynamicNumberTexture extends WebGLKernelValueNumberTexture {
 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`uniform ivec2 ${this.sizeId}`,
`uniform ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 this.dimensions=value.dimensions;
 this.checkSize(value.size[0],value.size[1]);
 this.textureSize=value.size;
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGLKernelValueDynamicNumberTexture
 };
 },{"../../../utils":114,"./number-texture":62}],49:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueSingleArray }=require('./single-array');

 class WebGLKernelValueDynamicSingleArray extends WebGLKernelValueSingleArray {
 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`uniform ivec2 ${this.sizeId}`,
`uniform ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 this.dimensions=utils.getDimensions(value,true);
 this.textureSize=utils.getMemoryOptimizedFloatTextureSize(this.dimensions,this.bitRatio);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * this.bitRatio;
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 this.uploadValue=new Float32Array(this.uploadArrayLength);
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGLKernelValueDynamicSingleArray
 };
 },{"../../../utils":114,"./single-array":63}],50:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueSingleArray1DI }=require('./single-array1d-i');

 class WebGLKernelValueDynamicSingleArray1DI extends WebGLKernelValueSingleArray1DI {
 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`uniform ivec2 ${this.sizeId}`,
`uniform ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 this.setShape(value);
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGLKernelValueDynamicSingleArray1DI
 };
 },{"../../../utils":114,"./single-array1d-i":64}],51:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueSingleArray2DI }=require('./single-array2d-i');

 class WebGLKernelValueDynamicSingleArray2DI extends WebGLKernelValueSingleArray2DI {
 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`uniform ivec2 ${this.sizeId}`,
`uniform ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 this.setShape(value);
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGLKernelValueDynamicSingleArray2DI
 };
 },{"../../../utils":114,"./single-array2d-i":65}],52:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueSingleArray3DI }=require('./single-array3d-i');

 class WebGLKernelValueDynamicSingleArray3DI extends WebGLKernelValueSingleArray3DI {
 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`uniform ivec2 ${this.sizeId}`,
`uniform ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 this.setShape(value);
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGLKernelValueDynamicSingleArray3DI
 };
 },{"../../../utils":114,"./single-array3d-i":66}],53:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueSingleInput }=require('./single-input');

 class WebGLKernelValueDynamicSingleInput extends WebGLKernelValueSingleInput {
 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`uniform ivec2 ${this.sizeId}`,
`uniform ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 let [w,h,d]=value.size;
 this.dimensions=new Int32Array([w || 1,h || 1,d || 1]);
 this.textureSize=utils.getMemoryOptimizedFloatTextureSize(this.dimensions,this.bitRatio);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * this.bitRatio;
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 this.uploadValue=new Float32Array(this.uploadArrayLength);
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGLKernelValueDynamicSingleInput
 };
 },{"../../../utils":114,"./single-input":67}],54:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueUnsignedArray }=require('./unsigned-array');

 class WebGLKernelValueDynamicUnsignedArray extends WebGLKernelValueUnsignedArray {
 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`uniform ivec2 ${this.sizeId}`,
`uniform ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 this.dimensions=utils.getDimensions(value,true);
 this.textureSize=utils.getMemoryOptimizedPackedTextureSize(this.dimensions,this.bitRatio);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * (4 / this.bitRatio);
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 const Type=this.getTransferArrayType(value);
 this.preUploadValue=new Type(this.uploadArrayLength);
 this.uploadValue=new Uint8Array(this.preUploadValue.buffer);
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGLKernelValueDynamicUnsignedArray
 };
 },{"../../../utils":114,"./unsigned-array":68}],55:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueUnsignedInput }=require('./unsigned-input');

 class WebGLKernelValueDynamicUnsignedInput extends WebGLKernelValueUnsignedInput {
 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`uniform ivec2 ${this.sizeId}`,
`uniform ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 let [w,h,d]=value.size;
 this.dimensions=new Int32Array([w || 1,h || 1,d || 1]);
 this.textureSize=utils.getMemoryOptimizedPackedTextureSize(this.dimensions,this.bitRatio);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * (4 / this.bitRatio);
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 const Type=this.getTransferArrayType(value.value);
 this.preUploadValue=new Type(this.uploadArrayLength);
 this.uploadValue=new Uint8Array(this.preUploadValue.buffer);
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGLKernelValueDynamicUnsignedInput
 };
 },{"../../../utils":114,"./unsigned-input":69}],56:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValue }=require('./index');

 class WebGLKernelValueFloat extends WebGLKernelValue {
 constructor(value,settings) {
 super(value,settings);
 this.uploadValue=value;
 }
 getStringValueHandler() {
 return `const uploadValue_${this.name}=${this.varName};\n`;
 }
 getSource(value) {
 if (this.origin === 'constants') {
if (Number.isInteger(value)) {
return `const float ${this.id}=${value}.0;\n`;
}
return `const float ${this.id}=${value};\n`;
 }
 return `uniform float ${this.id};\n`;
 }

 updateValue(value) {
 if (this.origin === 'constants') return;
 this.kernel.setUniform1f(this.id,this.uploadValue=value);
 }
 }

 module.exports={
 WebGLKernelValueFloat
 };
 },{"../../../utils":114,"./index":59}],57:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelArray }=require('./array');

 class WebGLKernelValueHTMLImage extends WebGLKernelArray {
 constructor(value,settings) {
 super(value,settings);
 const { width,height }=value;
 this.checkSize(width,height);
 this.dimensions=[width,height,1];
 this.textureSize=[width,height];
 this.uploadValue=value;
 }

 getStringValueHandler() {
 return `const uploadValue_${this.name}=${this.varName};\n`;
 }

 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(inputImage) {
 if (inputImage.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(inputImage.constructor);
return;
 }
 const { context: gl }=this;
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,true);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,gl.RGBA,gl.UNSIGNED_BYTE,this.uploadValue=inputImage);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGLKernelValueHTMLImage
 };
 },{"../../../utils":114,"./array":40}],58:[function(require,module,exports){
 const { WebGLKernelValueHTMLImage }=require('./html-image');

 class WebGLKernelValueHTMLVideo extends WebGLKernelValueHTMLImage {}

 module.exports={
 WebGLKernelValueHTMLVideo
 };
 },{"./html-image":57}],59:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { KernelValue }=require('../../kernel-value');

 class WebGLKernelValue extends KernelValue {
 constructor(value,settings) {
 super(value,settings);
 this.dimensionsId=null;
 this.sizeId=null;
 this.initialValueConstructor=value.constructor;
 this.onRequestTexture=settings.onRequestTexture;
 this.onRequestIndex=settings.onRequestIndex;
 this.uploadValue=null;
 this.textureSize=null;
 this.bitRatio=null;
 this.prevArg=null;
 }

 get id() {
 return `${this.origin}_${utils.sanitizeName(this.name)}`;
 }

 setup() {}

 getTransferArrayType(value) {
 if (Array.isArray(value[0])) {
return this.getTransferArrayType(value[0]);
 }
 switch (value.constructor) {
case Array:
case Int32Array:
case Int16Array:
case Int8Array:
return Float32Array;
case Uint8ClampedArray:
case Uint8Array:
case Uint16Array:
case Uint32Array:
case Float32Array:
case Float64Array:
return value.constructor;
 }
 console.warn('Unfamiliar constructor type. Will go ahead and use,but likley this may result in a transfer of zeros');
 return value.constructor;
 }

 getStringValueHandler() {
 throw new Error(`"getStringValueHandler" not implemented on ${this.constructor.name}`);
 }

 getVariablePrecisionString() {
 return this.kernel.getVariablePrecisionString(this.textureSize || undefined,this.tactic || undefined);
 }

 destroy() {}
 }

 module.exports={
 WebGLKernelValue
 };
 },{"../../../utils":114,"../../kernel-value":35}],60:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValue }=require('./index');

 class WebGLKernelValueInteger extends WebGLKernelValue {
 constructor(value,settings) {
 super(value,settings);
 this.uploadValue=value;
 }
 getStringValueHandler() {
 return `const uploadValue_${this.name}=${this.varName};\n`;
 }
 getSource(value) {
 if (this.origin === 'constants') {
return `const int ${this.id}=${ parseInt(value) };\n`;
 }
 return `uniform int ${this.id};\n`;
 }

 updateValue(value) {
 if (this.origin === 'constants') return;
 this.kernel.setUniform1i(this.id,this.uploadValue=value);
 }
 }

 module.exports={
 WebGLKernelValueInteger
 };
 },{"../../../utils":114,"./index":59}],61:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelArray }=require('./array');

 const sameError=`Source and destination textures are the same. Use immutable=true and manually cleanup kernel output texture memory with texture.delete()`;

 class WebGLKernelValueMemoryOptimizedNumberTexture extends WebGLKernelArray {
 constructor(value,settings) {
 super(value,settings);
 const [width,height]=value.size;
 this.checkSize(width,height);
 this.dimensions=value.dimensions;
 this.textureSize=value.size;
 this.uploadValue=value.texture;
 this.forceUploadEachRun=true;
 }

 setup() {
 this.setupTexture();
 }

 getStringValueHandler() {
 return `const uploadValue_${this.name}=${this.varName}.texture;\n`;
 }

 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(inputTexture) {
 if (inputTexture.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(inputTexture.constructor);
return;
 }
 if (this.checkContext && inputTexture.context !== this.context) {
throw new Error(`Value ${this.name} (${this.type}) must be from same context`);
 }

 const { kernel,context: gl }=this;
 if (kernel.pipeline) {
if (kernel.immutable) {
kernel.updateTextureArgumentRefs(this,inputTexture);
} else {
if (kernel.texture && kernel.texture.texture === inputTexture.texture) {
throw new Error(sameError);
} else if (kernel.mappedTextures) {
const { mappedTextures }=kernel;
for (let i=0; i < mappedTextures.length; i++) {
if (mappedTextures[i].texture === inputTexture.texture) {
 throw new Error(sameError);
}
}
}
}
 }

 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.uploadValue=inputTexture.texture);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGLKernelValueMemoryOptimizedNumberTexture,
 sameError
 };
 },{"../../../utils":114,"./array":40}],62:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelArray }=require('./array');
 const { sameError }=require('./memory-optimized-number-texture');

 class WebGLKernelValueNumberTexture extends WebGLKernelArray {
 constructor(value,settings) {
 super(value,settings);
 const [width,height]=value.size;
 this.checkSize(width,height);
 const { size: textureSize,dimensions }=value;
 this.bitRatio=this.getBitRatio(value);
 this.dimensions=dimensions;
 this.textureSize=textureSize;
 this.uploadValue=value.texture;
 this.forceUploadEachRun=true;
 }

 setup() {
 this.setupTexture();
 }

 getStringValueHandler() {
 return `const uploadValue_${this.name}=${this.varName}.texture;\n`;
 }

 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(inputTexture) {
 if (inputTexture.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(inputTexture.constructor);
return;
 }
 if (this.checkContext && inputTexture.context !== this.context) {
throw new Error(`Value ${this.name} (${this.type}) must be from same context`);
 }

 const { kernel,context: gl }=this;
 if (kernel.pipeline) {
if (kernel.immutable) {
kernel.updateTextureArgumentRefs(this,inputTexture);
} else {
if (kernel.texture && kernel.texture.texture === inputTexture.texture) {
throw new Error(sameError);
} else if (kernel.mappedTextures) {
const { mappedTextures }=kernel;
for (let i=0; i < mappedTextures.length; i++) {
if (mappedTextures[i].texture === inputTexture.texture) {
 throw new Error(sameError);
}
}
}
}
 }

 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.uploadValue=inputTexture.texture);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGLKernelValueNumberTexture
 };
 },{"../../../utils":114,"./array":40,"./memory-optimized-number-texture":61}],63:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelArray }=require('./array');

 class WebGLKernelValueSingleArray extends WebGLKernelArray {
 constructor(value,settings) {
 super(value,settings);
 this.bitRatio=4;
 this.dimensions=utils.getDimensions(value,true);
 this.textureSize=utils.getMemoryOptimizedFloatTextureSize(this.dimensions,this.bitRatio);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * this.bitRatio;
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 this.uploadValue=new Float32Array(this.uploadArrayLength);
 }

 getStringValueHandler() {
 return utils.linesToString([
`const uploadValue_${this.name}=new Float32Array(${this.uploadArrayLength})`,
`flattenTo(${this.varName},uploadValue_${this.name})`,
 ]);
 }

 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(value) {
 if (value.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(value.constructor);
return;
 }
 const { context: gl }=this;
 utils.flattenTo(value,this.uploadValue);
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,this.textureSize[0],this.textureSize[1],0,gl.RGBA,gl.FLOAT,this.uploadValue);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGLKernelValueSingleArray
 };
 },{"../../../utils":114,"./array":40}],64:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelArray }=require('./array');

 class WebGLKernelValueSingleArray1DI extends WebGLKernelArray {
 constructor(value,settings) {
 super(value,settings);
 this.bitRatio=4;
 this.setShape(value);
 }

 setShape(value) {
 const valueDimensions=utils.getDimensions(value,true);
 this.textureSize=utils.getMemoryOptimizedFloatTextureSize(valueDimensions,this.bitRatio);
 this.dimensions=new Int32Array([valueDimensions[1],1,1]);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * this.bitRatio;
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 this.uploadValue=new Float32Array(this.uploadArrayLength);
 }

 getStringValueHandler() {
 return utils.linesToString([
`const uploadValue_${this.name}=new Float32Array(${this.uploadArrayLength})`,
`flattenTo(${this.varName},uploadValue_${this.name})`,
 ]);
 }

 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(value) {
 if (value.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(value.constructor);
return;
 }
 const { context: gl }=this;
 utils.flatten2dArrayTo(value,this.uploadValue);
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,this.textureSize[0],this.textureSize[1],0,gl.RGBA,gl.FLOAT,this.uploadValue);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGLKernelValueSingleArray1DI
 };
 },{"../../../utils":114,"./array":40}],65:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelArray }=require('./array');

 class WebGLKernelValueSingleArray2DI extends WebGLKernelArray {
 constructor(value,settings) {
 super(value,settings);
 this.bitRatio=4;
 this.setShape(value);
 }

 setShape(value) {
 const valueDimensions=utils.getDimensions(value,true);
 this.textureSize=utils.getMemoryOptimizedFloatTextureSize(valueDimensions,this.bitRatio);
 this.dimensions=new Int32Array([valueDimensions[1],valueDimensions[2],1]);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * this.bitRatio;
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 this.uploadValue=new Float32Array(this.uploadArrayLength);
 }

 getStringValueHandler() {
 return utils.linesToString([
`const uploadValue_${this.name}=new Float32Array(${this.uploadArrayLength})`,
`flattenTo(${this.varName},uploadValue_${this.name})`,
 ]);
 }

 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(value) {
 if (value.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(value.constructor);
return;
 }
 const { context: gl }=this;
 utils.flatten3dArrayTo(value,this.uploadValue);
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,this.textureSize[0],this.textureSize[1],0,gl.RGBA,gl.FLOAT,this.uploadValue);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGLKernelValueSingleArray2DI
 };
 },{"../../../utils":114,"./array":40}],66:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelArray }=require('./array');

 class WebGLKernelValueSingleArray3DI extends WebGLKernelArray {
 constructor(value,settings) {
 super(value,settings);
 this.bitRatio=4;
 this.setShape(value);
 }

 setShape(value) {
 const valueDimensions=utils.getDimensions(value,true);
 this.textureSize=utils.getMemoryOptimizedFloatTextureSize(valueDimensions,this.bitRatio);
 this.dimensions=new Int32Array([valueDimensions[1],valueDimensions[2],valueDimensions[3]]);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * this.bitRatio;
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 this.uploadValue=new Float32Array(this.uploadArrayLength);
 }

 getStringValueHandler() {
 return utils.linesToString([
`const uploadValue_${this.name}=new Float32Array(${this.uploadArrayLength})`,
`flattenTo(${this.varName},uploadValue_${this.name})`,
 ]);
 }

 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(value) {
 if (value.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(value.constructor);
return;
 }
 const { context: gl }=this;
 utils.flatten4dArrayTo(value,this.uploadValue);
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,this.textureSize[0],this.textureSize[1],0,gl.RGBA,gl.FLOAT,this.uploadValue);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGLKernelValueSingleArray3DI
 };
 },{"../../../utils":114,"./array":40}],67:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelArray }=require('./array');

 class WebGLKernelValueSingleInput extends WebGLKernelArray {
 constructor(value,settings) {
 super(value,settings);
 this.bitRatio=4;
 let [w,h,d]=value.size;
 this.dimensions=new Int32Array([w || 1,h || 1,d || 1]);
 this.textureSize=utils.getMemoryOptimizedFloatTextureSize(this.dimensions,this.bitRatio);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * this.bitRatio;
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 this.uploadValue=new Float32Array(this.uploadArrayLength);
 }

 getStringValueHandler() {
 return utils.linesToString([
`const uploadValue_${this.name}=new Float32Array(${this.uploadArrayLength})`,
`flattenTo(${this.varName}.value,uploadValue_${this.name})`,
 ]);
 }

 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(input) {
 if (input.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(input.constructor);
return;
 }
 const { context: gl }=this;
 utils.flattenTo(input.value,this.uploadValue);
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,this.textureSize[0],this.textureSize[1],0,gl.RGBA,gl.FLOAT,this.uploadValue);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGLKernelValueSingleInput
 };
 },{"../../../utils":114,"./array":40}],68:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelArray }=require('./array');

 class WebGLKernelValueUnsignedArray extends WebGLKernelArray {
 constructor(value,settings) {
 super(value,settings);
 this.bitRatio=this.getBitRatio(value);
 this.dimensions=utils.getDimensions(value,true);
 this.textureSize=utils.getMemoryOptimizedPackedTextureSize(this.dimensions,this.bitRatio);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * (4 / this.bitRatio);
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 this.TranserArrayType=this.getTransferArrayType(value);
 this.preUploadValue=new this.TranserArrayType(this.uploadArrayLength);
 this.uploadValue=new Uint8Array(this.preUploadValue.buffer);
 }

 getStringValueHandler() {
 return utils.linesToString([
`const preUploadValue_${this.name}=new ${this.TranserArrayType.name}(${this.uploadArrayLength})`,
`const uploadValue_${this.name}=new Uint8Array(preUploadValue_${this.name}.buffer)`,
`flattenTo(${this.varName},preUploadValue_${this.name})`,
 ]);
 }

 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(value) {
 if (value.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(value.constructor);
return;
 }
 const { context: gl }=this;
 utils.flattenTo(value,this.preUploadValue);
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,this.textureSize[0],this.textureSize[1],0,gl.RGBA,gl.UNSIGNED_BYTE,this.uploadValue);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGLKernelValueUnsignedArray
 };
 },{"../../../utils":114,"./array":40}],69:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelArray }=require('./array');

 class WebGLKernelValueUnsignedInput extends WebGLKernelArray {
 constructor(value,settings) {
 super(value,settings);
 this.bitRatio=this.getBitRatio(value);
 const [w,h,d]=value.size;
 this.dimensions=new Int32Array([w || 1,h || 1,d || 1]);
 this.textureSize=utils.getMemoryOptimizedPackedTextureSize(this.dimensions,this.bitRatio);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * (4 / this.bitRatio);
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 this.TranserArrayType=this.getTransferArrayType(value.value);
 this.preUploadValue=new this.TranserArrayType(this.uploadArrayLength);
 this.uploadValue=new Uint8Array(this.preUploadValue.buffer);
 }

 getStringValueHandler() {
 return utils.linesToString([
`const preUploadValue_${this.name}=new ${this.TranserArrayType.name}(${this.uploadArrayLength})`,
`const uploadValue_${this.name}=new Uint8Array(preUploadValue_${this.name}.buffer)`,
`flattenTo(${this.varName}.value,preUploadValue_${this.name})`,
 ]);
 }

 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(input) {
 if (input.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(value.constructor);
return;
 }
 const { context: gl }=this;
 utils.flattenTo(input.value,this.preUploadValue);
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,this.textureSize[0],this.textureSize[1],0,gl.RGBA,gl.UNSIGNED_BYTE,this.uploadValue);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGLKernelValueUnsignedInput
 };
 },{"../../../utils":114,"./array":40}],70:[function(require,module,exports){
 const { GLKernel }=require('../gl/kernel');
 const { FunctionBuilder }=require('../function-builder');
 const { WebGLFunctionNode }=require('./function-node');
 const { utils }=require('../../utils');
 const mrud=require('../../plugins/math-random-uniformly-distributed');
 const { fragmentShader }=require('./fragment-shader');
 const { vertexShader }=require('./vertex-shader');
 const { glKernelString }=require('../gl/kernel-string');
 const { lookupKernelValueType }=require('./kernel-value-maps');

 let isSupported=null;
 let testCanvas=null;
 let testContext=null;
 let testExtensions=null;
 let features=null;

 const plugins=[mrud];
 const canvases=[];
 const maxTexSizes={};


 class WebGLKernel extends GLKernel {
 static get isSupported() {
 if (isSupported !== null) {
return isSupported;
 }
 this.setupFeatureChecks();
 isSupported=this.isContextMatch(testContext);
 return isSupported;
 }

 static setupFeatureChecks() {
 if (typeof document !== 'undefined') {
testCanvas=document.createElement('canvas');
 } else if (typeof OffscreenCanvas !== 'undefined') {
testCanvas=new OffscreenCanvas(0,0);
 }
 if (!testCanvas) return;
 testContext=testCanvas.getContext('webgl') || testCanvas.getContext('experimental-webgl');
 if (!testContext || !testContext.getExtension) return;
 testExtensions={
OES_texture_float: testContext.getExtension('OES_texture_float'),
OES_texture_float_linear: testContext.getExtension('OES_texture_float_linear'),
OES_element_index_uint: testContext.getExtension('OES_element_index_uint'),
WEBGL_draw_buffers: testContext.getExtension('WEBGL_draw_buffers'),
 };
 features=this.getFeatures();
 }

 static isContextMatch(context) {
 if (typeof WebGLRenderingContext !== 'undefined') {
return context instanceof WebGLRenderingContext;
 }
 return false;
 }

 static getIsTextureFloat() {
 return Boolean(testExtensions.OES_texture_float);
 }

 static getIsDrawBuffers() {
 return Boolean(testExtensions.WEBGL_draw_buffers);
 }

 static getChannelCount() {
 return testExtensions.WEBGL_draw_buffers ?
testContext.getParameter(testExtensions.WEBGL_draw_buffers.MAX_DRAW_BUFFERS_WEBGL) :
1;
 }

 static getMaxTextureSize() {
 return testContext.getParameter(testContext.MAX_TEXTURE_SIZE);
 }

 static lookupKernelValueType(type,dynamic,precision,value) {
 return lookupKernelValueType(type,dynamic,precision,value);
 }

 static get testCanvas() {
 return testCanvas;
 }

 static get testContext() {
 return testContext;
 }

 static get features() {
 return features;
 }

 static get fragmentShader() {
 return fragmentShader;
 }

 static get vertexShader() {
 return vertexShader;
 }

 constructor(source,settings) {
 super(source,settings);
 this.program=null;
 this.pipeline=settings.pipeline;
 this.endianness=utils.systemEndianness();
 this.extensions={};
 this.argumentTextureCount=0;
 this.constantTextureCount=0;
 this.fragShader=null;
 this.vertShader=null;
 this.drawBuffersMap=null;

 this.maxTexSize=null;
 this.onRequestSwitchKernel=null;

 this.texture=null;
 this.mappedTextures=null;
 this.mergeSettings(source.settings || settings);

 this.threadDim=null;
 this.framebuffer=null;
 this.buffer=null;

 this.textureCache=[];
 this.programUniformLocationCache={};
 this.uniform1fCache={};
 this.uniform1iCache={};
 this.uniform2fCache={};
 this.uniform2fvCache={};
 this.uniform2ivCache={};
 this.uniform3fvCache={};
 this.uniform3ivCache={};
 this.uniform4fvCache={};
 this.uniform4ivCache={};
 }

 initCanvas() {
 if (typeof document !== 'undefined') {
const canvas=document.createElement('canvas');
canvas.width=2;
canvas.height=2;
return canvas;
 } else if (typeof OffscreenCanvas !== 'undefined') {
return new OffscreenCanvas(0,0);
 }
 }

 initContext() {
 const settings={
depth: false,
alpha: true,
antialias: false
 };
 return this.canvas.getContext('webgl',settings) || this.canvas.getContext('experimental-webgl',settings);
 }

 initPlugins(settings) {
 const pluginsToUse=[];
 const { source }=this;
 if (typeof source === 'string') {
for (let i=0; i < plugins.length; i++) {
const plugin=plugins[i];
if (source.match(plugin.functionMatch)) {
pluginsToUse.push(plugin);
}
}
 } else if (typeof source === 'object') {
if (settings.pluginNames) {
for (let i=0; i < plugins.length; i++) {
const plugin=plugins[i];
const usePlugin=settings.pluginNames.some(pluginName => pluginName === plugin.name);
if (usePlugin) {
pluginsToUse.push(plugin);
}
}
}
 }
 return pluginsToUse;
 }

 initExtensions() {
 this.extensions={
OES_texture_float: this.context.getExtension('OES_texture_float'),
OES_texture_float_linear: this.context.getExtension('OES_texture_float_linear'),
OES_element_index_uint: this.context.getExtension('OES_element_index_uint'),
WEBGL_draw_buffers: this.context.getExtension('WEBGL_draw_buffers'),
WEBGL_color_buffer_float: this.context.getExtension('WEBGL_color_buffer_float'),
 };
 }

 validateSettings(args) {
 if (!this.validate) {
this.texSize=utils.getKernelTextureSize({
optimizeFloatMemory: this.optimizeFloatMemory,
precision: this.precision,
},this.output);
return;
 }

 const { features }=this.constructor;

 if (this.optimizeFloatMemory === true && !features.isTextureFloat) {
throw new Error('Float textures are not supported');
 } else if (this.precision === 'single' && !features.isFloatRead) {
throw new Error('Single precision not supported');
 } else if (!this.graphical && this.precision === null && features.isTextureFloat) {
this.precision=features.isFloatRead ? 'single' : 'unsigned';
 }

 if (this.subKernels && this.subKernels.length > 0 && !this.extensions.WEBGL_draw_buffers) {
throw new Error('could not instantiate draw buffers extension');
 }

 if (this.fixIntegerDivisionAccuracy === null) {
this.fixIntegerDivisionAccuracy=!features.isIntegerDivisionAccurate;
 } else if (this.fixIntegerDivisionAccuracy && features.isIntegerDivisionAccurate) {
this.fixIntegerDivisionAccuracy=false;
 }

 this.checkOutput();

 if (!this.output || this.output.length === 0) {
if (args.length !== 1) {
throw new Error('Auto output only supported for kernels with only one input');
}

const argType=utils.getVariableType(args[0],this.strictIntegers);
switch (argType) {
case 'Array':
this.output=utils.getDimensions(argType);
break;
case 'NumberTexture':
case 'MemoryOptimizedNumberTexture':
case 'ArrayTexture(1)':
case 'ArrayTexture(2)':
case 'ArrayTexture(3)':
case 'ArrayTexture(4)':
this.output=args[0].output;
break;
default:
throw new Error('Auto output not supported for input type: ' + argType);
}
 }

 if (this.graphical) {
if (this.output.length !== 2) {
throw new Error('Output must have 2 dimensions on graphical mode');
}

if (this.precision === 'precision') {
this.precision='unsigned';
console.warn('Cannot use graphical mode and single precision at the same time');
}

this.texSize=utils.clone(this.output);
return;
 } else if (this.precision === null && features.isTextureFloat) {
this.precision='single';
 }

 this.texSize=utils.getKernelTextureSize({
optimizeFloatMemory: this.optimizeFloatMemory,
precision: this.precision,
 },this.output);

 this.checkTextureSize();
 }

 updateMaxTexSize() {
 const { texSize,canvas }=this;
 if (this.maxTexSize === null) {
let canvasIndex=canvases.indexOf(canvas);
if (canvasIndex === -1) {
canvasIndex=canvases.length;
canvases.push(canvas);
maxTexSizes[canvasIndex]=[texSize[0],texSize[1]];
}
this.maxTexSize=maxTexSizes[canvasIndex];
 }
 if (this.maxTexSize[0] < texSize[0]) {
this.maxTexSize[0]=texSize[0];
 }
 if (this.maxTexSize[1] < texSize[1]) {
this.maxTexSize[1]=texSize[1];
 }
 }

 setupArguments(args) {
 this.kernelArguments=[];
 this.argumentTextureCount=0;
 const needsArgumentTypes=this.argumentTypes === null;
 if (needsArgumentTypes) {
this.argumentTypes=[];
 }
 this.argumentSizes=[];
 this.argumentBitRatios=[];

 if (args.length < this.argumentNames.length) {
throw new Error('not enough arguments for kernel');
 } else if (args.length > this.argumentNames.length) {
throw new Error('too many arguments for kernel');
 }

 const { context: gl }=this;
 let textureIndexes=0;

 const onRequestTexture=() => {
return this.createTexture();
 };
 const onRequestIndex=() => {
return this.constantTextureCount + textureIndexes++;
 };
 const onUpdateValueMismatch=(constructor) => {
this.switchKernels({
type: 'argumentMismatch',
needed: constructor
});
 };
 const onRequestContextHandle=() => {
return gl.TEXTURE0 + this.constantTextureCount + this.argumentTextureCount++;
 };

 for (let index=0; index < args.length; index++) {
const value=args[index];
const name=this.argumentNames[index];
let type;
if (needsArgumentTypes) {
type=utils.getVariableType(value,this.strictIntegers);
this.argumentTypes.push(type);
} else {
type=this.argumentTypes[index];
}
const KernelValue=this.constructor.lookupKernelValueType(type,this.dynamicArguments ? 'dynamic' : 'static',this.precision,args[index]);
if (KernelValue === null) {
return this.requestFallback(args);
}
const kernelArgument=new KernelValue(value,{
name,
type,
tactic: this.tactic,
origin: 'user',
context: gl,
checkContext: this.checkContext,
kernel: this,
strictIntegers: this.strictIntegers,
onRequestTexture,
onRequestIndex,
onUpdateValueMismatch,
onRequestContextHandle,
});
this.kernelArguments.push(kernelArgument);
kernelArgument.setup();
this.argumentSizes.push(kernelArgument.textureSize);
this.argumentBitRatios[index]=kernelArgument.bitRatio;
 }
 }

 createTexture() {
 const texture=this.context.createTexture();
 this.textureCache.push(texture);
 return texture;
 }

 setupConstants(args) {
 const { context: gl }=this;
 this.kernelConstants=[];
 this.forceUploadKernelConstants=[];
 let needsConstantTypes=this.constantTypes === null;
 if (needsConstantTypes) {
this.constantTypes={};
 }
 this.constantBitRatios={};
 let textureIndexes=0;
 for (const name in this.constants) {
const value=this.constants[name];
let type;
if (needsConstantTypes) {
type=utils.getVariableType(value,this.strictIntegers);
this.constantTypes[name]=type;
} else {
type=this.constantTypes[name];
}
const KernelValue=this.constructor.lookupKernelValueType(type,'static',this.precision,value);
if (KernelValue === null) {
return this.requestFallback(args);
}
const kernelValue=new KernelValue(value,{
name,
type,
tactic: this.tactic,
origin: 'constants',
context: this.context,
checkContext: this.checkContext,
kernel: this,
strictIntegers: this.strictIntegers,
onRequestTexture: () => {
return this.createTexture();
},
onRequestIndex: () => {
return textureIndexes++;
},
onRequestContextHandle: () => {
return gl.TEXTURE0 + this.constantTextureCount++;
}
});
this.constantBitRatios[name]=kernelValue.bitRatio;
this.kernelConstants.push(kernelValue);
kernelValue.setup();
if (kernelValue.forceUploadEachRun) {
this.forceUploadKernelConstants.push(kernelValue);
}
 }
 }

 build() {
 if (this.built) return;
 this.initExtensions();
 this.validateSettings(arguments);
 this.setupConstants(arguments);
 if (this.fallbackRequested) return;
 this.setupArguments(arguments);
 if (this.fallbackRequested) return;
 this.updateMaxTexSize();
 this.translateSource();
 const failureResult=this.pickRenderStrategy(arguments);
 if (failureResult) {
return failureResult;
 }
 const { texSize,context: gl,canvas }=this;
 gl.enable(gl.SCISSOR_TEST);
 if (this.pipeline && this.precision === 'single') {
gl.viewport(0,0,this.maxTexSize[0],this.maxTexSize[1]);
canvas.width=this.maxTexSize[0];
canvas.height=this.maxTexSize[1];
 } else {
gl.viewport(0,0,this.maxTexSize[0],this.maxTexSize[1]);
canvas.width=this.maxTexSize[0];
canvas.height=this.maxTexSize[1];
 }
 const threadDim=this.threadDim=Array.from(this.output);
 while (threadDim.length < 3) {
threadDim.push(1);
 }

 const compiledVertexShader=this.getVertexShader(arguments);
 const vertShader=gl.createShader(gl.VERTEX_SHADER);
 gl.shaderSource(vertShader,compiledVertexShader);
 gl.compileShader(vertShader);
 this.vertShader=vertShader;

 const compiledFragmentShader=this.getFragmentShader(arguments);
 const fragShader=gl.createShader(gl.FRAGMENT_SHADER);
 gl.shaderSource(fragShader,compiledFragmentShader);
 gl.compileShader(fragShader);
 this.fragShader=fragShader;

 if (this.debug) {
console.log('GLSL Shader Output:');
console.log(compiledFragmentShader);
 }

 if (!gl.getShaderParameter(vertShader,gl.COMPILE_STATUS)) {
throw new Error('Error compiling vertex shader: ' + gl.getShaderInfoLog(vertShader));
 }
 if (!gl.getShaderParameter(fragShader,gl.COMPILE_STATUS)) {
throw new Error('Error compiling fragment shader: ' + gl.getShaderInfoLog(fragShader));
 }

 const program=this.program=gl.createProgram();
 gl.attachShader(program,vertShader);
 gl.attachShader(program,fragShader);
 gl.linkProgram(program);
 this.framebuffer=gl.createFramebuffer();
 this.framebuffer.width=texSize[0];
 this.framebuffer.height=texSize[1];
 this.rawValueFramebuffers={};

 const vertices=new Float32Array([-1,-1,
1,-1,-1,1,
1,1
 ]);
 const texCoords=new Float32Array([
0,0,
1,0,
0,1,
1,1
 ]);

 const texCoordOffset=vertices.byteLength;

 let buffer=this.buffer;
 if (!buffer) {
buffer=this.buffer=gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER,buffer);
gl.bufferData(gl.ARRAY_BUFFER,vertices.byteLength + texCoords.byteLength,gl.STATIC_DRAW);
 } else {
gl.bindBuffer(gl.ARRAY_BUFFER,buffer);
 }

 gl.bufferSubData(gl.ARRAY_BUFFER,0,vertices);
 gl.bufferSubData(gl.ARRAY_BUFFER,texCoordOffset,texCoords);

 const aPosLoc=gl.getAttribLocation(this.program,'aPos');
 gl.enableVertexAttribArray(aPosLoc);
 gl.vertexAttribPointer(aPosLoc,2,gl.FLOAT,false,0,0);
 const aTexCoordLoc=gl.getAttribLocation(this.program,'aTexCoord');
 gl.enableVertexAttribArray(aTexCoordLoc);
 gl.vertexAttribPointer(aTexCoordLoc,2,gl.FLOAT,false,0,texCoordOffset);
 gl.bindFramebuffer(gl.FRAMEBUFFER,this.framebuffer);

 let i=0;
 gl.useProgram(this.program);
 for (let p in this.constants) {
this.kernelConstants[i++].updateValue(this.constants[p]);
 }

 this._setupOutputTexture();
 if (
this.subKernels !== null &&
this.subKernels.length > 0
 ) {
this._mappedTextureSwitched={};
this._setupSubOutputTextures();
 }
 this.buildSignature(arguments);
 this.built=true;
 }

 translateSource() {
 const functionBuilder=FunctionBuilder.fromKernel(this,WebGLFunctionNode,{
fixIntegerDivisionAccuracy: this.fixIntegerDivisionAccuracy
 });
 this.translatedSource=functionBuilder.getPrototypeString('kernel');
 this.setupReturnTypes(functionBuilder);
 }

 setupReturnTypes(functionBuilder) {
 if (!this.graphical && !this.returnType) {
this.returnType=functionBuilder.getKernelResultType();
 }

 if (this.subKernels && this.subKernels.length > 0) {
for (let i=0; i < this.subKernels.length; i++) {
const subKernel=this.subKernels[i];
if (!subKernel.returnType) {
subKernel.returnType=functionBuilder.getSubKernelResultType(i);
}
}
 }
 }

 run() {
 const { kernelArguments,texSize,forceUploadKernelConstants,context: gl }=this;

 gl.useProgram(this.program);
 gl.scissor(0,0,texSize[0],texSize[1]);
 if (this.dynamicOutput) {
this.setUniform3iv('uOutputDim',new Int32Array(this.threadDim));
this.setUniform2iv('uTexSize',texSize);
 }

 this.setUniform2f('ratio',texSize[0] / this.maxTexSize[0],texSize[1] / this.maxTexSize[1]);

 for (let i=0; i < forceUploadKernelConstants.length; i++) {
const constant=forceUploadKernelConstants[i];
constant.updateValue(this.constants[constant.name]);
if (this.switchingKernels) return;
 }
 for (let i=0; i < kernelArguments.length; i++) {
kernelArguments[i].updateValue(arguments[i]);
if (this.switchingKernels) return;
 }

 if (this.plugins) {
for (let i=0; i < this.plugins.length; i++) {
const plugin=this.plugins[i];
if (plugin.onBeforeRun) {
plugin.onBeforeRun(this);
}
}
 }

 if (this.graphical) {
if (this.pipeline) {
gl.bindRenderbuffer(gl.RENDERBUFFER,null);
gl.bindFramebuffer(gl.FRAMEBUFFER,this.framebuffer);
if (this.immutable) {
this._replaceOutputTexture();
}
gl.drawArrays(gl.TRIANGLE_STRIP,0,4);
return this.immutable ? this.texture.clone() : this.texture;
}
gl.bindRenderbuffer(gl.RENDERBUFFER,null);
gl.bindFramebuffer(gl.FRAMEBUFFER,null);
gl.drawArrays(gl.TRIANGLE_STRIP,0,4);
return;
 }

 gl.bindFramebuffer(gl.FRAMEBUFFER,this.framebuffer);
 if (this.immutable) {
this._replaceOutputTexture();
 }

 if (this.subKernels !== null) {
if (this.immutable) {
this._replaceSubOutputTextures();
}
this.drawBuffers();
 }

 gl.drawArrays(gl.TRIANGLE_STRIP,0,4);
 }

 drawBuffers() {
 this.extensions.WEBGL_draw_buffers.drawBuffersWEBGL(this.drawBuffersMap);
 }

 getInternalFormat() {
 return this.context.RGBA;
 }
 getTextureFormat() {
 const { context: gl }=this;
 switch (this.getInternalFormat()) {
case gl.RGBA:
return gl.RGBA;
default:
throw new Error('Unknown internal format');
 }
 }

 _replaceOutputTexture() {
 if (this.texture.beforeMutate() || this._textureSwitched) {
const gl=this.context;
gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,this.texture.texture,0);
this._textureSwitched=false;
 }
 }

 _setupOutputTexture() {
 const gl=this.context;
 const texSize=this.texSize;
 if (this.texture) {
gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,this.texture.texture,0);
return;
 }
 const texture=this.createTexture();
 gl.activeTexture(gl.TEXTURE0 + this.constantTextureCount + this.argumentTextureCount);
 gl.bindTexture(gl.TEXTURE_2D,texture);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.CLAMP_TO_EDGE);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.NEAREST);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.NEAREST);
 const format=this.getInternalFormat();
 if (this.precision === 'single') {
gl.texImage2D(gl.TEXTURE_2D,0,format,texSize[0],texSize[1],0,gl.RGBA,gl.FLOAT,null);
 } else {
gl.texImage2D(gl.TEXTURE_2D,0,format,texSize[0],texSize[1],0,format,gl.UNSIGNED_BYTE,null);
 }
 gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,texture,0);
 this.texture=new this.TextureConstructor({
texture,
size: texSize,
dimensions: this.threadDim,
output: this.output,
context: this.context,
internalFormat: this.getInternalFormat(),
textureFormat: this.getTextureFormat(),
kernel: this,
 });
 }

 _replaceSubOutputTextures() {
 const gl=this.context;
 for (let i=0; i < this.mappedTextures.length; i++) {
const mappedTexture=this.mappedTextures[i];
if (mappedTexture.beforeMutate() || this._mappedTextureSwitched[i]) {
gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0 + i + 1,gl.TEXTURE_2D,mappedTexture.texture,0);
this._mappedTextureSwitched[i]=false;
}
 }
 }

 _setupSubOutputTextures() {
 const gl=this.context;
 if (this.mappedTextures) {
for (let i=0; i < this.subKernels.length; i++) {
gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0 + i + 1,gl.TEXTURE_2D,this.mappedTextures[i].texture,0);
}
return;
 }
 const texSize=this.texSize;
 this.drawBuffersMap=[gl.COLOR_ATTACHMENT0];
 this.mappedTextures=[];
 for (let i=0; i < this.subKernels.length; i++) {
const texture=this.createTexture();
this.drawBuffersMap.push(gl.COLOR_ATTACHMENT0 + i + 1);
gl.activeTexture(gl.TEXTURE0 + this.constantTextureCount + this.argumentTextureCount + i);
gl.bindTexture(gl.TEXTURE_2D,texture);
gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.NEAREST);
if (this.precision === 'single') {
gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,texSize[0],texSize[1],0,gl.RGBA,gl.FLOAT,null);
} else {
gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,texSize[0],texSize[1],0,gl.RGBA,gl.UNSIGNED_BYTE,null);
}
gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0 + i + 1,gl.TEXTURE_2D,texture,0);

this.mappedTextures.push(new this.TextureConstructor({
texture,
size: texSize,
dimensions: this.threadDim,
output: this.output,
context: this.context,
internalFormat: this.getInternalFormat(),
textureFormat: this.getTextureFormat(),
kernel: this,
}));
 }
 }

 setUniform1f(name,value) {
 if (this.uniform1fCache.hasOwnProperty(name)) {
const cache=this.uniform1fCache[name];
if (value === cache) {
return;
}
 }
 this.uniform1fCache[name]=value;
 const loc=this.getUniformLocation(name);
 this.context.uniform1f(loc,value);
 }

 setUniform1i(name,value) {
 if (this.uniform1iCache.hasOwnProperty(name)) {
const cache=this.uniform1iCache[name];
if (value === cache) {
return;
}
 }
 this.uniform1iCache[name]=value;
 const loc=this.getUniformLocation(name);
 this.context.uniform1i(loc,value);
 }

 setUniform2f(name,value1,value2) {
 if (this.uniform2fCache.hasOwnProperty(name)) {
const cache=this.uniform2fCache[name];
if (
value1 === cache[0] &&
value2 === cache[1]
) {
return;
}
 }
 this.uniform2fCache[name]=[value1,value2];
 const loc=this.getUniformLocation(name);
 this.context.uniform2f(loc,value1,value2);
 }

 setUniform2fv(name,value) {
 if (this.uniform2fvCache.hasOwnProperty(name)) {
const cache=this.uniform2fvCache[name];
if (
value[0] === cache[0] &&
value[1] === cache[1]
) {
return;
}
 }
 this.uniform2fvCache[name]=value;
 const loc=this.getUniformLocation(name);
 this.context.uniform2fv(loc,value);
 }

 setUniform2iv(name,value) {
 if (this.uniform2ivCache.hasOwnProperty(name)) {
const cache=this.uniform2ivCache[name];
if (
value[0] === cache[0] &&
value[1] === cache[1]
) {
return;
}
 }
 this.uniform2ivCache[name]=value;
 const loc=this.getUniformLocation(name);
 this.context.uniform2iv(loc,value);
 }

 setUniform3fv(name,value) {
 if (this.uniform3fvCache.hasOwnProperty(name)) {
const cache=this.uniform3fvCache[name];
if (
value[0] === cache[0] &&
value[1] === cache[1] &&
value[2] === cache[2]
) {
return;
}
 }
 this.uniform3fvCache[name]=value;
 const loc=this.getUniformLocation(name);
 this.context.uniform3fv(loc,value);
 }

 setUniform3iv(name,value) {
 if (this.uniform3ivCache.hasOwnProperty(name)) {
const cache=this.uniform3ivCache[name];
if (
value[0] === cache[0] &&
value[1] === cache[1] &&
value[2] === cache[2]
) {
return;
}
 }
 this.uniform3ivCache[name]=value;
 const loc=this.getUniformLocation(name);
 this.context.uniform3iv(loc,value);
 }

 setUniform4fv(name,value) {
 if (this.uniform4fvCache.hasOwnProperty(name)) {
const cache=this.uniform4fvCache[name];
if (
value[0] === cache[0] &&
value[1] === cache[1] &&
value[2] === cache[2] &&
value[3] === cache[3]
) {
return;
}
 }
 this.uniform4fvCache[name]=value;
 const loc=this.getUniformLocation(name);
 this.context.uniform4fv(loc,value);
 }

 setUniform4iv(name,value) {
 if (this.uniform4ivCache.hasOwnProperty(name)) {
const cache=this.uniform4ivCache[name];
if (
value[0] === cache[0] &&
value[1] === cache[1] &&
value[2] === cache[2] &&
value[3] === cache[3]
) {
return;
}
 }
 this.uniform4ivCache[name]=value;
 const loc=this.getUniformLocation(name);
 this.context.uniform4iv(loc,value);
 }

 getUniformLocation(name) {
 if (this.programUniformLocationCache.hasOwnProperty(name)) {
return this.programUniformLocationCache[name];
 }
 return this.programUniformLocationCache[name]=this.context.getUniformLocation(this.program,name);
 }

 _getFragShaderArtifactMap(args) {
 return {
HEADER: this._getHeaderString(),
LOOP_MAX: this._getLoopMaxString(),
PLUGINS: this._getPluginsString(),
CONSTANTS: this._getConstantsString(),
DECODE32_ENDIANNESS: this._getDecode32EndiannessString(),
ENCODE32_ENDIANNESS: this._getEncode32EndiannessString(),
DIVIDE_WITH_INTEGER_CHECK: this._getDivideWithIntegerCheckString(),
INJECTED_NATIVE: this._getInjectedNative(),
MAIN_CONSTANTS: this._getMainConstantsString(),
MAIN_ARGUMENTS: this._getMainArgumentsString(args),
KERNEL: this.getKernelString(),
MAIN_RESULT: this.getMainResultString(),
FLOAT_TACTIC_DECLARATION: this.getFloatTacticDeclaration(),
INT_TACTIC_DECLARATION: this.getIntTacticDeclaration(),
SAMPLER_2D_TACTIC_DECLARATION: this.getSampler2DTacticDeclaration(),
SAMPLER_2D_ARRAY_TACTIC_DECLARATION: this.getSampler2DArrayTacticDeclaration(),
 };
 }

 _getVertShaderArtifactMap(args) {
 return {
FLOAT_TACTIC_DECLARATION: this.getFloatTacticDeclaration(),
INT_TACTIC_DECLARATION: this.getIntTacticDeclaration(),
SAMPLER_2D_TACTIC_DECLARATION: this.getSampler2DTacticDeclaration(),
SAMPLER_2D_ARRAY_TACTIC_DECLARATION: this.getSampler2DArrayTacticDeclaration(),
 };
 }

 _getHeaderString() {
 return (
this.subKernels !== null ?
'#extension GL_EXT_draw_buffers : require\n' :
''
 );
 }

 _getLoopMaxString() {
 return (
this.loopMaxIterations ?
` ${parseInt(this.loopMaxIterations)};\n` :
' 1000;\n'
 );
 }

 _getPluginsString() {
 if (!this.plugins) return '\n';
 return this.plugins.map(plugin => plugin.source && this.source.match(plugin.functionMatch) ? plugin.source : '').join('\n');
 }

 _getConstantsString() {
 const result=[];
 const { threadDim,texSize }=this;
 if (this.dynamicOutput) {
result.push(
'uniform ivec3 uOutputDim',
'uniform ivec2 uTexSize'
);
 } else {
result.push(
`ivec3 uOutputDim=ivec3(${threadDim[0]},${threadDim[1]},${threadDim[2]})`,
`ivec2 uTexSize=ivec2(${texSize[0]},${texSize[1]})`
);
 }
 return utils.linesToString(result);
 }

 _getTextureCoordinate() {
 const subKernels=this.subKernels;
 if (subKernels === null || subKernels.length < 1) {
return 'varying vec2 vTexCoord;\n';
 } else {
return 'out vec2 vTexCoord;\n';
 }
 }

 _getDecode32EndiannessString() {
 return (
this.endianness === 'LE' ?
'' :
' texel.rgba=texel.abgr;\n'
 );
 }

 _getEncode32EndiannessString() {
 return (
this.endianness === 'LE' ?
'' :
' texel.rgba=texel.abgr;\n'
 );
 }

 _getDivideWithIntegerCheckString() {
 return this.fixIntegerDivisionAccuracy ?
`float divWithIntCheck(float x,float y) {
 if (floor(x) == x && floor(y) == y && integerMod(x,y) == 0.0) {
 return float(int(x) / int(y));
 }
 return x / y;
}

float integerCorrectionModulo(float number,float divisor) {
 if (number < 0.0) {
 number=abs(number);
 if (divisor < 0.0) {
 divisor=abs(divisor);
 }
 return -(number - (divisor * floor(divWithIntCheck(number,divisor))));
 }
 if (divisor < 0.0) {
 divisor=abs(divisor);
 }
 return number - (divisor * floor(divWithIntCheck(number,divisor)));
}` :
'';
 }

 _getMainArgumentsString(args) {
 const results=[];
 const { argumentNames }=this;
 for (let i=0; i < argumentNames.length; i++) {
results.push(this.kernelArguments[i].getSource(args[i]));
 }
 return results.join('');
 }

 _getInjectedNative() {
 return this.injectedNative || '';
 }

 _getMainConstantsString() {
 const result=[];
 const { constants }=this;
 if (constants) {
let i=0;
for (const name in constants) {
if (!this.constants.hasOwnProperty(name)) continue;
result.push(this.kernelConstants[i++].getSource(this.constants[name]));
}
 }
 return result.join('');
 }

 getRawValueFramebuffer(width,height) {
 if (!this.rawValueFramebuffers[width]) {
this.rawValueFramebuffers[width]={};
 }
 if (!this.rawValueFramebuffers[width][height]) {
const framebuffer=this.context.createFramebuffer();
framebuffer.width=width;
framebuffer.height=height;
this.rawValueFramebuffers[width][height]=framebuffer;
 }
 return this.rawValueFramebuffers[width][height];
 }

 getKernelResultDeclaration() {
 switch (this.returnType) {
case 'Array(2)':
return 'vec2 kernelResult';
case 'Array(3)':
return 'vec3 kernelResult';
case 'Array(4)':
return 'vec4 kernelResult';
case 'LiteralInteger':
case 'Float':
case 'Number':
case 'Integer':
return 'float kernelResult';
default:
if (this.graphical) {
return 'float kernelResult';
} else {
throw new Error(`unrecognized output type "${ this.returnType }"`);
}
 }
 }
 getKernelString() {
 const result=[this.getKernelResultDeclaration()];
 const { subKernels }=this;
 if (subKernels !== null) {
switch (this.returnType) {
case 'Number':
case 'Float':
case 'Integer':
for (let i=0; i < subKernels.length; i++) {
const subKernel=subKernels[i];
result.push(
 subKernel.returnType === 'Integer' ?
 `int subKernelResult_${ subKernel.name }=0` :
 `float subKernelResult_${ subKernel.name }=0.0`
);
}
break;
case 'Array(2)':
for (let i=0; i < subKernels.length; i++) {
result.push(
 `vec2 subKernelResult_${ subKernels[i].name }`
);
}
break;
case 'Array(3)':
for (let i=0; i < subKernels.length; i++) {
result.push(
 `vec3 subKernelResult_${ subKernels[i].name }`
);
}
break;
case 'Array(4)':
for (let i=0; i < subKernels.length; i++) {
result.push(
 `vec4 subKernelResult_${ subKernels[i].name }`
);
}
break;
}
 }

 return utils.linesToString(result) + this.translatedSource;
 }

 getMainResultGraphical() {
 return utils.linesToString([
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
' gl_FragColor=actualColor',
 ]);
 }

 getMainResultPackedPixels() {
 switch (this.returnType) {
case 'LiteralInteger':
case 'Number':
case 'Integer':
case 'Float':
return this.getMainResultKernelPackedPixels() +
this.getMainResultSubKernelPackedPixels();
default:
throw new Error(`packed output only usable with Numbers,"${this.returnType}" specified`);
 }
 }

 getMainResultKernelPackedPixels() {
 return utils.linesToString([
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
` gl_FragData[0]=${this.useLegacyEncoder ? 'legacyEncode32' : 'encode32'}(kernelResult)`
 ]);
 }

 getMainResultSubKernelPackedPixels() {
 const result=[];
 if (!this.subKernels) return '';
 for (let i=0; i < this.subKernels.length; i++) {
const subKernel=this.subKernels[i];
if (subKernel.returnType === 'Integer') {
result.push(
` gl_FragData[${i + 1}]=${this.useLegacyEncoder ? 'legacyEncode32' : 'encode32'}(float(subKernelResult_${this.subKernels[i].name}))`
);
} else {
result.push(
` gl_FragData[${i + 1}]=${this.useLegacyEncoder ? 'legacyEncode32' : 'encode32'}(subKernelResult_${this.subKernels[i].name})`
);
}
 }
 return utils.linesToString(result);
 }

 getMainResultMemoryOptimizedFloats() {
 const result=[
' index *= 4',
 ];

 switch (this.returnType) {
case 'Number':
case 'Integer':
case 'Float':
const channels=['r','g','b','a'];
for (let i=0; i < channels.length; i++) {
const channel=channels[i];
this.getMainResultKernelMemoryOptimizedFloats(result,channel);
this.getMainResultSubKernelMemoryOptimizedFloats(result,channel);
if (i + 1 < channels.length) {
result.push(' index += 1');
}
}
break;
default:
throw new Error(`optimized output only usable with Numbers,${this.returnType} specified`);
 }

 return utils.linesToString(result);
 }

 getMainResultKernelMemoryOptimizedFloats(result,channel) {
 result.push(
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
` gl_FragData[0].${channel}=kernelResult`
 );
 }

 getMainResultSubKernelMemoryOptimizedFloats(result,channel) {
 if (!this.subKernels) return result;
 for (let i=0; i < this.subKernels.length; i++) {
const subKernel=this.subKernels[i];
if (subKernel.returnType === 'Integer') {
result.push(
` gl_FragData[${i + 1}].${channel}=float(subKernelResult_${this.subKernels[i].name})`
);
} else {
result.push(
` gl_FragData[${i + 1}].${channel}=subKernelResult_${this.subKernels[i].name}`
);
}
 }
 }

 getMainResultKernelNumberTexture() {
 return [
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
' gl_FragData[0][0]=kernelResult',
 ];
 }

 getMainResultSubKernelNumberTexture() {
 const result=[];
 if (!this.subKernels) return result;
 for (let i=0; i < this.subKernels.length; ++i) {
const subKernel=this.subKernels[i];
if (subKernel.returnType === 'Integer') {
result.push(
` gl_FragData[${i + 1}][0]=float(subKernelResult_${subKernel.name})`
);
} else {
result.push(
` gl_FragData[${i + 1}][0]=subKernelResult_${subKernel.name}`
);
}
 }
 return result;
 }

 getMainResultKernelArray2Texture() {
 return [
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
' gl_FragData[0][0]=kernelResult[0]',
' gl_FragData[0][1]=kernelResult[1]',
 ];
 }

 getMainResultSubKernelArray2Texture() {
 const result=[];
 if (!this.subKernels) return result;
 for (let i=0; i < this.subKernels.length; ++i) {
result.push(
` gl_FragData[${i + 1}][0]=subKernelResult_${this.subKernels[i].name}[0]`,
` gl_FragData[${i + 1}][1]=subKernelResult_${this.subKernels[i].name}[1]`
);
 }
 return result;
 }

 getMainResultKernelArray3Texture() {
 return [
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
' gl_FragData[0][0]=kernelResult[0]',
' gl_FragData[0][1]=kernelResult[1]',
' gl_FragData[0][2]=kernelResult[2]',
 ];
 }

 getMainResultSubKernelArray3Texture() {
 const result=[];
 if (!this.subKernels) return result;
 for (let i=0; i < this.subKernels.length; ++i) {
result.push(
` gl_FragData[${i + 1}][0]=subKernelResult_${this.subKernels[i].name}[0]`,
` gl_FragData[${i + 1}][1]=subKernelResult_${this.subKernels[i].name}[1]`,
` gl_FragData[${i + 1}][2]=subKernelResult_${this.subKernels[i].name}[2]`
);
 }
 return result;
 }

 getMainResultKernelArray4Texture() {
 return [
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
' gl_FragData[0]=kernelResult',
 ];
 }

 getMainResultSubKernelArray4Texture() {
 const result=[];
 if (!this.subKernels) return result;
 switch (this.returnType) {
case 'Number':
case 'Float':
case 'Integer':
for (let i=0; i < this.subKernels.length; ++i) {
const subKernel=this.subKernels[i];
if (subKernel.returnType === 'Integer') {
result.push(
 ` gl_FragData[${i + 1}]=float(subKernelResult_${this.subKernels[i].name})`
);
} else {
result.push(
 ` gl_FragData[${i + 1}]=subKernelResult_${this.subKernels[i].name}`
);
}
}
break;
case 'Array(2)':
for (let i=0; i < this.subKernels.length; ++i) {
result.push(
` gl_FragData[${i + 1}][0]=subKernelResult_${this.subKernels[i].name}[0]`,
` gl_FragData[${i + 1}][1]=subKernelResult_${this.subKernels[i].name}[1]`
);
}
break;
case 'Array(3)':
for (let i=0; i < this.subKernels.length; ++i) {
result.push(
` gl_FragData[${i + 1}][0]=subKernelResult_${this.subKernels[i].name}[0]`,
` gl_FragData[${i + 1}][1]=subKernelResult_${this.subKernels[i].name}[1]`,
` gl_FragData[${i + 1}][2]=subKernelResult_${this.subKernels[i].name}[2]`
);
}
break;
case 'Array(4)':
for (let i=0; i < this.subKernels.length; ++i) {
result.push(
` gl_FragData[${i + 1}][0]=subKernelResult_${this.subKernels[i].name}[0]`,
` gl_FragData[${i + 1}][1]=subKernelResult_${this.subKernels[i].name}[1]`,
` gl_FragData[${i + 1}][2]=subKernelResult_${this.subKernels[i].name}[2]`,
` gl_FragData[${i + 1}][3]=subKernelResult_${this.subKernels[i].name}[3]`
);
}
break;
 }

 return result;
 }

 replaceArtifacts(src,map) {
 return src.replace(/[ ]*__([A-Z]+[0-9]*([_]?[A-Z]*[0-9]?)*)__;\n/g,(match,artifact) => {
if (map.hasOwnProperty(artifact)) {
return map[artifact];
}
throw `unhandled artifact ${artifact}`;
 });
 }

 getFragmentShader(args) {
 if (this.compiledFragmentShader !== null) {
return this.compiledFragmentShader;
 }
 return this.compiledFragmentShader=this.replaceArtifacts(this.constructor.fragmentShader,this._getFragShaderArtifactMap(args));
 }

 getVertexShader(args) {
 if (this.compiledVertexShader !== null) {
return this.compiledVertexShader;
 }
 return this.compiledVertexShader=this.replaceArtifacts(this.constructor.vertexShader,this._getVertShaderArtifactMap(args));
 }

 toString() {
 const setupContextString=utils.linesToString([
`const gl=context`,
 ]);
 return glKernelString(this.constructor,arguments,this,setupContextString);
 }

 destroy(removeCanvasReferences) {
 if (!this.context) return;
 if (this.buffer) {
this.context.deleteBuffer(this.buffer);
 }
 if (this.framebuffer) {
this.context.deleteFramebuffer(this.framebuffer);
 }
 for (const width in this.rawValueFramebuffers) {
for (const height in this.rawValueFramebuffers[width]) {
this.context.deleteFramebuffer(this.rawValueFramebuffers[width][height]);
delete this.rawValueFramebuffers[width][height];
}
delete this.rawValueFramebuffers[width];
 }
 if (this.vertShader) {
this.context.deleteShader(this.vertShader);
 }
 if (this.fragShader) {
this.context.deleteShader(this.fragShader);
 }
 if (this.program) {
this.context.deleteProgram(this.program);
 }
 if (this.texture) {
this.texture.delete();
const textureCacheIndex=this.textureCache.indexOf(this.texture.texture);
if (textureCacheIndex > -1) {
this.textureCache.splice(textureCacheIndex,1);
}
this.texture=null;
 }
 if (this.mappedTextures && this.mappedTextures.length) {
for (let i=0; i < this.mappedTextures.length; i++) {
const mappedTexture=this.mappedTextures[i];
mappedTexture.delete();
const textureCacheIndex=this.textureCache.indexOf(mappedTexture.texture);
if (textureCacheIndex > -1) {
this.textureCache.splice(textureCacheIndex,1);
}
}
this.mappedTextures=null;
 }
 if (this.kernelArguments) {
for (let i=0; i < this.kernelArguments.length; i++) {
this.kernelArguments[i].destroy();
}
 }
 if (this.kernelConstants) {
for (let i=0; i < this.kernelConstants.length; i++) {
this.kernelConstants[i].destroy();
}
 }
 while (this.textureCache.length > 0) {
const texture=this.textureCache.pop();
this.context.deleteTexture(texture);
 }
 if (removeCanvasReferences) {
const idx=canvases.indexOf(this.canvas);
if (idx >= 0) {
canvases[idx]=null;
maxTexSizes[idx]=null;
}
 }
 this.destroyExtensions();
 delete this.context;
 delete this.canvas;
 if (!this.gpu) return;
 const i=this.gpu.kernels.indexOf(this);
 if (i === -1) return;
 this.gpu.kernels.splice(i,1);
 }

 destroyExtensions() {
 this.extensions.OES_texture_float=null;
 this.extensions.OES_texture_float_linear=null;
 this.extensions.OES_element_index_uint=null;
 this.extensions.WEBGL_draw_buffers=null;
 }

 static destroyContext(context) {
 const extension=context.getExtension('WEBGL_lose_context');
 if (extension) {
extension.loseContext();
 }
 }

 toJSON() {
 const json=super.toJSON();
 json.functionNodes=FunctionBuilder.fromKernel(this,WebGLFunctionNode).toJSON();
 json.settings.threadDim=this.threadDim;
 return json;
 }
 }

 module.exports={
 WebGLKernel
 };
 },{"../../plugins/math-random-uniformly-distributed":112,"../../utils":114,"../function-builder":9,"../gl/kernel":13,"../gl/kernel-string":12,"./fragment-shader":37,"./function-node":38,"./kernel-value-maps":39,"./vertex-shader":71}],71:[function(require,module,exports){
 const vertexShader=`__FLOAT_TACTIC_DECLARATION__;
__INT_TACTIC_DECLARATION__;
__SAMPLER_2D_TACTIC_DECLARATION__;

attribute vec2 aPos;
attribute vec2 aTexCoord;

varying vec2 vTexCoord;
uniform vec2 ratio;

void main(void) {
 gl_Position=vec4((aPos + vec2(1)) * ratio + vec2(-1),0,1);
 vTexCoord=aTexCoord;
}`;

 module.exports={
 vertexShader
 };
 },{}],72:[function(require,module,exports){
 const fragmentShader=`#version 300 es
__HEADER__;
__FLOAT_TACTIC_DECLARATION__;
__INT_TACTIC_DECLARATION__;
__SAMPLER_2D_TACTIC_DECLARATION__;
__SAMPLER_2D_ARRAY_TACTIC_DECLARATION__;

const int LOOP_MAX=__LOOP_MAX__;

__PLUGINS__;
__CONSTANTS__;

in vec2 vTexCoord;

float atan2(float v1,float v2) {
 if (v1 == 0.0 || v2 == 0.0) return 0.0;
 return atan(v1 / v2);
}

float cbrt(float x) {
 if (x >= 0.0) {
 return pow(x,1.0 / 3.0);
 } else {
 return -pow(x,1.0 / 3.0);
 }
}

float expm1(float x) {
 return pow(${Math.E},x) - 1.0; 
}

float fround(highp float x) {
 return x;
}

float imul(float v1,float v2) {
 return float(int(v1) * int(v2));
}

float log10(float x) {
 return log2(x) * (1.0 / log2(10.0));
}

float log1p(float x) {
 return log(1.0 + x);
}

float _pow(float v1,float v2) {
 if (v2 == 0.0) return 1.0;
 return pow(v1,v2);
}

float _round(float x) {
 return floor(x + 0.5);
}


const int BIT_COUNT=32;
int modi(int x,int y) {
 return x - y * (x / y);
}

int bitwiseOr(int a,int b) {
 int result=0;
 int n=1;
 
 for (int i=0; i < BIT_COUNT; i++) {
 if ((modi(a,2) == 1) || (modi(b,2) == 1)) {
 result += n;
 }
 a=a / 2;
 b=b / 2;
 n=n * 2;
 if(!(a > 0 || b > 0)) {
 break;
 }
 }
 return result;
}
int bitwiseXOR(int a,int b) {
 int result=0;
 int n=1;
 
 for (int i=0; i < BIT_COUNT; i++) {
 if ((modi(a,2) == 1) != (modi(b,2) == 1)) {
 result += n;
 }
 a=a / 2;
 b=b / 2;
 n=n * 2;
 if(!(a > 0 || b > 0)) {
 break;
 }
 }
 return result;
}
int bitwiseAnd(int a,int b) {
 int result=0;
 int n=1;
 for (int i=0; i < BIT_COUNT; i++) {
 if ((modi(a,2) == 1) && (modi(b,2) == 1)) {
 result += n;
 }
 a=a / 2;
 b=b / 2;
 n=n * 2;
 if(!(a > 0 && b > 0)) {
 break;
 }
 }
 return result;
}
int bitwiseNot(int a) {
 int result=0;
 int n=1;
 
 for (int i=0; i < BIT_COUNT; i++) {
 if (modi(a,2) == 0) {
 result += n; 
 }
 a=a / 2;
 n=n * 2;
 }
 return result;
}
int bitwiseZeroFillLeftShift(int n,int shift) {
 int maxBytes=BIT_COUNT;
 for (int i=0; i < BIT_COUNT; i++) {
 if (maxBytes >= n) {
 break;
 }
 maxBytes *= 2;
 }
 for (int i=0; i < BIT_COUNT; i++) {
 if (i >= shift) {
 break;
 }
 n *= 2;
 }

 int result=0;
 int byteVal=1;
 for (int i=0; i < BIT_COUNT; i++) {
 if (i >= maxBytes) break;
 if (modi(n,2) > 0) { result += byteVal; }
 n=int(n / 2);
 byteVal *= 2;
 }
 return result;
}

int bitwiseSignedRightShift(int num,int shifts) {
 return int(floor(float(num) / pow(2.0,float(shifts))));
}

int bitwiseZeroFillRightShift(int n,int shift) {
 int maxBytes=BIT_COUNT;
 for (int i=0; i < BIT_COUNT; i++) {
 if (maxBytes >= n) {
 break;
 }
 maxBytes *= 2;
 }
 for (int i=0; i < BIT_COUNT; i++) {
 if (i >= shift) {
 break;
 }
 n /= 2;
 }
 int result=0;
 int byteVal=1;
 for (int i=0; i < BIT_COUNT; i++) {
 if (i >= maxBytes) break;
 if (modi(n,2) > 0) { result += byteVal; }
 n=int(n / 2);
 byteVal *= 2;
 }
 return result;
}

vec2 integerMod(vec2 x,float y) {
 vec2 res=floor(mod(x,y));
 return res * step(1.0 - floor(y),-res);
}

vec3 integerMod(vec3 x,float y) {
 vec3 res=floor(mod(x,y));
 return res * step(1.0 - floor(y),-res);
}

vec4 integerMod(vec4 x,vec4 y) {
 vec4 res=floor(mod(x,y));
 return res * step(1.0 - floor(y),-res);
}

float integerMod(float x,float y) {
 float res=floor(mod(x,y));
 return res * (res > floor(y) - 1.0 ? 0.0 : 1.0);
}

int integerMod(int x,int y) {
 return x - (y * int(x/y));
}

__DIVIDE_WITH_INTEGER_CHECK__;

// Here be dragons!
// DO NOT OPTIMIZE THIS CODE
// YOU WILL BREAK SOMETHING ON SOMEBODY\'S MACHINE
// LEAVE IT AS IT IS,LEST YOU WASTE YOUR OWN TIME
const vec2 MAGIC_VEC=vec2(1.0,-256.0);
const vec4 SCALE_FACTOR=vec4(1.0,256.0,65536.0,0.0);
const vec4 SCALE_FACTOR_INV=vec4(1.0,0.00390625,0.0000152587890625,0.0); // 1,1/256,1/65536
float decode32(vec4 texel) {
 __DECODE32_ENDIANNESS__;
 texel *= 255.0;
 vec2 gte128;
 gte128.x=texel.b >= 128.0 ? 1.0 : 0.0;
 gte128.y=texel.a >= 128.0 ? 1.0 : 0.0;
 float exponent=2.0 * texel.a - 127.0 + dot(gte128,MAGIC_VEC);
 float res=exp2(round(exponent));
 texel.b=texel.b - 128.0 * gte128.x;
 res=dot(texel,SCALE_FACTOR) * exp2(round(exponent-23.0)) + res;
 res *= gte128.y * -2.0 + 1.0;
 return res;
}

float decode16(vec4 texel,int index) {
 int channel=integerMod(index,2);
 return texel[channel*2] * 255.0 + texel[channel*2 + 1] * 65280.0;
}

float decode8(vec4 texel,int index) {
 int channel=integerMod(index,4);
 return texel[channel] * 255.0;
}

vec4 legacyEncode32(float f) {
 float F=abs(f);
 float sign=f < 0.0 ? 1.0 : 0.0;
 float exponent=floor(log2(F));
 float mantissa=(exp2(-exponent) * F);
 // exponent += floor(log2(mantissa));
 vec4 texel=vec4(F * exp2(23.0-exponent)) * SCALE_FACTOR_INV;
 texel.rg=integerMod(texel.rg,256.0);
 texel.b=integerMod(texel.b,128.0);
 texel.a=exponent*0.5 + 63.5;
 texel.ba += vec2(integerMod(exponent+127.0,2.0),sign) * 128.0;
 texel=floor(texel);
 texel *= 0.003921569; // 1/255
 __ENCODE32_ENDIANNESS__;
 return texel;
}

// https://github.com/gpujs/gpu.js/wiki/Encoder-details
vec4 encode32(float value) {
 if (value == 0.0) return vec4(0,0,0,0);

 float exponent;
 float mantissa;
 vec4 result;
 float sgn;

 sgn=step(0.0,-value);
 value=abs(value);

 exponent=floor(log2(value));

 mantissa=value*pow(2.0,-exponent)-1.0;
 exponent=exponent+127.0;
 result=vec4(0,0,0,0);

 result.a=floor(exponent/2.0);
 exponent=exponent - result.a*2.0;
 result.a=result.a + 128.0*sgn;

 result.b=floor(mantissa * 128.0);
 mantissa=mantissa - result.b / 128.0;
 result.b=result.b + exponent*128.0;

 result.g=floor(mantissa*32768.0);
 mantissa=mantissa - result.g/32768.0;

 result.r=floor(mantissa*8388608.0);
 return result/255.0;
}
// Dragons end here

int index;
ivec3 threadId;

ivec3 indexTo3D(int idx,ivec3 texDim) {
 int z=int(idx / (texDim.x * texDim.y));
 idx -= z * int(texDim.x * texDim.y);
 int y=int(idx / texDim.x);
 int x=int(integerMod(idx,texDim.x));
 return ivec3(x,y,z);
}

float get32(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + texDim.x * (y + texDim.y * z);
 int w=texSize.x;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 vec4 texel=texture(tex,st / vec2(texSize));
 return decode32(texel);
}

float get16(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + (texDim.x * (y + (texDim.y * z)));
 int w=texSize.x * 2;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 vec4 texel=texture(tex,st / vec2(texSize.x * 2,texSize.y));
 return decode16(texel,index);
}

float get8(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + (texDim.x * (y + (texDim.y * z)));
 int w=texSize.x * 4;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 vec4 texel=texture(tex,st / vec2(texSize.x * 4,texSize.y));
 return decode8(texel,index);
}

float getMemoryOptimized32(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + (texDim.x * (y + (texDim.y * z)));
 int channel=integerMod(index,4);
 index=index / 4;
 int w=texSize.x;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 index=index / 4;
 vec4 texel=texture(tex,st / vec2(texSize));
 return texel[channel];
}

vec4 getImage2D(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + texDim.x * (y + texDim.y * z);
 int w=texSize.x;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 return texture(tex,st / vec2(texSize));
}

vec4 getImage3D(sampler2DArray tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + texDim.x * (y + texDim.y * z);
 int w=texSize.x;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 return texture(tex,vec3(st / vec2(texSize),z));
}

float getFloatFromSampler2D(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 vec4 result=getImage2D(tex,texSize,texDim,z,y,x);
 return result[0];
}

vec2 getVec2FromSampler2D(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 vec4 result=getImage2D(tex,texSize,texDim,z,y,x);
 return vec2(result[0],result[1]);
}

vec2 getMemoryOptimizedVec2(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + texDim.x * (y + texDim.y * z);
 int channel=integerMod(index,2);
 index=index / 2;
 int w=texSize.x;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 vec4 texel=texture(tex,st / vec2(texSize));
 if (channel == 0) return vec2(texel.r,texel.g);
 if (channel == 1) return vec2(texel.b,texel.a);
 return vec2(0.0,0.0);
}

vec3 getVec3FromSampler2D(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 vec4 result=getImage2D(tex,texSize,texDim,z,y,x);
 return vec3(result[0],result[1],result[2]);
}

vec3 getMemoryOptimizedVec3(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int fieldIndex=3 * (x + texDim.x * (y + texDim.y * z));
 int vectorIndex=fieldIndex / 4;
 int vectorOffset=fieldIndex - vectorIndex * 4;
 int readY=vectorIndex / texSize.x;
 int readX=vectorIndex - readY * texSize.x;
 vec4 tex1=texture(tex,(vec2(readX,readY) + 0.5) / vec2(texSize));

 if (vectorOffset == 0) {
 return tex1.xyz;
 } else if (vectorOffset == 1) {
 return tex1.yzw;
 } else {
 readX++;
 if (readX >= texSize.x) {
 readX=0;
 readY++;
 }
 vec4 tex2=texture(tex,vec2(readX,readY) / vec2(texSize));
 if (vectorOffset == 2) {
 return vec3(tex1.z,tex1.w,tex2.x);
 } else {
 return vec3(tex1.w,tex2.x,tex2.y);
 }
 }
}

vec4 getVec4FromSampler2D(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 return getImage2D(tex,texSize,texDim,z,y,x);
}

vec4 getMemoryOptimizedVec4(sampler2D tex,ivec2 texSize,ivec3 texDim,int z,int y,int x) {
 int index=x + texDim.x * (y + texDim.y * z);
 int channel=integerMod(index,2);
 int w=texSize.x;
 vec2 st=vec2(float(integerMod(index,w)),float(index / w)) + 0.5;
 vec4 texel=texture(tex,st / vec2(texSize));
 return vec4(texel.r,texel.g,texel.b,texel.a);
}

vec4 actualColor;
void color(float r,float g,float b,float a) {
 actualColor=vec4(r,g,b,a);
}

void color(float r,float g,float b) {
 color(r,g,b,1.0);
}

float modulo(float number,float divisor) {
 if (number < 0.0) {
 number=abs(number);
 if (divisor < 0.0) {
 divisor=abs(divisor);
 }
 return -mod(number,divisor);
 }
 if (divisor < 0.0) {
 divisor=abs(divisor);
 }
 return mod(number,divisor);
}

__INJECTED_NATIVE__;
__MAIN_CONSTANTS__;
__MAIN_ARGUMENTS__;
__KERNEL__;

void main(void) {
 index=int(vTexCoord.s * float(uTexSize.x)) + int(vTexCoord.t * float(uTexSize.y)) * uTexSize.x;
 __MAIN_RESULT__;
}`;

 module.exports={
 fragmentShader
 };
 },{}],73:[function(require,module,exports){
 const { utils }=require('../../utils');
 const { WebGLFunctionNode }=require('../web-gl/function-node');

 class WebGL2FunctionNode extends WebGLFunctionNode {

 astIdentifierExpression(idtNode,retArr) {
 if (idtNode.type !== 'Identifier') {
throw this.astErrorOutput(
'IdentifierExpression - not an Identifier',
idtNode
);
 }

 const type=this.getType(idtNode);

 const name=utils.sanitizeName(idtNode.name);
 if (idtNode.name === 'Infinity') {
retArr.push('intBitsToFloat(2139095039)');
 } else if (type === 'Boolean') {
if (this.argumentNames.indexOf(name) > -1) {
retArr.push(`bool(user_${name})`);
} else {
retArr.push(`user_${name}`);
}
 } else {
retArr.push(`user_${name}`);
 }

 return retArr;
 }
 }

 module.exports={
 WebGL2FunctionNode
 };
 },{"../../utils":114,"../web-gl/function-node":38}],74:[function(require,module,exports){
 const { WebGL2KernelValueBoolean }=require('./kernel-value/boolean');
 const { WebGL2KernelValueFloat }=require('./kernel-value/float');
 const { WebGL2KernelValueInteger }=require('./kernel-value/integer');

 const { WebGL2KernelValueHTMLImage }=require('./kernel-value/html-image');
 const { WebGL2KernelValueDynamicHTMLImage }=require('./kernel-value/dynamic-html-image');

 const { WebGL2KernelValueHTMLImageArray }=require('./kernel-value/html-image-array');
 const { WebGL2KernelValueDynamicHTMLImageArray }=require('./kernel-value/dynamic-html-image-array');

 const { WebGL2KernelValueHTMLVideo }=require('./kernel-value/html-video');
 const { WebGL2KernelValueDynamicHTMLVideo }=require('./kernel-value/dynamic-html-video');

 const { WebGL2KernelValueSingleInput }=require('./kernel-value/single-input');
 const { WebGL2KernelValueDynamicSingleInput }=require('./kernel-value/dynamic-single-input');

 const { WebGL2KernelValueUnsignedInput }=require('./kernel-value/unsigned-input');
 const { WebGL2KernelValueDynamicUnsignedInput }=require('./kernel-value/dynamic-unsigned-input');

 const { WebGL2KernelValueMemoryOptimizedNumberTexture }=require('./kernel-value/memory-optimized-number-texture');
 const { WebGL2KernelValueDynamicMemoryOptimizedNumberTexture }=require('./kernel-value/dynamic-memory-optimized-number-texture');

 const { WebGL2KernelValueNumberTexture }=require('./kernel-value/number-texture');
 const { WebGL2KernelValueDynamicNumberTexture }=require('./kernel-value/dynamic-number-texture');

 const { WebGL2KernelValueSingleArray }=require('./kernel-value/single-array');
 const { WebGL2KernelValueDynamicSingleArray }=require('./kernel-value/dynamic-single-array');

 const { WebGL2KernelValueSingleArray1DI }=require('./kernel-value/single-array1d-i');
 const { WebGL2KernelValueDynamicSingleArray1DI }=require('./kernel-value/dynamic-single-array1d-i');

 const { WebGL2KernelValueSingleArray2DI }=require('./kernel-value/single-array2d-i');
 const { WebGL2KernelValueDynamicSingleArray2DI }=require('./kernel-value/dynamic-single-array2d-i');

 const { WebGL2KernelValueSingleArray3DI }=require('./kernel-value/single-array3d-i');
 const { WebGL2KernelValueDynamicSingleArray3DI }=require('./kernel-value/dynamic-single-array3d-i');

 const { WebGL2KernelValueArray2 }=require('./kernel-value/array2');
 const { WebGL2KernelValueArray3 }=require('./kernel-value/array3');
 const { WebGL2KernelValueArray4 }=require('./kernel-value/array4');

 const { WebGL2KernelValueUnsignedArray }=require('./kernel-value/unsigned-array');
 const { WebGL2KernelValueDynamicUnsignedArray }=require('./kernel-value/dynamic-unsigned-array');

 const kernelValueMaps={
 unsigned: {
 dynamic: {
'Boolean': WebGL2KernelValueBoolean,
'Integer': WebGL2KernelValueInteger,
'Float': WebGL2KernelValueFloat,
'Array': WebGL2KernelValueDynamicUnsignedArray,
'Array(2)': WebGL2KernelValueArray2,
'Array(3)': WebGL2KernelValueArray3,
'Array(4)': WebGL2KernelValueArray4,
'Array1D(2)': false,
'Array1D(3)': false,
'Array1D(4)': false,
'Array2D(2)': false,
'Array2D(3)': false,
'Array2D(4)': false,
'Array3D(2)': false,
'Array3D(3)': false,
'Array3D(4)': false,
'Input': WebGL2KernelValueDynamicUnsignedInput,
'NumberTexture': WebGL2KernelValueDynamicNumberTexture,
'ArrayTexture(1)': WebGL2KernelValueDynamicNumberTexture,
'ArrayTexture(2)': WebGL2KernelValueDynamicNumberTexture,
'ArrayTexture(3)': WebGL2KernelValueDynamicNumberTexture,
'ArrayTexture(4)': WebGL2KernelValueDynamicNumberTexture,
'MemoryOptimizedNumberTexture': WebGL2KernelValueDynamicMemoryOptimizedNumberTexture,
'HTMLCanvas': WebGL2KernelValueDynamicHTMLImage,
'OffscreenCanvas': WebGL2KernelValueDynamicHTMLImage,
'HTMLImage': WebGL2KernelValueDynamicHTMLImage,
'ImageBitmap': WebGL2KernelValueDynamicHTMLImage,
'ImageData': WebGL2KernelValueDynamicHTMLImage,
'HTMLImageArray': WebGL2KernelValueDynamicHTMLImageArray,
'HTMLVideo': WebGL2KernelValueDynamicHTMLVideo,
 },
 static: {
'Boolean': WebGL2KernelValueBoolean,
'Float': WebGL2KernelValueFloat,
'Integer': WebGL2KernelValueInteger,
'Array': WebGL2KernelValueUnsignedArray,
'Array(2)': WebGL2KernelValueArray2,
'Array(3)': WebGL2KernelValueArray3,
'Array(4)': WebGL2KernelValueArray4,
'Array1D(2)': false,
'Array1D(3)': false,
'Array1D(4)': false,
'Array2D(2)': false,
'Array2D(3)': false,
'Array2D(4)': false,
'Array3D(2)': false,
'Array3D(3)': false,
'Array3D(4)': false,
'Input': WebGL2KernelValueUnsignedInput,
'NumberTexture': WebGL2KernelValueNumberTexture,
'ArrayTexture(1)': WebGL2KernelValueNumberTexture,
'ArrayTexture(2)': WebGL2KernelValueNumberTexture,
'ArrayTexture(3)': WebGL2KernelValueNumberTexture,
'ArrayTexture(4)': WebGL2KernelValueNumberTexture,
'MemoryOptimizedNumberTexture': WebGL2KernelValueDynamicMemoryOptimizedNumberTexture,
'HTMLCanvas': WebGL2KernelValueHTMLImage,
'OffscreenCanvas': WebGL2KernelValueHTMLImage,
'HTMLImage': WebGL2KernelValueHTMLImage,
'ImageBitmap': WebGL2KernelValueHTMLImage,
'ImageData': WebGL2KernelValueHTMLImage,
'HTMLImageArray': WebGL2KernelValueHTMLImageArray,
'HTMLVideo': WebGL2KernelValueHTMLVideo,
 }
 },
 single: {
 dynamic: {
'Boolean': WebGL2KernelValueBoolean,
'Integer': WebGL2KernelValueInteger,
'Float': WebGL2KernelValueFloat,
'Array': WebGL2KernelValueDynamicSingleArray,
'Array(2)': WebGL2KernelValueArray2,
'Array(3)': WebGL2KernelValueArray3,
'Array(4)': WebGL2KernelValueArray4,
'Array1D(2)': WebGL2KernelValueDynamicSingleArray1DI,
'Array1D(3)': WebGL2KernelValueDynamicSingleArray1DI,
'Array1D(4)': WebGL2KernelValueDynamicSingleArray1DI,
'Array2D(2)': WebGL2KernelValueDynamicSingleArray2DI,
'Array2D(3)': WebGL2KernelValueDynamicSingleArray2DI,
'Array2D(4)': WebGL2KernelValueDynamicSingleArray2DI,
'Array3D(2)': WebGL2KernelValueDynamicSingleArray3DI,
'Array3D(3)': WebGL2KernelValueDynamicSingleArray3DI,
'Array3D(4)': WebGL2KernelValueDynamicSingleArray3DI,
'Input': WebGL2KernelValueDynamicSingleInput,
'NumberTexture': WebGL2KernelValueDynamicNumberTexture,
'ArrayTexture(1)': WebGL2KernelValueDynamicNumberTexture,
'ArrayTexture(2)': WebGL2KernelValueDynamicNumberTexture,
'ArrayTexture(3)': WebGL2KernelValueDynamicNumberTexture,
'ArrayTexture(4)': WebGL2KernelValueDynamicNumberTexture,
'MemoryOptimizedNumberTexture': WebGL2KernelValueDynamicMemoryOptimizedNumberTexture,
'HTMLCanvas': WebGL2KernelValueDynamicHTMLImage,
'OffscreenCanvas': WebGL2KernelValueDynamicHTMLImage,
'HTMLImage': WebGL2KernelValueDynamicHTMLImage,
'ImageBitmap': WebGL2KernelValueDynamicHTMLImage,
'ImageData': WebGL2KernelValueDynamicHTMLImage,
'HTMLImageArray': WebGL2KernelValueDynamicHTMLImageArray,
'HTMLVideo': WebGL2KernelValueDynamicHTMLVideo,
 },
 static: {
'Boolean': WebGL2KernelValueBoolean,
'Float': WebGL2KernelValueFloat,
'Integer': WebGL2KernelValueInteger,
'Array': WebGL2KernelValueSingleArray,
'Array(2)': WebGL2KernelValueArray2,
'Array(3)': WebGL2KernelValueArray3,
'Array(4)': WebGL2KernelValueArray4,
'Array1D(2)': WebGL2KernelValueSingleArray1DI,
'Array1D(3)': WebGL2KernelValueSingleArray1DI,
'Array1D(4)': WebGL2KernelValueSingleArray1DI,
'Array2D(2)': WebGL2KernelValueSingleArray2DI,
'Array2D(3)': WebGL2KernelValueSingleArray2DI,
'Array2D(4)': WebGL2KernelValueSingleArray2DI,
'Array3D(2)': WebGL2KernelValueSingleArray3DI,
'Array3D(3)': WebGL2KernelValueSingleArray3DI,
'Array3D(4)': WebGL2KernelValueSingleArray3DI,
'Input': WebGL2KernelValueSingleInput,
'NumberTexture': WebGL2KernelValueNumberTexture,
'ArrayTexture(1)': WebGL2KernelValueNumberTexture,
'ArrayTexture(2)': WebGL2KernelValueNumberTexture,
'ArrayTexture(3)': WebGL2KernelValueNumberTexture,
'ArrayTexture(4)': WebGL2KernelValueNumberTexture,
'MemoryOptimizedNumberTexture': WebGL2KernelValueMemoryOptimizedNumberTexture,
'HTMLCanvas': WebGL2KernelValueHTMLImage,
'OffscreenCanvas': WebGL2KernelValueHTMLImage,
'HTMLImage': WebGL2KernelValueHTMLImage,
'ImageBitmap': WebGL2KernelValueHTMLImage,
'ImageData': WebGL2KernelValueHTMLImage,
'HTMLImageArray': WebGL2KernelValueHTMLImageArray,
'HTMLVideo': WebGL2KernelValueHTMLVideo,
 }
 },
 };

 function lookupKernelValueType(type,dynamic,precision,value) {
 if (!type) {
 throw new Error('type missing');
 }
 if (!dynamic) {
 throw new Error('dynamic missing');
 }
 if (!precision) {
 throw new Error('precision missing');
 }
 if (value.type) {
 type=value.type;
 }
 const types=kernelValueMaps[precision][dynamic];
 if (types[type] === false) {
 return null;
 } else if (types[type] === undefined) {
 throw new Error(`Could not find a KernelValue for ${ type }`);
 }
 return types[type];
 }

 module.exports={
 kernelValueMaps,
 lookupKernelValueType
 };
 },{"./kernel-value/array2":75,"./kernel-value/array3":76,"./kernel-value/array4":77,"./kernel-value/boolean":78,"./kernel-value/dynamic-html-image":80,"./kernel-value/dynamic-html-image-array":79,"./kernel-value/dynamic-html-video":81,"./kernel-value/dynamic-memory-optimized-number-texture":82,"./kernel-value/dynamic-number-texture":83,"./kernel-value/dynamic-single-array":84,"./kernel-value/dynamic-single-array1d-i":85,"./kernel-value/dynamic-single-array2d-i":86,"./kernel-value/dynamic-single-array3d-i":87,"./kernel-value/dynamic-single-input":88,"./kernel-value/dynamic-unsigned-array":89,"./kernel-value/dynamic-unsigned-input":90,"./kernel-value/float":91,"./kernel-value/html-image":93,"./kernel-value/html-image-array":92,"./kernel-value/html-video":94,"./kernel-value/integer":95,"./kernel-value/memory-optimized-number-texture":96,"./kernel-value/number-texture":97,"./kernel-value/single-array":98,"./kernel-value/single-array1d-i":99,"./kernel-value/single-array2d-i":100,"./kernel-value/single-array3d-i":101,"./kernel-value/single-input":102,"./kernel-value/unsigned-array":103,"./kernel-value/unsigned-input":104}],75:[function(require,module,exports){
 const { WebGLKernelValueArray2 }=require('../../web-gl/kernel-value/array2');

 class WebGL2KernelValueArray2 extends WebGLKernelValueArray2 {}

 module.exports={
 WebGL2KernelValueArray2
 };
 },{"../../web-gl/kernel-value/array2":41}],76:[function(require,module,exports){
 const { WebGLKernelValueArray3 }=require('../../web-gl/kernel-value/array3');

 class WebGL2KernelValueArray3 extends WebGLKernelValueArray3 {}

 module.exports={
 WebGL2KernelValueArray3
 };
 },{"../../web-gl/kernel-value/array3":42}],77:[function(require,module,exports){
 const { WebGLKernelValueArray4 }=require('../../web-gl/kernel-value/array4');

 class WebGL2KernelValueArray4 extends WebGLKernelValueArray4 {}

 module.exports={
 WebGL2KernelValueArray4
 };
 },{"../../web-gl/kernel-value/array4":43}],78:[function(require,module,exports){
 const { WebGLKernelValueBoolean }=require('../../web-gl/kernel-value/boolean');

 class WebGL2KernelValueBoolean extends WebGLKernelValueBoolean {}

 module.exports={
 WebGL2KernelValueBoolean
 };
 },{"../../web-gl/kernel-value/boolean":44}],79:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGL2KernelValueHTMLImageArray }=require('./html-image-array');

 class WebGL2KernelValueDynamicHTMLImageArray extends WebGL2KernelValueHTMLImageArray {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2DArray ${this.id}`,
`uniform ${ variablePrecision } ivec2 ${this.sizeId}`,
`uniform ${ variablePrecision } ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(images) {
 const { width,height }=images[0];
 this.checkSize(width,height);
 this.dimensions=[width,height,images.length];
 this.textureSize=[width,height];
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(images);
 }
 }

 module.exports={
 WebGL2KernelValueDynamicHTMLImageArray
 };
 },{"../../../utils":114,"./html-image-array":92}],80:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueDynamicHTMLImage }=require('../../web-gl/kernel-value/dynamic-html-image');

 class WebGL2KernelValueDynamicHTMLImage extends WebGLKernelValueDynamicHTMLImage {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`uniform ${ variablePrecision } ivec2 ${this.sizeId}`,
`uniform ${ variablePrecision } ivec3 ${this.dimensionsId}`,
 ]);
 }
 }

 module.exports={
 WebGL2KernelValueDynamicHTMLImage
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/dynamic-html-image":45}],81:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGL2KernelValueDynamicHTMLImage }=require('./dynamic-html-image');

 class WebGL2KernelValueDynamicHTMLVideo extends WebGL2KernelValueDynamicHTMLImage {}

 module.exports={
 WebGL2KernelValueDynamicHTMLVideo
 };
 },{"../../../utils":114,"./dynamic-html-image":80}],82:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueDynamicMemoryOptimizedNumberTexture }=require('../../web-gl/kernel-value/dynamic-memory-optimized-number-texture');

 class WebGL2KernelValueDynamicMemoryOptimizedNumberTexture extends WebGLKernelValueDynamicMemoryOptimizedNumberTexture {
 getSource() {
 return utils.linesToString([
`uniform sampler2D ${this.id}`,
`uniform ivec2 ${this.sizeId}`,
`uniform ivec3 ${this.dimensionsId}`,
 ]);
 }
 }

 module.exports={
 WebGL2KernelValueDynamicMemoryOptimizedNumberTexture
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/dynamic-memory-optimized-number-texture":47}],83:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueDynamicNumberTexture }=require('../../web-gl/kernel-value/dynamic-number-texture');

 class WebGL2KernelValueDynamicNumberTexture extends WebGLKernelValueDynamicNumberTexture {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`uniform ${ variablePrecision } ivec2 ${this.sizeId}`,
`uniform ${ variablePrecision } ivec3 ${this.dimensionsId}`,
 ]);
 }
 }

 module.exports={
 WebGL2KernelValueDynamicNumberTexture
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/dynamic-number-texture":48}],84:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGL2KernelValueSingleArray }=require('../../web-gl2/kernel-value/single-array');

 class WebGL2KernelValueDynamicSingleArray extends WebGL2KernelValueSingleArray {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`uniform ${ variablePrecision } ivec2 ${this.sizeId}`,
`uniform ${ variablePrecision } ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 this.dimensions=utils.getDimensions(value,true);
 this.textureSize=utils.getMemoryOptimizedFloatTextureSize(this.dimensions,this.bitRatio);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * this.bitRatio;
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 this.uploadValue=new Float32Array(this.uploadArrayLength);
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGL2KernelValueDynamicSingleArray
 };
 },{"../../../utils":114,"../../web-gl2/kernel-value/single-array":98}],85:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGL2KernelValueSingleArray1DI }=require('../../web-gl2/kernel-value/single-array1d-i');

 class WebGL2KernelValueDynamicSingleArray1DI extends WebGL2KernelValueSingleArray1DI {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`uniform ${ variablePrecision } ivec2 ${this.sizeId}`,
`uniform ${ variablePrecision } ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 this.setShape(value);
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGL2KernelValueDynamicSingleArray1DI
 };
 },{"../../../utils":114,"../../web-gl2/kernel-value/single-array1d-i":99}],86:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGL2KernelValueSingleArray2DI }=require('../../web-gl2/kernel-value/single-array2d-i');

 class WebGL2KernelValueDynamicSingleArray2DI extends WebGL2KernelValueSingleArray2DI {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`uniform ${ variablePrecision } ivec2 ${this.sizeId}`,
`uniform ${ variablePrecision } ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 this.setShape(value);
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGL2KernelValueDynamicSingleArray2DI
 };
 },{"../../../utils":114,"../../web-gl2/kernel-value/single-array2d-i":100}],87:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGL2KernelValueSingleArray3DI }=require('../../web-gl2/kernel-value/single-array3d-i');

 class WebGL2KernelValueDynamicSingleArray3DI extends WebGL2KernelValueSingleArray3DI {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`uniform ${ variablePrecision } ivec2 ${this.sizeId}`,
`uniform ${ variablePrecision } ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 this.setShape(value);
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGL2KernelValueDynamicSingleArray3DI
 };
 },{"../../../utils":114,"../../web-gl2/kernel-value/single-array3d-i":101}],88:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGL2KernelValueSingleInput }=require('../../web-gl2/kernel-value/single-input');

 class WebGL2KernelValueDynamicSingleInput extends WebGL2KernelValueSingleInput {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`uniform ${ variablePrecision } ivec2 ${this.sizeId}`,
`uniform ${ variablePrecision } ivec3 ${this.dimensionsId}`,
 ]);
 }

 updateValue(value) {
 let [w,h,d]=value.size;
 this.dimensions=new Int32Array([w || 1,h || 1,d || 1]);
 this.textureSize=utils.getMemoryOptimizedFloatTextureSize(this.dimensions,this.bitRatio);
 this.uploadArrayLength=this.textureSize[0] * this.textureSize[1] * this.bitRatio;
 this.checkSize(this.textureSize[0],this.textureSize[1]);
 this.uploadValue=new Float32Array(this.uploadArrayLength);
 this.kernel.setUniform3iv(this.dimensionsId,this.dimensions);
 this.kernel.setUniform2iv(this.sizeId,this.textureSize);
 super.updateValue(value);
 }
 }

 module.exports={
 WebGL2KernelValueDynamicSingleInput
 };
 },{"../../../utils":114,"../../web-gl2/kernel-value/single-input":102}],89:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueDynamicUnsignedArray }=require('../../web-gl/kernel-value/dynamic-unsigned-array');

 class WebGL2KernelValueDynamicUnsignedArray extends WebGLKernelValueDynamicUnsignedArray {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`uniform ${ variablePrecision } ivec2 ${this.sizeId}`,
`uniform ${ variablePrecision } ivec3 ${this.dimensionsId}`,
 ]);
 }
 }

 module.exports={
 WebGL2KernelValueDynamicUnsignedArray
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/dynamic-unsigned-array":54}],90:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueDynamicUnsignedInput }=require('../../web-gl/kernel-value/dynamic-unsigned-input');

 class WebGL2KernelValueDynamicUnsignedInput extends WebGLKernelValueDynamicUnsignedInput {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`uniform ${ variablePrecision } ivec2 ${this.sizeId}`,
`uniform ${ variablePrecision } ivec3 ${this.dimensionsId}`,
 ]);
 }
 }

 module.exports={
 WebGL2KernelValueDynamicUnsignedInput
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/dynamic-unsigned-input":55}],91:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueFloat }=require('../../web-gl/kernel-value/float');

 class WebGL2KernelValueFloat extends WebGLKernelValueFloat {}

 module.exports={
 WebGL2KernelValueFloat
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/float":56}],92:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelArray }=require('../../web-gl/kernel-value/array');

 class WebGL2KernelValueHTMLImageArray extends WebGLKernelArray {
 constructor(value,settings) {
 super(value,settings);
 this.checkSize(value[0].width,value[0].height);
 this.dimensions=[value[0].width,value[0].height,value.length];
 this.textureSize=[value[0].width,value[0].height];
 }
 defineTexture() {
 const { context: gl }=this;
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D_ARRAY,this.texture);
 gl.texParameteri(gl.TEXTURE_2D_ARRAY,gl.TEXTURE_MAG_FILTER,gl.NEAREST);
 gl.texParameteri(gl.TEXTURE_2D_ARRAY,gl.TEXTURE_MIN_FILTER,gl.NEAREST);
 }

 getStringValueHandler() {
 return `const uploadValue_${this.name}=${this.varName};\n`;
 }
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2DArray ${this.id}`,
`${ variablePrecision } ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`${ variablePrecision } ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(images) {
 const { context: gl }=this;
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D_ARRAY,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,true);
 gl.texImage3D(
gl.TEXTURE_2D_ARRAY,
0,
gl.RGBA,
images[0].width,
images[0].height,
images.length,
0,
gl.RGBA,
gl.UNSIGNED_BYTE,
null
 );
 for (let i=0; i < images.length; i++) {
const xOffset=0;
const yOffset=0;
const imageDepth=1;
gl.texSubImage3D(
gl.TEXTURE_2D_ARRAY,
0,
xOffset,
yOffset,
i,
images[i].width,
images[i].height,
imageDepth,
gl.RGBA,
gl.UNSIGNED_BYTE,
this.uploadValue=images[i]
);
 }
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGL2KernelValueHTMLImageArray
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/array":40}],93:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueHTMLImage }=require('../../web-gl/kernel-value/html-image');

 class WebGL2KernelValueHTMLImage extends WebGLKernelValueHTMLImage {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`${ variablePrecision } ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`${ variablePrecision } ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }
 }

 module.exports={
 WebGL2KernelValueHTMLImage
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/html-image":57}],94:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGL2KernelValueHTMLImage }=require('./html-image');

 class WebGL2KernelValueHTMLVideo extends WebGL2KernelValueHTMLImage {}

 module.exports={
 WebGL2KernelValueHTMLVideo
 };
 },{"../../../utils":114,"./html-image":93}],95:[function(require,module,exports){
 const { WebGLKernelValueInteger }=require('../../web-gl/kernel-value/integer');

 class WebGL2KernelValueInteger extends WebGLKernelValueInteger {
 getSource(value) {
 const variablePrecision=this.getVariablePrecisionString();
 if (this.origin === 'constants') {
return `const ${ variablePrecision } int ${this.id}=${ parseInt(value) };\n`;
 }
 return `uniform ${ variablePrecision } int ${this.id};\n`;
 }

 updateValue(value) {
 if (this.origin === 'constants') return;
 this.kernel.setUniform1i(this.id,this.uploadValue=value);
 }
 }

 module.exports={
 WebGL2KernelValueInteger
 };
 },{"../../web-gl/kernel-value/integer":60}],96:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueMemoryOptimizedNumberTexture }=require('../../web-gl/kernel-value/memory-optimized-number-texture');

 class WebGL2KernelValueMemoryOptimizedNumberTexture extends WebGLKernelValueMemoryOptimizedNumberTexture {
 getSource() {
 const { id,sizeId,textureSize,dimensionsId,dimensions }=this;
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform sampler2D ${id}`,
`${ variablePrecision } ivec2 ${sizeId}=ivec2(${textureSize[0]},${textureSize[1]})`,
`${ variablePrecision } ivec3 ${dimensionsId}=ivec3(${dimensions[0]},${dimensions[1]},${dimensions[2]})`,
 ]);
 }
 }

 module.exports={
 WebGL2KernelValueMemoryOptimizedNumberTexture
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/memory-optimized-number-texture":61}],97:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueNumberTexture }=require('../../web-gl/kernel-value/number-texture');

 class WebGL2KernelValueNumberTexture extends WebGLKernelValueNumberTexture {
 getSource() {
 const { id,sizeId,textureSize,dimensionsId,dimensions }=this;
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${id}`,
`${ variablePrecision } ivec2 ${sizeId}=ivec2(${textureSize[0]},${textureSize[1]})`,
`${ variablePrecision } ivec3 ${dimensionsId}=ivec3(${dimensions[0]},${dimensions[1]},${dimensions[2]})`,
 ]);
 }
 }

 module.exports={
 WebGL2KernelValueNumberTexture
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/number-texture":62}],98:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueSingleArray }=require('../../web-gl/kernel-value/single-array');

 class WebGL2KernelValueSingleArray extends WebGLKernelValueSingleArray {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`${ variablePrecision } ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`${ variablePrecision } ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(value) {
 if (value.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(value.constructor);
return;
 }
 const { context: gl }=this;
 utils.flattenTo(value,this.uploadValue);
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA32F,this.textureSize[0],this.textureSize[1],0,gl.RGBA,gl.FLOAT,this.uploadValue);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGL2KernelValueSingleArray
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/single-array":63}],99:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueSingleArray1DI }=require('../../web-gl/kernel-value/single-array1d-i');

 class WebGL2KernelValueSingleArray1DI extends WebGLKernelValueSingleArray1DI {
 updateValue(value) {
 if (value.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(value.constructor);
return;
 }
 const { context: gl }=this;
 utils.flattenTo(value,this.uploadValue);
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA32F,this.textureSize[0],this.textureSize[1],0,gl.RGBA,gl.FLOAT,this.uploadValue);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGL2KernelValueSingleArray1DI
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/single-array1d-i":64}],100:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueSingleArray2DI }=require('../../web-gl/kernel-value/single-array2d-i');

 class WebGL2KernelValueSingleArray2DI extends WebGLKernelValueSingleArray2DI {
 updateValue(value) {
 if (value.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(value.constructor);
return;
 }
 const { context: gl }=this;
 utils.flattenTo(value,this.uploadValue);
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA32F,this.textureSize[0],this.textureSize[1],0,gl.RGBA,gl.FLOAT,this.uploadValue);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGL2KernelValueSingleArray2DI
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/single-array2d-i":65}],101:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueSingleArray3DI }=require('../../web-gl/kernel-value/single-array3d-i');

 class WebGL2KernelValueSingleArray3DI extends WebGLKernelValueSingleArray3DI {
 updateValue(value) {
 if (value.constructor !== this.initialValueConstructor) {
this.onUpdateValueMismatch(value.constructor);
return;
 }
 const { context: gl }=this;
 utils.flattenTo(value,this.uploadValue);
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA32F,this.textureSize[0],this.textureSize[1],0,gl.RGBA,gl.FLOAT,this.uploadValue);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGL2KernelValueSingleArray3DI
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/single-array3d-i":66}],102:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueSingleInput }=require('../../web-gl/kernel-value/single-input');

 class WebGL2KernelValueSingleInput extends WebGLKernelValueSingleInput {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`${ variablePrecision } ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`${ variablePrecision } ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }

 updateValue(input) {
 const { context: gl }=this;
 utils.flattenTo(input.value,this.uploadValue);
 gl.activeTexture(this.contextHandle);
 gl.bindTexture(gl.TEXTURE_2D,this.texture);
 gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
 gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA32F,this.textureSize[0],this.textureSize[1],0,gl.RGBA,gl.FLOAT,this.uploadValue);
 this.kernel.setUniform1i(this.id,this.index);
 }
 }

 module.exports={
 WebGL2KernelValueSingleInput
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/single-input":67}],103:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueUnsignedArray }=require('../../web-gl/kernel-value/unsigned-array');

 class WebGL2KernelValueUnsignedArray extends WebGLKernelValueUnsignedArray {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`${ variablePrecision } ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`${ variablePrecision } ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }
 }

 module.exports={
 WebGL2KernelValueUnsignedArray
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/unsigned-array":68}],104:[function(require,module,exports){
 const { utils }=require('../../../utils');
 const { WebGLKernelValueUnsignedInput }=require('../../web-gl/kernel-value/unsigned-input');

 class WebGL2KernelValueUnsignedInput extends WebGLKernelValueUnsignedInput {
 getSource() {
 const variablePrecision=this.getVariablePrecisionString();
 return utils.linesToString([
`uniform ${ variablePrecision } sampler2D ${this.id}`,
`${ variablePrecision } ivec2 ${this.sizeId}=ivec2(${this.textureSize[0]},${this.textureSize[1]})`,
`${ variablePrecision } ivec3 ${this.dimensionsId}=ivec3(${this.dimensions[0]},${this.dimensions[1]},${this.dimensions[2]})`,
 ]);
 }
 }

 module.exports={
 WebGL2KernelValueUnsignedInput
 };
 },{"../../../utils":114,"../../web-gl/kernel-value/unsigned-input":69}],105:[function(require,module,exports){
 const { WebGLKernel }=require('../web-gl/kernel');
 const { WebGL2FunctionNode }=require('./function-node');
 const { FunctionBuilder }=require('../function-builder');
 const { utils }=require('../../utils');
 const { fragmentShader }=require('./fragment-shader');
 const { vertexShader }=require('./vertex-shader');
 const { lookupKernelValueType }=require('./kernel-value-maps');

 let isSupported=null;
 let testCanvas=null;
 let testContext=null;
 let testExtensions=null;

 let features=null;

 class WebGL2Kernel extends WebGLKernel {
 static get isSupported() {
 if (isSupported !== null) {
return isSupported;
 }
 this.setupFeatureChecks();
 isSupported=this.isContextMatch(testContext);
 return isSupported;
 }

 static setupFeatureChecks() {
 if (typeof document !== 'undefined') {
testCanvas=document.createElement('canvas');
 } else if (typeof OffscreenCanvas !== 'undefined') {
testCanvas=new OffscreenCanvas(0,0);
 }
 if (!testCanvas) return;
 testContext=testCanvas.getContext('webgl2');
 if (!testContext || !testContext.getExtension) return;
 testExtensions={
EXT_color_buffer_float: testContext.getExtension('EXT_color_buffer_float'),
OES_texture_float_linear: testContext.getExtension('OES_texture_float_linear'),
 };
 features=this.getFeatures();
 }

 static isContextMatch(context) {
 if (typeof WebGL2RenderingContext !== 'undefined') {
return context instanceof WebGL2RenderingContext;
 }
 return false;
 }

 static getFeatures() {
 const gl=this.testContext;
 return Object.freeze({
isFloatRead: this.getIsFloatRead(),
isIntegerDivisionAccurate: this.getIsIntegerDivisionAccurate(),
isSpeedTacticSupported: this.getIsSpeedTacticSupported(),
kernelMap: true,
isTextureFloat: true,
isDrawBuffers: true,
channelCount: this.getChannelCount(),
maxTextureSize: this.getMaxTextureSize(),
lowIntPrecision: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER,gl.LOW_INT),
lowFloatPrecision: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER,gl.LOW_FLOAT),
mediumIntPrecision: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER,gl.MEDIUM_INT),
mediumFloatPrecision: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER,gl.MEDIUM_FLOAT),
highIntPrecision: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER,gl.HIGH_INT),
highFloatPrecision: gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER,gl.HIGH_FLOAT),
 });
 }

 static getIsTextureFloat() {
 return true;
 }

 static getChannelCount() {
 return testContext.getParameter(testContext.MAX_DRAW_BUFFERS);
 }

 static getMaxTextureSize() {
 return testContext.getParameter(testContext.MAX_TEXTURE_SIZE);
 }

 static lookupKernelValueType(type,dynamic,precision,value) {
 return lookupKernelValueType(type,dynamic,precision,value);
 }

 static get testCanvas() {
 return testCanvas;
 }

 static get testContext() {
 return testContext;
 }

 static get features() {
 return features;
 }

 static get fragmentShader() {
 return fragmentShader;
 }
 static get vertexShader() {
 return vertexShader;
 }

 initContext() {
 const settings={
alpha:true,depth:false,stencil:false,imageSmoothingEnabled:false,preserveDrawingBuffer:false,premultipliedAlpha:false,desynchronized:false,lowLatency:true,powerPreference:'high-performance',antialias:false
 };
 return this.canvas.getContext('webgl2',settings);
 }

 initExtensions() {
 this.extensions={
EXT_color_buffer_float: this.context.getExtension('EXT_color_buffer_float'),
OES_texture_float_linear: this.context.getExtension('OES_texture_float_linear'),
 };
 }

 validateSettings(args) {
 if (!this.validate) {
this.texSize=utils.getKernelTextureSize({
optimizeFloatMemory: this.optimizeFloatMemory,
precision: this.precision,
},this.output);
return;
 }

 const { features }=this.constructor;
 if (this.precision === 'single' && !features.isFloatRead) {
throw new Error('Float texture outputs are not supported');
 } else if (!this.graphical && this.precision === null) {
this.precision=features.isFloatRead ? 'single' : 'unsigned';
 }

 if (this.fixIntegerDivisionAccuracy === null) {
this.fixIntegerDivisionAccuracy=!features.isIntegerDivisionAccurate;
 } else if (this.fixIntegerDivisionAccuracy && features.isIntegerDivisionAccurate) {
this.fixIntegerDivisionAccuracy=false;
 }

 this.checkOutput();

 if (!this.output || this.output.length === 0) {
if (args.length !== 1) {
throw new Error('Auto output only supported for kernels with only one input');
}

const argType=utils.getVariableType(args[0],this.strictIntegers);
switch (argType) {
case 'Array':
this.output=utils.getDimensions(argType);
break;
case 'NumberTexture':
case 'MemoryOptimizedNumberTexture':
case 'ArrayTexture(1)':
case 'ArrayTexture(2)':
case 'ArrayTexture(3)':
case 'ArrayTexture(4)':
this.output=args[0].output;
break;
default:
throw new Error('Auto output not supported for input type: ' + argType);
}
 }

 if (this.graphical) {
if (this.output.length !== 2) {
throw new Error('Output must have 2 dimensions on graphical mode');
}

if (this.precision === 'single') {
console.warn('Cannot use graphical mode and single precision at the same time');
this.precision='unsigned';
}

this.texSize=utils.clone(this.output);
return;
 } else if (!this.graphical && this.precision === null && features.isTextureFloat) {
this.precision='single';
 }

 this.texSize=utils.getKernelTextureSize({
optimizeFloatMemory: this.optimizeFloatMemory,
precision: this.precision,
 },this.output);

 this.checkTextureSize();
 }

 translateSource() {
 const functionBuilder=FunctionBuilder.fromKernel(this,WebGL2FunctionNode,{
fixIntegerDivisionAccuracy: this.fixIntegerDivisionAccuracy
 });
 this.translatedSource=functionBuilder.getPrototypeString('kernel');
 this.setupReturnTypes(functionBuilder);
 }

 drawBuffers() {
 this.context.drawBuffers(this.drawBuffersMap);
 }

 getTextureFormat() {
 const { context: gl }=this;
 switch (this.getInternalFormat()) {
case gl.R32F:
return gl.RED;
case gl.RG32F:
return gl.RG;
case gl.RGBA32F:
return gl.RGBA;
case gl.RGBA:
return gl.RGBA;
default:
throw new Error('Unknown internal format');
 }
 }
 getInternalFormat() {
 const { context: gl }=this;

 if (this.precision === 'single') {
if (this.pipeline) {
switch (this.returnType) {
case 'Number':
case 'Float':
case 'Integer':
if (this.optimizeFloatMemory) {
 return gl.RGBA32F;
} else {
 return gl.R32F;
}
case 'Array(2)':
return gl.RG32F;
case 'Array(3)':
case 'Array(4)':
return gl.RGBA32F;
default:
throw new Error('Unhandled return type');
}
}
return gl.RGBA32F;
 }
 return gl.RGBA;
 }

 _setupOutputTexture() {
 const gl=this.context;
 if (this.texture) {
gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,this.texture.texture,0);
return;
 }
 gl.bindFramebuffer(gl.FRAMEBUFFER,this.framebuffer);
 const texture=gl.createTexture();
 const texSize=this.texSize;
 gl.activeTexture(gl.TEXTURE0 + this.constantTextureCount + this.argumentTextureCount);
 gl.bindTexture(gl.TEXTURE_2D,texture);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.REPEAT);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.REPEAT);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.NEAREST);
 gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.NEAREST);
 const format=this.getInternalFormat();
 if (this.precision === 'single') {
gl.texStorage2D(gl.TEXTURE_2D,1,format,texSize[0],texSize[1]);
 } else {
gl.texImage2D(gl.TEXTURE_2D,0,format,texSize[0],texSize[1],0,format,gl.UNSIGNED_BYTE,null);
 }
 gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,texture,0);
 this.texture=new this.TextureConstructor({
texture,
size: texSize,
dimensions: this.threadDim,
output: this.output,
context: this.context,
internalFormat: this.getInternalFormat(),
textureFormat: this.getTextureFormat(),
kernel: this,
 });
 }

 _setupSubOutputTextures() {
 const gl=this.context;
 if (this.mappedTextures) {
for (let i=0; i < this.subKernels.length; i++) {
gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0 + i + 1,gl.TEXTURE_2D,this.mappedTextures[i].texture,0);
}
return;
 }
 const texSize=this.texSize;
 this.drawBuffersMap=[gl.COLOR_ATTACHMENT0];
 this.mappedTextures=[];
 for (let i=0; i < this.subKernels.length; i++) {
const texture=this.createTexture();
this.drawBuffersMap.push(gl.COLOR_ATTACHMENT0 + i + 1);
gl.activeTexture(gl.TEXTURE0 + this.constantTextureCount + this.argumentTextureCount + i);
gl.bindTexture(gl.TEXTURE_2D,texture);
gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.CLAMP_TO_EDGE);
gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.NEAREST);
const format=this.getInternalFormat();
if (this.precision === 'single') {
gl.texStorage2D(gl.TEXTURE_2D,1,format,texSize[0],texSize[1]);
} else {
gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA,texSize[0],texSize[1],0,gl.RGBA,gl.UNSIGNED_BYTE,null);
}
gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0 + i + 1,gl.TEXTURE_2D,texture,0);

this.mappedTextures.push(new this.TextureConstructor({
texture,
size: texSize,
dimensions: this.threadDim,
output: this.output,
context: this.context,
internalFormat: this.getInternalFormat(),
textureFormat: this.getTextureFormat(),
kernel: this,
}));
 }
 }

 _getHeaderString() {
 return '';
 }

 _getTextureCoordinate() {
 const subKernels=this.subKernels;
 const variablePrecision=this.getVariablePrecisionString(this.texSize,this.tactic);
 if (subKernels === null || subKernels.length < 1) {
return `in ${ variablePrecision } vec2 vTexCoord;\n`;
 } else {
return `out ${ variablePrecision } vec2 vTexCoord;\n`;
 }
 }

 _getMainArgumentsString(args) {
 const result=[];
 const argumentNames=this.argumentNames;
 for (let i=0; i < argumentNames.length; i++) {
result.push(this.kernelArguments[i].getSource(args[i]));
 }
 return result.join('');
 }

 getKernelString() {
 const result=[this.getKernelResultDeclaration()];
 const subKernels=this.subKernels;
 if (subKernels !== null) {
result.push(
'layout(location=0) out vec4 data0'
);
switch (this.returnType) {
case 'Number':
case 'Float':
case 'Integer':
for (let i=0; i < subKernels.length; i++) {
const subKernel=subKernels[i];
result.push(
 subKernel.returnType === 'Integer' ?
 `int subKernelResult_${ subKernel.name }=0` :
 `float subKernelResult_${ subKernel.name }=0.0`,
 `layout(location=${ i + 1 }) out vec4 data${ i + 1 }`
);
}
break;
case 'Array(2)':
for (let i=0; i < subKernels.length; i++) {
result.push(
 `vec2 subKernelResult_${ subKernels[i].name }`,
 `layout(location=${ i + 1 }) out vec4 data${ i + 1 }`
);
}
break;
case 'Array(3)':
for (let i=0; i < subKernels.length; i++) {
result.push(
 `vec3 subKernelResult_${ subKernels[i].name }`,
 `layout(location=${ i + 1 }) out vec4 data${ i + 1 }`
);
}
break;
case 'Array(4)':
for (let i=0; i < subKernels.length; i++) {
result.push(
 `vec4 subKernelResult_${ subKernels[i].name }`,
 `layout(location=${ i + 1 }) out vec4 data${ i + 1 }`
);
}
break;
}
 } else {
result.push(
'out vec4 data0'
);
 }

 return utils.linesToString(result) + this.translatedSource;
 }

 getMainResultGraphical() {
 return utils.linesToString([
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
' data0=actualColor',
 ]);
 }

 getMainResultPackedPixels() {
 switch (this.returnType) {
case 'LiteralInteger':
case 'Number':
case 'Integer':
case 'Float':
return this.getMainResultKernelPackedPixels() +
this.getMainResultSubKernelPackedPixels();
default:
throw new Error(`packed output only usable with Numbers,"${this.returnType}" specified`);
 }
 }

 getMainResultKernelPackedPixels() {
 return utils.linesToString([
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
` data0=${this.useLegacyEncoder ? 'legacyEncode32' : 'encode32'}(kernelResult)`
 ]);
 }

 getMainResultSubKernelPackedPixels() {
 const result=[];
 if (!this.subKernels) return '';
 for (let i=0; i < this.subKernels.length; i++) {
const subKernel=this.subKernels[i];
if (subKernel.returnType === 'Integer') {
result.push(
` data${i + 1}=${this.useLegacyEncoder ? 'legacyEncode32' : 'encode32'}(float(subKernelResult_${this.subKernels[i].name}))`
);
} else {
result.push(
` data${i + 1}=${this.useLegacyEncoder ? 'legacyEncode32' : 'encode32'}(subKernelResult_${this.subKernels[i].name})`
);
}
 }
 return utils.linesToString(result);
 }

 getMainResultKernelMemoryOptimizedFloats(result,channel) {
 result.push(
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
` data0.${channel}=kernelResult`
 );
 }

 getMainResultSubKernelMemoryOptimizedFloats(result,channel) {
 if (!this.subKernels) return result;
 for (let i=0; i < this.subKernels.length; i++) {
const subKernel=this.subKernels[i];
if (subKernel.returnType === 'Integer') {
result.push(
` data${i + 1}.${channel}=float(subKernelResult_${subKernel.name})`
);
} else {
result.push(
` data${i + 1}.${channel}=subKernelResult_${subKernel.name}`
);
}
 }
 }

 getMainResultKernelNumberTexture() {
 return [
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
' data0[0]=kernelResult',
 ];
 }

 getMainResultSubKernelNumberTexture() {
 const result=[];
 if (!this.subKernels) return result;
 for (let i=0; i < this.subKernels.length; ++i) {
const subKernel=this.subKernels[i];
if (subKernel.returnType === 'Integer') {
result.push(
` data${i + 1}[0]=float(subKernelResult_${subKernel.name})`
);
} else {
result.push(
` data${i + 1}[0]=subKernelResult_${subKernel.name}`
);
}
 }
 return result;
 }

 getMainResultKernelArray2Texture() {
 return [
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
' data0[0]=kernelResult[0]',
' data0[1]=kernelResult[1]',
 ];
 }

 getMainResultSubKernelArray2Texture() {
 const result=[];
 if (!this.subKernels) return result;
 for (let i=0; i < this.subKernels.length; ++i) {
const subKernel=this.subKernels[i];
result.push(
` data${i + 1}[0]=subKernelResult_${subKernel.name}[0]`,
` data${i + 1}[1]=subKernelResult_${subKernel.name}[1]`
);
 }
 return result;
 }

 getMainResultKernelArray3Texture() {
 return [
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
' data0[0]=kernelResult[0]',
' data0[1]=kernelResult[1]',
' data0[2]=kernelResult[2]',
 ];
 }

 getMainResultSubKernelArray3Texture() {
 const result=[];
 if (!this.subKernels) return result;
 for (let i=0; i < this.subKernels.length; ++i) {
const subKernel=this.subKernels[i];
result.push(
` data${i + 1}[0]=subKernelResult_${subKernel.name}[0]`,
` data${i + 1}[1]=subKernelResult_${subKernel.name}[1]`,
` data${i + 1}[2]=subKernelResult_${subKernel.name}[2]`
);
 }
 return result;
 }

 getMainResultKernelArray4Texture() {
 return [
' threadId=indexTo3D(index,uOutputDim)',
' kernel()',
' data0=kernelResult',
 ];
 }

 getMainResultSubKernelArray4Texture() {
 const result=[];
 if (!this.subKernels) return result;
 for (let i=0; i < this.subKernels.length; ++i) {
result.push(
` data${i + 1}=subKernelResult_${this.subKernels[i].name}`
);
 }
 return result;
 }

 destroyExtensions() {
 this.extensions.EXT_color_buffer_float=null;
 this.extensions.OES_texture_float_linear=null;
 }

 toJSON() {
 const json=super.toJSON();
 json.functionNodes=FunctionBuilder.fromKernel(this,WebGL2FunctionNode).toJSON();
 json.settings.threadDim=this.threadDim;
 return json;
 }
 }

 module.exports={
 WebGL2Kernel
 };
 },{"../../utils":114,"../function-builder":9,"../web-gl/kernel":70,"./fragment-shader":72,"./function-node":73,"./kernel-value-maps":74,"./vertex-shader":106}],106:[function(require,module,exports){
 const vertexShader=`#version 300 es
__FLOAT_TACTIC_DECLARATION__;
__INT_TACTIC_DECLARATION__;
__SAMPLER_2D_TACTIC_DECLARATION__;

in vec2 aPos;
in vec2 aTexCoord;

out vec2 vTexCoord;
uniform vec2 ratio;

void main(void) {
 gl_Position=vec4((aPos + vec2(1)) * ratio + vec2(-1),0,1);
 vTexCoord=aTexCoord;
}`;

 module.exports={
 vertexShader
 };
 },{}],107:[function(require,module,exports){
 const lib=require('./index');
 const GPU=lib.GPU;
 for (const p in lib) {
 if (!lib.hasOwnProperty(p)) continue;
 if (p === 'GPU') continue;
 GPU[p]=lib[p];
 }

 if (typeof window !== 'undefined') {
 bindTo(window);
 }
 if (typeof self !== 'undefined') {
 bindTo(self);
 }

 function bindTo(target) {
 if (target.GPU) return;
 Object.defineProperty(target,'GPU',{
 get() {
return GPU;
 }
 });
 }

 module.exports=lib;
 },{"./index":109}],108:[function(require,module,exports){
 const { gpuMock }=require('gpu-mock.js');
 const { utils }=require('./utils');
 const { Kernel }=require('./backend/kernel');
 const { CPUKernel }=require('./backend/cpu/kernel');
 const { HeadlessGLKernel }=require('./backend/headless-gl/kernel');
 const { WebGL2Kernel }=require('./backend/web-gl2/kernel');
 const { WebGLKernel }=require('./backend/web-gl/kernel');
 const { kernelRunShortcut }=require('./kernel-run-shortcut');


 const kernelOrder=[HeadlessGLKernel,WebGL2Kernel,WebGLKernel];

 const kernelTypes=['gpu','cpu'];

 const internalKernels={
 'headlessgl': HeadlessGLKernel,
 'webgl2': WebGL2Kernel,
 'webgl': WebGLKernel,
 };

 let validate=true;

 class GPU {
 static disableValidation() {
 validate=false;
 }

 static enableValidation() {
 validate=true;
 }

 static get isGPUSupported() {
 return kernelOrder.some(Kernel => Kernel.isSupported);
 }

 static get isKernelMapSupported() {
 return kernelOrder.some(Kernel => Kernel.isSupported && Kernel.features.kernelMap);
 }

 static get isOffscreenCanvasSupported() {
 return (typeof Worker !== 'undefined' && typeof OffscreenCanvas !== 'undefined') || typeof importScripts !== 'undefined';
 }

 static get isWebGLSupported() {
 return WebGLKernel.isSupported;
 }

 static get isWebGL2Supported() {
 return WebGL2Kernel.isSupported;
 }

 static get isHeadlessGLSupported() {
 return HeadlessGLKernel.isSupported;
 }

 static get isCanvasSupported() {
 return typeof HTMLCanvasElement !== 'undefined';
 }

 static get isGPUHTMLImageArraySupported() {
 return WebGL2Kernel.isSupported;
 }

 static get isSinglePrecisionSupported() {
 return kernelOrder.some(Kernel => Kernel.isSupported && Kernel.features.isFloatRead && Kernel.features.isTextureFloat);
 }

 constructor(settings) {
 settings=settings || {};
 this.canvas=settings.canvas || null;
 this.context=settings.context || null;
 this.mode=settings.mode;
 this.Kernel=null;
 this.kernels=[];
 this.functions=[];
 this.nativeFunctions=[];
 this.injectedNative=null;
 if (this.mode === 'dev') return;
 this.chooseKernel();
 if (settings.functions) {
for (let i=0; i < settings.functions.length; i++) {
this.addFunction(settings.functions[i]);
}
 }

 if (settings.nativeFunctions) {
for (const p in settings.nativeFunctions) {
if (!settings.nativeFunctions.hasOwnProperty(p)) continue;
const s=settings.nativeFunctions[p];
const { name,source }=s;
this.addNativeFunction(name,source,s);
}
 }
 }

 chooseKernel() {
 if (this.Kernel) return;

 let Kernel=null;

 if (this.context) {
for (let i=0; i < kernelOrder.length; i++) {
const ExternalKernel=kernelOrder[i];
if (ExternalKernel.isContextMatch(this.context)) {
if (!ExternalKernel.isSupported) {
throw new Error(`Kernel type ${ExternalKernel.name} not supported`);
}
Kernel=ExternalKernel;
break;
}
}
if (Kernel === null) {
throw new Error('unknown Context');
}
 } else if (this.mode) {
if (this.mode in internalKernels) {
if (!validate || internalKernels[this.mode].isSupported) {
Kernel=internalKernels[this.mode];
}
} else if (this.mode === 'gpu') {
for (let i=0; i < kernelOrder.length; i++) {
if (kernelOrder[i].isSupported) {
Kernel=kernelOrder[i];
break;
}
}
} else if (this.mode === 'cpu') {
Kernel=CPUKernel;
}
if (!Kernel) {
throw new Error(`A requested mode of "${this.mode}" and is not supported`);
}
 } else {
for (let i=0; i < kernelOrder.length; i++) {
if (kernelOrder[i].isSupported) {
Kernel=kernelOrder[i];
break;
}
}
if (!Kernel) {
Kernel=CPUKernel;
}
 }

 if (!this.mode) {
this.mode=Kernel.mode;
 }
 this.Kernel=Kernel;
 }

 createKernel(source,settings) {
 if (typeof source === 'undefined') {
throw new Error('Missing source parameter');
 }
 if (typeof source !== 'object' && !utils.isFunction(source) && typeof source !== 'string') {
throw new Error('source parameter not a function');
 }

 const kernels=this.kernels;
 if (this.mode === 'dev') {
const devKernel=gpuMock(source,upgradeDeprecatedCreateKernelSettings(settings));
kernels.push(devKernel);
return devKernel;
 }

 source=typeof source === 'function' ? source.toString() : source;
 const switchableKernels={};
 const settingsCopy=upgradeDeprecatedCreateKernelSettings(settings) || {};
 if (settings && typeof settings.argumentTypes === 'object') {
settingsCopy.argumentTypes=Object.keys(settings.argumentTypes).map(argumentName => settings.argumentTypes[argumentName]);
 }

 function onRequestFallback(args) {
console.warn('Falling back to CPU');
const fallbackKernel=new CPUKernel(source,{
argumentTypes: kernelRun.argumentTypes,
constantTypes: kernelRun.constantTypes,
graphical: kernelRun.graphical,
loopMaxIterations: kernelRun.loopMaxIterations,
constants: kernelRun.constants,
dynamicOutput: kernelRun.dynamicOutput,
dynamicArgument: kernelRun.dynamicArguments,
output: kernelRun.output,
precision: kernelRun.precision,
pipeline: kernelRun.pipeline,
immutable: kernelRun.immutable,
optimizeFloatMemory: kernelRun.optimizeFloatMemory,
fixIntegerDivisionAccuracy: kernelRun.fixIntegerDivisionAccuracy,
functions: kernelRun.functions,
nativeFunctions: kernelRun.nativeFunctions,
injectedNative: kernelRun.injectedNative,
subKernels: kernelRun.subKernels,
strictIntegers: kernelRun.strictIntegers,
debug: kernelRun.debug,
});
fallbackKernel.build.apply(fallbackKernel,args);
const result=fallbackKernel.run.apply(fallbackKernel,args);
kernelRun.replaceKernel(fallbackKernel);
return result;
 }

 function onRequestSwitchKernel(reasons,args,_kernel) {
if (_kernel.debug) {
console.warn('Switching kernels');
}
let newOutput=null;
if (_kernel.signature && !switchableKernels[_kernel.signature]) {
switchableKernels[_kernel.signature]=_kernel;
}
if (_kernel.dynamicOutput) {
for (let i=reasons.length - 1; i >= 0; i--) {
const reason=reasons[i];
if (reason.type === 'outputPrecisionMismatch') {
newOutput=reason.needed;
}
}
}

const Constructor=_kernel.constructor;
const argumentTypes=Constructor.getArgumentTypes(_kernel,args);
const signature=Constructor.getSignature(_kernel,argumentTypes);
const existingKernel=switchableKernels[signature];
if (existingKernel) {
existingKernel.onActivate(_kernel);
return existingKernel;
}

const newKernel=switchableKernels[signature]=new Constructor(source,{
argumentTypes,
constantTypes: _kernel.constantTypes,
graphical: _kernel.graphical,
loopMaxIterations: _kernel.loopMaxIterations,
constants: _kernel.constants,
dynamicOutput: _kernel.dynamicOutput,
dynamicArgument: _kernel.dynamicArguments,
context: _kernel.context,
canvas: _kernel.canvas,
output: newOutput || _kernel.output,
precision: _kernel.precision,
pipeline: _kernel.pipeline,
immutable: _kernel.immutable,
optimizeFloatMemory: _kernel.optimizeFloatMemory,
fixIntegerDivisionAccuracy: _kernel.fixIntegerDivisionAccuracy,
functions: _kernel.functions,
nativeFunctions: _kernel.nativeFunctions,
injectedNative: _kernel.injectedNative,
subKernels: _kernel.subKernels,
strictIntegers: _kernel.strictIntegers,
debug: _kernel.debug,
gpu: _kernel.gpu,
validate,
returnType: _kernel.returnType,
tactic: _kernel.tactic,
onRequestFallback,
onRequestSwitchKernel,
texture: _kernel.texture,
mappedTextures: _kernel.mappedTextures,
drawBuffersMap: _kernel.drawBuffersMap,
});
newKernel.build.apply(newKernel,args);
kernelRun.replaceKernel(newKernel);
kernels.push(newKernel);
return newKernel;
 }
 const mergedSettings=Object.assign({
context: this.context,
canvas: this.canvas,
functions: this.functions,
nativeFunctions: this.nativeFunctions,
injectedNative: this.injectedNative,
gpu: this,
validate,
onRequestFallback,
onRequestSwitchKernel
 },settingsCopy);

 const kernel=new this.Kernel(source,mergedSettings);
 const kernelRun=kernelRunShortcut(kernel);

 if (!this.canvas) {
this.canvas=kernel.canvas;
 }

 if (!this.context) {
this.context=kernel.context;
 }

 kernels.push(kernel);

 return kernelRun;
 }

 createKernelMap() {
 let fn;
 let settings;
 const argument2Type=typeof arguments[arguments.length - 2];
 if (argument2Type === 'function' || argument2Type === 'string') {
fn=arguments[arguments.length - 2];
settings=arguments[arguments.length - 1];
 } else {
fn=arguments[arguments.length - 1];
 }

 if (this.mode !== 'dev') {
if (!this.Kernel.isSupported || !this.Kernel.features.kernelMap) {
if (this.mode && kernelTypes.indexOf(this.mode) < 0) {
throw new Error(`kernelMap not supported on ${this.Kernel.name}`);
}
}
 }

 const settingsCopy=upgradeDeprecatedCreateKernelSettings(settings);
 if (settings && typeof settings.argumentTypes === 'object') {
settingsCopy.argumentTypes=Object.keys(settings.argumentTypes).map(argumentName => settings.argumentTypes[argumentName]);
 }

 if (Array.isArray(arguments[0])) {
settingsCopy.subKernels=[];
const functions=arguments[0];
for (let i=0; i < functions.length; i++) {
const source=functions[i].toString();
const name=utils.getFunctionNameFromString(source);
settingsCopy.subKernels.push({
name,
source,
property: i,
});
}
 } else {
settingsCopy.subKernels=[];
const functions=arguments[0];
for (let p in functions) {
if (!functions.hasOwnProperty(p)) continue;
const source=functions[p].toString();
const name=utils.getFunctionNameFromString(source);
settingsCopy.subKernels.push({
name: name || p,
source,
property: p,
});
}
 }
 return this.createKernel(fn,settingsCopy);
 }

 combineKernels() {
 const firstKernel=arguments[0];
 const combinedKernel=arguments[arguments.length - 1];
 if (firstKernel.kernel.constructor.mode === 'cpu') return combinedKernel;
 const canvas=arguments[0].canvas;
 const context=arguments[0].context;
 const max=arguments.length - 1;
 for (let i=0; i < max; i++) {
arguments[i]
.setCanvas(canvas)
.setContext(context)
.setPipeline(true);
 }

 return function() {
const texture=combinedKernel.apply(this,arguments);
if (texture.toArray) {
return texture.toArray();
}
return texture;
 };
 }

 setFunctions(functions) {
 this.functions=functions;
 return this;
 }

 setNativeFunctions(nativeFunctions) {
 this.nativeFunctions=nativeFunctions;
 return this;
 }

 addFunction(source,settings) {
 this.functions.push({ source,settings });
 return this;
 }

 addNativeFunction(name,source,settings) {
 if (this.kernels.length > 0) {
throw new Error('Cannot call "addNativeFunction" after "createKernels" has been called.');
 }
 this.nativeFunctions.push(Object.assign({ name,source },settings));
 return this;
 }

 injectNative(source) {
 this.injectedNative=source;
 return this;
 }

 destroy() {
 return new Promise((resolve,reject) => {
if (!this.kernels) {
resolve();
}
setTimeout(() => {
try {
for (let i=0; i < this.kernels.length; i++) {
this.kernels[i].destroy(true);
}
let firstKernel=this.kernels[0];
if (firstKernel) {
if (firstKernel.kernel) {
 firstKernel=firstKernel.kernel;
}
if (firstKernel.constructor.destroyContext) {
 firstKernel.constructor.destroyContext(this.context);
}
}
} catch (e) {
reject(e);
}
resolve();
},0);
 });
 }
 }


 function upgradeDeprecatedCreateKernelSettings(settings) {
 if (!settings) {
 return {};
 }
 const upgradedSettings=Object.assign({},settings);

 if (settings.hasOwnProperty('floatOutput')) {
 utils.warnDeprecated('setting','floatOutput','precision');
 upgradedSettings.precision=settings.floatOutput ? 'single' : 'unsigned';
 }
 if (settings.hasOwnProperty('outputToTexture')) {
 utils.warnDeprecated('setting','outputToTexture','pipeline');
 upgradedSettings.pipeline=Boolean(settings.outputToTexture);
 }
 if (settings.hasOwnProperty('outputImmutable')) {
 utils.warnDeprecated('setting','outputImmutable','immutable');
 upgradedSettings.immutable=Boolean(settings.outputImmutable);
 }
 if (settings.hasOwnProperty('floatTextures')) {
 utils.warnDeprecated('setting','floatTextures','optimizeFloatMemory');
 upgradedSettings.optimizeFloatMemory=Boolean(settings.floatTextures);
 }
 return upgradedSettings;
 }

 module.exports={
 GPU,
 kernelOrder,
 kernelTypes
 };
 },{"./backend/cpu/kernel":8,"./backend/headless-gl/kernel":34,"./backend/kernel":36,"./backend/web-gl/kernel":70,"./backend/web-gl2/kernel":105,"./kernel-run-shortcut":111,"./utils":114,"gpu-mock.js":4}],109:[function(require,module,exports){
 const { GPU }=require('./gpu');
 const { alias }=require('./alias');
 const { utils }=require('./utils');
 const { Input,input }=require('./input');
 const { Texture }=require('./texture');
 const { FunctionBuilder }=require('./backend/function-builder');
 const { FunctionNode }=require('./backend/function-node');
 const { CPUFunctionNode }=require('./backend/cpu/function-node');
 const { CPUKernel }=require('./backend/cpu/kernel');

 const { HeadlessGLKernel }=require('./backend/headless-gl/kernel');

 const { WebGLFunctionNode }=require('./backend/web-gl/function-node');
 const { WebGLKernel }=require('./backend/web-gl/kernel');
 const { kernelValueMaps: webGLKernelValueMaps }=require('./backend/web-gl/kernel-value-maps');

 const { WebGL2FunctionNode }=require('./backend/web-gl2/function-node');
 const { WebGL2Kernel }=require('./backend/web-gl2/kernel');
 const { kernelValueMaps: webGL2KernelValueMaps }=require('./backend/web-gl2/kernel-value-maps');

 const { GLKernel }=require('./backend/gl/kernel');

 const { Kernel }=require('./backend/kernel');

 const { FunctionTracer }=require('./backend/function-tracer');

 const mathRandom=require('./plugins/math-random-uniformly-distributed');

 module.exports={
 alias,
 CPUFunctionNode,
 CPUKernel,
 GPU,
 FunctionBuilder,
 FunctionNode,
 HeadlessGLKernel,
 Input,
 input,
 Texture,
 utils,

 WebGL2FunctionNode,
 WebGL2Kernel,
 webGL2KernelValueMaps,

 WebGLFunctionNode,
 WebGLKernel,
 webGLKernelValueMaps,

 GLKernel,
 Kernel,
 FunctionTracer,

 plugins: {
 mathRandom
 }
 };
 },{"./alias":5,"./backend/cpu/function-node":6,"./backend/cpu/kernel":8,"./backend/function-builder":9,"./backend/function-node":10,"./backend/function-tracer":11,"./backend/gl/kernel":13,"./backend/headless-gl/kernel":34,"./backend/kernel":36,"./backend/web-gl/function-node":38,"./backend/web-gl/kernel":70,"./backend/web-gl/kernel-value-maps":39,"./backend/web-gl2/function-node":73,"./backend/web-gl2/kernel":105,"./backend/web-gl2/kernel-value-maps":74,"./gpu":108,"./input":110,"./plugins/math-random-uniformly-distributed":112,"./texture":113,"./utils":114}],110:[function(require,module,exports){
 class Input {
 constructor(value,size) {
 this.value=value;
 if (Array.isArray(size)) {
this.size=size;
 } else {
this.size=new Int32Array(3);
if (size.z) {
this.size=new Int32Array([size.x,size.y,size.z]);
} else if (size.y) {
this.size=new Int32Array([size.x,size.y]);
} else {
this.size=new Int32Array([size.x]);
}
 }

 const [w,h,d]=this.size;
 if (d) {
if (this.value.length !== (w * h * d)) {
throw new Error(`Input size ${this.value.length} does not match ${w} * ${h} * ${d}=${(h * w * d)}`);
}
 } else if (h) {
if (this.value.length !== (w * h)) {
throw new Error(`Input size ${this.value.length} does not match ${w} * ${h}=${(h * w)}`);
}
 } else {
if (this.value.length !== w) {
throw new Error(`Input size ${this.value.length} does not match ${w}`);
}
 }

 }

 toArray() {
 const { utils }=require('./utils');
 const [w,h,d]=this.size;
 if (d) {
return utils.erectMemoryOptimized3DFloat(this.value.subarray ? this.value : new Float32Array(this.value),w,h,d);
 } else if (h) {
return utils.erectMemoryOptimized2DFloat(this.value.subarray ? this.value : new Float32Array(this.value),w,h);
 } else {
return this.value;
 }
 }
 }

 function input(value,size) {
 return new Input(value,size);
 }

 module.exports={
 Input,
 input
 };
 },{"./utils":114}],111:[function(require,module,exports){
 const { utils }=require('./utils');

 function kernelRunShortcut(kernel) {
 let run=function() {
 kernel.build.apply(kernel,arguments);
 run=function() {
let result=kernel.run.apply(kernel,arguments);
if (kernel.switchingKernels) {
const reasons=kernel.resetSwitchingKernels();
const newKernel=kernel.onRequestSwitchKernel(reasons,arguments,kernel);
shortcut.kernel=kernel=newKernel;
result=newKernel.run.apply(newKernel,arguments);
}
if (kernel.renderKernels) {
return kernel.renderKernels();
} else if (kernel.renderOutput) {
return kernel.renderOutput();
} else {
return result;
}
 };
 return run.apply(kernel,arguments);
 };
 const shortcut=function() {
 return run.apply(kernel,arguments);
 };
 shortcut.exec=function() {
 return new Promise((accept,reject) => {
try {
accept(run.apply(this,arguments));
} catch (e) {
reject(e);
}
 });
 };
 shortcut.replaceKernel=function(replacementKernel) {
 kernel=replacementKernel;
 bindKernelToShortcut(kernel,shortcut);
 };

 bindKernelToShortcut(kernel,shortcut);
 return shortcut;
 }

 function bindKernelToShortcut(kernel,shortcut) {
 if (shortcut.kernel) {
 shortcut.kernel=kernel;
 return;
 }
 const properties=utils.allPropertiesOf(kernel);
 for (let i=0; i < properties.length; i++) {
 const property=properties[i];
 if (property[0] === '_' && property[1] === '_') continue;
 if (typeof kernel[property] === 'function') {
if (property.substring(0,3) === 'add' || property.substring(0,3) === 'set') {
shortcut[property]=function() {
shortcut.kernel[property].apply(shortcut.kernel,arguments);
return shortcut;
};
} else {
shortcut[property]=function() {
return shortcut.kernel[property].apply(shortcut.kernel,arguments);
};
}
 } else {
shortcut.__defineGetter__(property,() => shortcut.kernel[property]);
shortcut.__defineSetter__(property,(value) => {
shortcut.kernel[property]=value;
});
 }
 }
 shortcut.kernel=kernel;
 }
 module.exports={
 kernelRunShortcut
 };
 },{"./utils":114}],112:[function(require,module,exports){
 const source=`// https://www.shadertoy.com/view/4t2SDh
//note: uniformly distributed,normalized rand,[0,1]
highp float randomSeedShift=1.0;
highp float slide=1.0;
uniform highp float randomSeed1;
uniform highp float randomSeed2;

highp float nrand(highp vec2 n) {
 highp float result=fract(sin(dot((n.xy + 1.0) * vec2(randomSeed1 * slide,randomSeed2 * randomSeedShift),vec2(12.9898,78.233))) * 43758.5453);
 randomSeedShift=result;
 if (randomSeedShift > 0.5) {
 slide += 0.00009; 
 } else {
 slide += 0.0009;
 }
 return result;
}`;

 const name='math-random-uniformly-distributed';

 const functionMatch=`Math.random()`;

 const functionReplace=`nrand(vTexCoord)`;

 const functionReturnType='Number';
 const onBeforeRun=(kernel) => {
 kernel.setUniform1f('randomSeed1',Math.random());
 kernel.setUniform1f('randomSeed2',Math.random());
 };

 const plugin={
 name,
 onBeforeRun,
 functionMatch,
 functionReplace,
 functionReturnType,
 source
 };

 module.exports=plugin;
 },{}],113:[function(require,module,exports){
 class Texture {
 constructor(settings) {
 const {
texture,
size,
dimensions,
output,
context,
type='NumberTexture',
kernel,
internalFormat,
textureFormat
 }=settings;
 if (!output) throw new Error('settings property "output" required.');
 if (!context) throw new Error('settings property "context" required.');
 if (!texture) throw new Error('settings property "texture" required.');
 if (!kernel) throw new Error('settings property "kernel" required.');
 this.texture=texture;
 if (texture._refs) {
texture._refs++;
 } else {
texture._refs=1;
 }
 this.size=size;
 this.dimensions=dimensions;
 this.output=output;
 this.context=context;
 this.kernel=kernel;
 this.type=type;
 this._deleted=false;
 this.internalFormat=internalFormat;
 this.textureFormat=textureFormat;
 }

 toArray() {
 throw new Error(`Not implemented on ${this.constructor.name}`);
 }

 clone() {
 throw new Error(`Not implemented on ${this.constructor.name}`);
 }

 delete() {
 throw new Error(`Not implemented on ${this.constructor.name}`);
 }

 clear() {
 throw new Error(`Not implemented on ${this.constructor.name}`);
 }
 }

 module.exports={
 Texture
 };
 },{}],114:[function(require,module,exports){
 const acorn=require('acorn');
 const { Input }=require('./input');
 const { Texture }=require('./texture');

 const FUNCTION_NAME=/function ([^(]*)/;
 const STRIP_COMMENTS=/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
 const ARGUMENT_NAMES=/([^\s,]+)/g;

 const utils={
 systemEndianness() {
 return _systemEndianness;
 },
 getSystemEndianness() {
 const b=new ArrayBuffer(4);
 const a=new Uint32Array(b);
 const c=new Uint8Array(b);
 a[0]=0xdeadbeef;
 if (c[0] === 0xef) return 'LE';
 if (c[0] === 0xde) return 'BE';
 throw new Error('unknown endianness');
 },

 isFunction(funcObj) {
 return typeof(funcObj) === 'function';
 },

 isFunctionString(fn) {
 if (typeof fn === 'string') {
return (fn
.slice(0,'function'.length)
.toLowerCase() === 'function');
 }
 return false;
 },

 getFunctionNameFromString(funcStr) {
 const result=FUNCTION_NAME.exec(funcStr);
 if (!result || result.length === 0) return null;
 return result[1].trim();
 },

 getFunctionBodyFromString(funcStr) {
 return funcStr.substring(funcStr.indexOf('{') + 1,funcStr.lastIndexOf('}'));
 },

 getArgumentNamesFromString(fn) {
 const fnStr=fn.replace(STRIP_COMMENTS,'');
 let result=fnStr.slice(fnStr.indexOf('(') + 1,fnStr.indexOf(')')).match(ARGUMENT_NAMES);
 if (result === null) {
result=[];
 }
 return result;
 },

 clone(obj) {
 if (obj === null || typeof obj !== 'object' || obj.hasOwnProperty('isActiveClone')) return obj;

 const temp=obj.constructor();

 for (let key in obj) {
if (Object.prototype.hasOwnProperty.call(obj,key)) {
obj.isActiveClone=null;
temp[key]=utils.clone(obj[key]);
delete obj.isActiveClone;
}
 }

 return temp;
 },

 isArray(array) {
 return !isNaN(array.length);
 },

 getVariableType(value,strictIntegers) {
 if (utils.isArray(value)) {
if (value.length > 0 && value[0].nodeName === 'IMG') {
return 'HTMLImageArray';
}
return 'Array';
 }

 switch (value.constructor) {
case Boolean:
return 'Boolean';
case Number:
if (strictIntegers && Number.isInteger(value)) {
return 'Integer';
}
return 'Float';
case Texture:
return value.type;
case Input:
return 'Input';
case OffscreenCanvas:
return 'OffscreenCanvas';
case ImageBitmap:
return 'ImageBitmap';
case ImageData:
return 'ImageData';
 }
 switch (value.nodeName) {
case 'IMG':
return 'HTMLImage';
case 'CANVAS':
return 'HTMLImage';
case 'VIDEO':
return 'HTMLVideo';
 }
 if (value.hasOwnProperty('type')) {
return value.type;
 }
 return 'Unknown';
 },

 getKernelTextureSize(settings,dimensions) {
 let [w,h,d]=dimensions;
 let texelCount=(w || 1) * (h || 1) * (d || 1);

 if (settings.optimizeFloatMemory && settings.precision === 'single') {
w=texelCount=Math.ceil(texelCount / 4);
 }
 if (h > 1 && w * h === texelCount) {
return new Int32Array([w,h]);
 }
 return utils.closestSquareDimensions(texelCount);
 },

 closestSquareDimensions(length) {
 const sqrt=Math.sqrt(length);
 let high=Math.ceil(sqrt);
 let low=Math.floor(sqrt);
 while (high * low < length) {
high--;
low=Math.ceil(length / high);
 }
 return new Int32Array([low,Math.ceil(length / low)]);
 },

 getMemoryOptimizedFloatTextureSize(dimensions,bitRatio) {
 const totalArea=utils.roundTo((dimensions[0] || 1) * (dimensions[1] || 1) * (dimensions[2] || 1) * (dimensions[3] || 1),4);
 const texelCount=totalArea / bitRatio;
 return utils.closestSquareDimensions(texelCount);
 },

 getMemoryOptimizedPackedTextureSize(dimensions,bitRatio) {
 const [w,h,d]=dimensions;
 const totalArea=utils.roundTo((w || 1) * (h || 1) * (d || 1),4);
 const texelCount=totalArea / (4 / bitRatio);
 return utils.closestSquareDimensions(texelCount);
 },

 roundTo(n,d) {
 return Math.floor((n + d - 1) / d) * d;
 },
 getDimensions(x,pad) {
 let ret;
 if (utils.isArray(x)) {
const dim=[];
let temp=x;
while (utils.isArray(temp)) {
dim.push(temp.length);
temp=temp[0];
}
ret=dim.reverse();
 } else if (x instanceof Texture) {
ret=x.output;
 } else if (x instanceof Input) {
ret=x.size;
 } else {
throw new Error(`Unknown dimensions of ${x}`);
 }

 if (pad) {
ret=Array.from(ret);
while (ret.length < 3) {
ret.push(1);
}
 }

 return new Int32Array(ret);
 },

 flatten2dArrayTo(array,target) {
 let offset=0;
 for (let y=0; y < array.length; y++) {
target.set(array[y],offset);
offset += array[y].length;
 }
 },

 flatten3dArrayTo(array,target) {
 let offset=0;
 for (let z=0; z < array.length; z++) {
for (let y=0; y < array[z].length; y++) {
target.set(array[z][y],offset);
offset += array[z][y].length;
}
 }
 },

 flatten4dArrayTo(array,target) {
 let offset=0;
 for (let l=0; l < array.length; l++) {
for (let z=0; z < array[l].length; z++) {
for (let y=0; y < array[l][z].length; y++) {
target.set(array[l][z][y],offset);
offset += array[l][z][y].length;
}
}
 }
 },

 flattenTo(array,target) {
 if (utils.isArray(array[0])) {
if (utils.isArray(array[0][0])) {
if (utils.isArray(array[0][0][0])) {
utils.flatten4dArrayTo(array,target);
} else {
utils.flatten3dArrayTo(array,target);
}
} else {
utils.flatten2dArrayTo(array,target);
}
 } else {
target.set(array);
 }
 },

 splitArray(array,part) {
 const result=[];
 for (let i=0; i < array.length; i += part) {
result.push(new array.constructor(array.buffer,i * 4 + array.byteOffset,part));
 }
 return result;
 },

 getAstString(source,ast) {
 const lines=Array.isArray(source) ? source : source.split(/\r?\n/g);
 const start=ast.loc.start;
 const end=ast.loc.end;
 const result=[];
 if (start.line === end.line) {
result.push(lines[start.line - 1].substring(start.column,end.column));
 } else {
result.push(lines[start.line - 1].slice(start.column));
for (let i=start.line; i < end.line; i++) {
result.push(lines[i]);
}
result.push(lines[end.line - 1].slice(0,end.column));
 }
 return result.join('\n');
 },

 allPropertiesOf(obj) {
 const props=[];

 do {
props.push.apply(props,Object.getOwnPropertyNames(obj));
 } while (obj=Object.getPrototypeOf(obj));

 return props;
 },

 linesToString(lines) {
 if (lines.length > 0) {
return lines.join(';\n') + ';\n';
 } else {
return '\n';
 }
 },
 warnDeprecated(type,oldName,newName) {
 if (newName) {
console.warn(`You are using a deprecated ${ type } "${ oldName }". It has been replaced with "${ newName }". Fixing,but please upgrade as it will soon be removed.`);
 } else {
console.warn(`You are using a deprecated ${ type } "${ oldName }". It has been removed. Fixing,but please upgrade as it will soon be removed.`);
 }
 },
 flipPixels: (pixels,width,height) => {
 const halfHeight=height / 2 | 0;
 const bytesPerRow=width * 4;
 const temp=new Uint8ClampedArray(width * 4);
 const result=pixels.slice(0);
 for (let y=0; y < halfHeight; ++y) {
const topOffset=y * bytesPerRow;
const bottomOffset=(height - y - 1) * bytesPerRow;

temp.set(result.subarray(topOffset,topOffset + bytesPerRow));

result.copyWithin(topOffset,bottomOffset,bottomOffset + bytesPerRow);

result.set(temp,bottomOffset);
 }
 return result;
 },
 erectPackedFloat: (array,width) => {
 return array.subarray(0,width);
 },
 erect2DPackedFloat: (array,width,height) => {
 const yResults=new Array(height);
 for (let y=0; y < height; y++) {
const xStart=y * width;
const xEnd=xStart + width;
yResults[y]=array.subarray(xStart,xEnd);
 }
 return yResults;
 },
 erect3DPackedFloat: (array,width,height,depth) => {
 const zResults=new Array(depth);
 for (let z=0; z < depth; z++) {
const yResults=new Array(height);
for (let y=0; y < height; y++) {
const xStart=(z * height * width) + y * width;
const xEnd=xStart + width;
yResults[y]=array.subarray(xStart,xEnd);
}
zResults[z]=yResults;
 }
 return zResults;
 },
 erectMemoryOptimizedFloat: (array,width) => {
 return array.subarray(0,width);
 },
 erectMemoryOptimized2DFloat: (array,width,height) => {
 const yResults=new Array(height);
 for (let y=0; y < height; y++) {
const offset=y * width;
yResults[y]=array.subarray(offset,offset + width);
 }
 return yResults;
 },
 erectMemoryOptimized3DFloat: (array,width,height,depth) => {
 const zResults=new Array(depth);
 for (let z=0; z < depth; z++) {
const yResults=new Array(height);
for (let y=0; y < height; y++) {
const offset=(z * height * width) + (y * width);
yResults[y]=array.subarray(offset,offset + width);
}
zResults[z]=yResults;
 }
 return zResults;
 },
 erectFloat: (array,width) => {
 const xResults=new Float32Array(width);
 let i=0;
 for (let x=0; x < width; x++) {
xResults[x]=array[i];
i += 4;
 }
 return xResults;
 },
 erect2DFloat: (array,width,height) => {
 const yResults=new Array(height);
 let i=0;
 for (let y=0; y < height; y++) {
const xResults=new Float32Array(width);
for (let x=0; x < width; x++) {
xResults[x]=array[i];
i += 4;
}
yResults[y]=xResults;
 }
 return yResults;
 },
 erect3DFloat: (array,width,height,depth) => {
 const zResults=new Array(depth);
 let i=0;
 for (let z=0; z < depth; z++) {
const yResults=new Array(height);
for (let y=0; y < height; y++) {
const xResults=new Float32Array(width);
for (let x=0; x < width; x++) {
xResults[x]=array[i];
i += 4;
}
yResults[y]=xResults;
}
zResults[z]=yResults;
 }
 return zResults;
 },
 erectArray2: (array,width) => {
 const xResults=new Array(width);
 const xResultsMax=width * 4;
 let i=0;
 for (let x=0; x < xResultsMax; x += 4) {
xResults[i++]=array.subarray(x,x + 2);
 }
 return xResults;
 },
 erect2DArray2: (array,width,height) => {
 const yResults=new Array(height);
 const XResultsMax=width * 4;
 for (let y=0; y < height; y++) {
const xResults=new Array(width);
const offset=y * XResultsMax;
let i=0;
for (let x=0; x < XResultsMax; x += 4) {
xResults[i++]=array.subarray(x + offset,x + offset + 2);
}
yResults[y]=xResults;
 }
 return yResults;
 },
 erect3DArray2: (array,width,height,depth) => {
 const xResultsMax=width * 4;
 const zResults=new Array(depth);
 for (let z=0; z < depth; z++) {
const yResults=new Array(height);
for (let y=0; y < height; y++) {
const xResults=new Array(width);
const offset=(z * xResultsMax * height) + (y * xResultsMax);
let i=0;
for (let x=0; x < xResultsMax; x += 4) {
xResults[i++]=array.subarray(x + offset,x + offset + 2);
}
yResults[y]=xResults;
}
zResults[z]=yResults;
 }
 return zResults;
 },
 erectArray3: (array,width) => {
 const xResults=new Array(width);
 const xResultsMax=width * 4;
 let i=0;
 for (let x=0; x < xResultsMax; x += 4) {
xResults[i++]=array.subarray(x,x + 3);
 }
 return xResults;
 },
 erect2DArray3: (array,width,height) => {
 const xResultsMax=width * 4;
 const yResults=new Array(height);
 for (let y=0; y < height; y++) {
const xResults=new Array(width);
const offset=y * xResultsMax;
let i=0;
for (let x=0; x < xResultsMax; x += 4) {
xResults[i++]=array.subarray(x + offset,x + offset + 3);
}
yResults[y]=xResults;
 }
 return yResults;
 },
 erect3DArray3: (array,width,height,depth) => {
 const xResultsMax=width * 4;
 const zResults=new Array(depth);
 for (let z=0; z < depth; z++) {
const yResults=new Array(height);
for (let y=0; y < height; y++) {
const xResults=new Array(width);
const offset=(z * xResultsMax * height) + (y * xResultsMax);
let i=0;
for (let x=0; x < xResultsMax; x += 4) {
xResults[i++]=array.subarray(x + offset,x + offset + 3);
}
yResults[y]=xResults;
}
zResults[z]=yResults;
 }
 return zResults;
 },
 erectArray4: (array,width) => {
 const xResults=new Array(array);
 const xResultsMax=width * 4;
 let i=0;
 for (let x=0; x < xResultsMax; x += 4) {
xResults[i++]=array.subarray(x,x + 4);
 }
 return xResults;
 },
 erect2DArray4: (array,width,height) => {
 const xResultsMax=width * 4;
 const yResults=new Array(height);
 for (let y=0; y < height; y++) {
const xResults=new Array(width);
const offset=y * xResultsMax;
let i=0;
for (let x=0; x < xResultsMax; x += 4) {
xResults[i++]=array.subarray(x + offset,x + offset + 4);
}
yResults[y]=xResults;
 }
 return yResults;
 },
 erect3DArray4: (array,width,height,depth) => {
 const xResultsMax=width * 4;
 const zResults=new Array(depth);
 for (let z=0; z < depth; z++) {
const yResults=new Array(height);
for (let y=0; y < height; y++) {
const xResults=new Array(width);
const offset=(z * xResultsMax * height) + (y * xResultsMax);
let i=0;
for (let x=0; x < xResultsMax; x += 4) {
xResults[i++]=array.subarray(x + offset,x + offset + 4);
}
yResults[y]=xResults;
}
zResults[z]=yResults;
 }
 return zResults;
 },

 flattenFunctionToString: (source,settings) => {
 const { findDependency,thisLookup,doNotDefine }=settings;
 let flattened=settings.flattened;
 if (!flattened) {
flattened=settings.flattened={};
 }
 const ast=acorn.parse(source);
 const functionDependencies=[];
 let indent=0;

 function flatten(ast) {
if (Array.isArray(ast)) {
const results=[];
for (let i=0; i < ast.length; i++) {
results.push(flatten(ast[i]));
}
return results.join('');
}
switch (ast.type) {
case 'Program':
return flatten(ast.body) + (ast.body[0].type === 'VariableDeclaration' ? ';' : '');
case 'FunctionDeclaration':
return `function ${ast.id.name}(${ast.params.map(flatten).join(',')}) ${ flatten(ast.body) }`;
case 'BlockStatement': {
const result=[];
indent += 2;
for (let i=0; i < ast.body.length; i++) {
const flat=flatten(ast.body[i]);
if (flat) {
 result.push(' '.repeat(indent) + flat,';\n');
}
}
indent -= 2;
return `{\n${result.join('')}}`;
}
case 'VariableDeclaration':
const declarations=utils.normalizeDeclarations(ast)
.map(flatten)
.filter(r => r !== null);
if (declarations.length < 1) {
return '';
} else {
return `${ast.kind} ${declarations.join(',')}`;
}
case 'VariableDeclarator':
if (ast.init.object && ast.init.object.type === 'ThisExpression') {
const lookup=thisLookup(ast.init.property.name,true);
if (lookup) {
 return `${ast.id.name}=${flatten(ast.init)}`;
} else {
 return null;
}
} else {
return `${ast.id.name}=${flatten(ast.init)}`;
}
case 'CallExpression': {
if (ast.callee.property.name === 'subarray') {
return `${flatten(ast.callee.object)}.${flatten(ast.callee.property)}(${ast.arguments.map(value => flatten(value)).join(',')})`;
}
if (ast.callee.object.name === 'gl' || ast.callee.object.name === 'context') {
return `${flatten(ast.callee.object)}.${flatten(ast.callee.property)}(${ast.arguments.map(value => flatten(value)).join(',')})`;
}
if (ast.callee.object.type === 'ThisExpression') {
functionDependencies.push(findDependency('this',ast.callee.property.name));
return `${ast.callee.property.name}(${ast.arguments.map(value => flatten(value)).join(',')})`;
} else if (ast.callee.object.name) {
const foundSource=findDependency(ast.callee.object.name,ast.callee.property.name);
if (foundSource === null) {
 return `${ast.callee.object.name}.${ast.callee.property.name}(${ast.arguments.map(value => flatten(value)).join(',')})`;
} else {
 functionDependencies.push(foundSource);
 return `${ast.callee.property.name}(${ast.arguments.map(value => flatten(value)).join(',')})`;
}
} else if (ast.callee.object.type === 'MemberExpression') {
return `${flatten(ast.callee.object)}.${ast.callee.property.name}(${ast.arguments.map(value => flatten(value)).join(',')})`;
} else {
throw new Error('unknown ast.callee');
}
}
case 'ReturnStatement':
return `return ${flatten(ast.argument)}`;
case 'BinaryExpression':
return `(${flatten(ast.left)}${ast.operator}${flatten(ast.right)})`;
case 'UnaryExpression':
if (ast.prefix) {
return `${ast.operator} ${flatten(ast.argument)}`;
} else {
return `${flatten(ast.argument)} ${ast.operator}`;
}
case 'ExpressionStatement':
return `${flatten(ast.expression)}`;
case 'SequenceExpression':
return `(${flatten(ast.expressions)})`;
case 'ArrowFunctionExpression':
return `(${ast.params.map(flatten).join(',')}) => ${flatten(ast.body)}`;
case 'Literal':
return ast.raw;
case 'Identifier':
return ast.name;
case 'MemberExpression':
if (ast.object.type === 'ThisExpression') {
return thisLookup(ast.property.name);
}
if (ast.computed) {
return `${flatten(ast.object)}[${flatten(ast.property)}]`;
}
return flatten(ast.object) + '.' + flatten(ast.property);
case 'ThisExpression':
return 'this';
case 'NewExpression':
return `new ${flatten(ast.callee)}(${ast.arguments.map(value => flatten(value)).join(',')})`;
case 'ForStatement':
return `for (${flatten(ast.init)};${flatten(ast.test)};${flatten(ast.update)}) ${flatten(ast.body)}`;
case 'AssignmentExpression':
return `${flatten(ast.left)}${ast.operator}${flatten(ast.right)}`;
case 'UpdateExpression':
return `${flatten(ast.argument)}${ast.operator}`;
case 'IfStatement':
return `if (${flatten(ast.test)}) ${flatten(ast.consequent)}`;
case 'ThrowStatement':
return `throw ${flatten(ast.argument)}`;
case 'ObjectPattern':
return ast.properties.map(flatten).join(',');
case 'ArrayPattern':
return ast.elements.map(flatten).join(',');
case 'DebuggerStatement':
return 'debugger;';
case 'ConditionalExpression':
return `${flatten(ast.test)}?${flatten(ast.consequent)}:${flatten(ast.alternate)}`;
case 'Property':
if (ast.kind === 'init') {
return flatten(ast.key);
}
}
throw new Error(`unhandled ast.type of ${ ast.type }`);
 }
 const result=flatten(ast);
 if (functionDependencies.length > 0) {
const flattenedFunctionDependencies=[];
for (let i=0; i < functionDependencies.length; i++) {
const functionDependency=functionDependencies[i];
if (!flattened[functionDependency]) {
flattened[functionDependency]=true;
}
functionDependency ? flattenedFunctionDependencies.push(utils.flattenFunctionToString(functionDependency,settings) + '\n') : '';
}
return flattenedFunctionDependencies.join('') + result;
 }
 return result;
 },

 normalizeDeclarations: (ast) => {
 if (ast.type !== 'VariableDeclaration') throw new Error('Ast is not of type "VariableDeclaration"');
 const normalizedDeclarations=[];
 for (let declarationIndex=0; declarationIndex < ast.declarations.length; declarationIndex++) {
const declaration=ast.declarations[declarationIndex];
if (declaration.id && declaration.id.type === 'ObjectPattern' && declaration.id.properties) {
const { properties }=declaration.id;
for (let propertyIndex=0; propertyIndex < properties.length; propertyIndex++) {
const property=properties[propertyIndex];
if (property.value.type === 'ObjectPattern' && property.value.properties) {
for (let subPropertyIndex=0; subPropertyIndex < property.value.properties.length; subPropertyIndex++) {
 const subProperty=property.value.properties[subPropertyIndex];
 if (subProperty.type === 'Property') {
 normalizedDeclarations.push({
 type: 'VariableDeclarator',
 id: {
 type: 'Identifier',
 name: subProperty.key.name
 },
 init: {
 type: 'MemberExpression',
 object: {
type: 'MemberExpression',
object: declaration.init,
property: {
type: 'Identifier',
name: property.key.name
},
computed: false
 },
 property: {
type: 'Identifier',
name: subProperty.key.name
 },
 computed: false
 }
 });
 } else {
 throw new Error('unexpected state');
 }
}
} else if (property.value.type === 'Identifier') {
normalizedDeclarations.push({
 type: 'VariableDeclarator',
 id: {
 type: 'Identifier',
 name: property.value && property.value.name ? property.value.name : property.key.name
 },
 init: {
 type: 'MemberExpression',
 object: declaration.init,
 property: {
 type: 'Identifier',
 name: property.key.name
 },
 computed: false
 }
});
} else {
throw new Error('unexpected state');
}
}
} else if (declaration.id && declaration.id.type === 'ArrayPattern' && declaration.id.elements) {
const { elements }=declaration.id;
for (let elementIndex=0; elementIndex < elements.length; elementIndex++) {
const element=elements[elementIndex];
if (element.type === 'Identifier') {
normalizedDeclarations.push({
 type: 'VariableDeclarator',
 id: {
 type: 'Identifier',
 name: element.name
 },
 init: {
 type: 'MemberExpression',
 object: declaration.init,
 property: {
 type: 'Literal',
 value: elementIndex,
 raw: elementIndex.toString(),
 start: element.start,
 end: element.end
 },
 computed: true
 }
});
} else {
throw new Error('unexpected state');
}
}
} else {
normalizedDeclarations.push(declaration);
}
 }
 return normalizedDeclarations;
 },

 splitHTMLImageToRGB: (gpu,image) => {
 const rKernel=gpu.createKernel(function(a) {
const pixel=a[this.thread.y][this.thread.x];
return pixel.r * 255;
 },{
output: [image.width,image.height],
precision: 'unsigned',
argumentTypes: { a: 'HTMLImage' },
 });
 const gKernel=gpu.createKernel(function(a) {
const pixel=a[this.thread.y][this.thread.x];
return pixel.g * 255;
 },{
output: [image.width,image.height],
precision: 'unsigned',
argumentTypes: { a: 'HTMLImage' },
 });
 const bKernel=gpu.createKernel(function(a) {
const pixel=a[this.thread.y][this.thread.x];
return pixel.b * 255;
 },{
output: [image.width,image.height],
precision: 'unsigned',
argumentTypes: { a: 'HTMLImage' },
 });
 const aKernel=gpu.createKernel(function(a) {
const pixel=a[this.thread.y][this.thread.x];
return pixel.a * 255;
 },{
output: [image.width,image.height],
precision: 'unsigned',
argumentTypes: { a: 'HTMLImage' },
 });
 const result=[
rKernel(image),
gKernel(image),
bKernel(image),
aKernel(image),
 ];
 result.rKernel=rKernel;
 result.gKernel=gKernel;
 result.bKernel=bKernel;
 result.aKernel=aKernel;
 result.gpu=gpu;
 return result;
 },

 splitRGBAToCanvases: (gpu,rgba,width,height) => {
 const visualKernelR=gpu.createKernel(function(v) {
const pixel=v[this.thread.y][this.thread.x];
this.color(pixel.r / 255,0,0,255);
 },{
output: [width,height],
graphical: true,
argumentTypes: { v: 'Array2D(4)' }
 });
 visualKernelR(rgba);

 const visualKernelG=gpu.createKernel(function(v) {
const pixel=v[this.thread.y][this.thread.x];
this.color(0,pixel.g / 255,0,255);
 },{
output: [width,height],
graphical: true,
argumentTypes: { v: 'Array2D(4)' }
 });
 visualKernelG(rgba);

 const visualKernelB=gpu.createKernel(function(v) {
const pixel=v[this.thread.y][this.thread.x];
this.color(0,0,pixel.b / 255,255);
 },{
output: [width,height],
graphical: true,
argumentTypes: { v: 'Array2D(4)' }
 });
 visualKernelB(rgba);

 const visualKernelA=gpu.createKernel(function(v) {
const pixel=v[this.thread.y][this.thread.x];
this.color(255,255,255,pixel.a / 255);
 },{
output: [width,height],
graphical: true,
argumentTypes: { v: 'Array2D(4)' }
 });
 visualKernelA(rgba);
 return [
visualKernelR.canvas,
visualKernelG.canvas,
visualKernelB.canvas,
visualKernelA.canvas,
 ];
 },

 getMinifySafeName: (fn) => {
 try {
const ast=acorn.parse(`const value=${fn.toString()}`);
const { init }=ast.body[0].declarations[0];
return init.body.name || init.body.body[0].argument.name;
 } catch (e) {
throw new Error('Unrecognized function type. Please use `() => yourFunctionVariableHere` or function() { return yourFunctionVariableHere; }');
 }
 },
 sanitizeName: function(name) {
 if (dollarSign.test(name)) {
name=name.replace(dollarSign,'S_S');
 }
 if (doubleUnderscore.test(name)) {
name=name.replace(doubleUnderscore,'U_U');
 } else if (singleUnderscore.test(name)) {
name=name.replace(singleUnderscore,'u_u');
 }
 return name;
 }
 };

 const dollarSign=/\$/;
 const doubleUnderscore=/__/;
 const singleUnderscore=/_/;

 const _systemEndianness=utils.getSystemEndianness();

 module.exports={
 utils
 };
 },{"./input":110,"./texture":113,"acorn":1}]},{},[107])(107)
});
var Module = typeof Module != "undefined" ? Module : {};

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

var arguments_ = [];

var thisProgram = "./this.program";

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

var ENVIRONMENT_IS_WEB = typeof window == "object";

var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";

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

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

if (Module["ENVIRONMENT"]) {
 throw new Error("Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)");
}

var scriptDirectory = "";

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

var read_, readAsync, readBinary, setWindowTitle;

function logExceptionOnExit(e) {
 if (e instanceof ExitStatus) return;
 let toLog = e;
 if (e && typeof e == "object" && e.stack) {
  toLog = [ e, e.stack ];
 }
 err("exiting due to exception: " + toLog);
}

if (ENVIRONMENT_IS_NODE) {
 if (typeof process == "undefined" || !process.release || process.release.name !== "node") throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
 var fs = require("fs");
 var nodePath = require("path");
 if (ENVIRONMENT_IS_WORKER) {
  scriptDirectory = nodePath.dirname(scriptDirectory) + "/";
 } else {
  scriptDirectory = __dirname + "/";
 }
 read_ = (filename, binary) => {
  filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
  return fs.readFileSync(filename, binary ? undefined : "utf8");
 };
 readBinary = filename => {
  var ret = read_(filename, true);
  if (!ret.buffer) {
   ret = new Uint8Array(ret);
  }
  assert(ret.buffer);
  return ret;
 };
 readAsync = (filename, onload, onerror) => {
  filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
  fs.readFile(filename, function(err, data) {
   if (err) onerror(err); else onload(data.buffer);
  });
 };
 if (process["argv"].length > 1) {
  thisProgram = process["argv"][1].replace(/\\/g, "/");
 }
 arguments_ = process["argv"].slice(2);
 if (typeof module != "undefined") {
  module["exports"] = Module;
 }
 process["on"]("uncaughtException", function(ex) {
  if (!(ex instanceof ExitStatus)) {
   throw ex;
  }
 });
 process["on"]("unhandledRejection", function(reason) {
  throw reason;
 });
 quit_ = (status, toThrow) => {
  if (keepRuntimeAlive()) {
   process["exitCode"] = status;
   throw toThrow;
  }
  logExceptionOnExit(toThrow);
  process["exit"](status);
 };
 Module["inspect"] = function() {
  return "[Emscripten Module object]";
 };
} else if (ENVIRONMENT_IS_SHELL) {
 if (typeof process == "object" && typeof require === "function" || typeof window == "object" || typeof importScripts == "function") throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
 if (typeof read != "undefined") {
  read_ = function shell_read(f) {
   return read(f);
  };
 }
 readBinary = function readBinary(f) {
  let data;
  if (typeof readbuffer == "function") {
   return new Uint8Array(readbuffer(f));
  }
  data = read(f, "binary");
  assert(typeof data == "object");
  return data;
 };
 readAsync = function readAsync(f, onload, onerror) {
  setTimeout(() => onload(readBinary(f)), 0);
 };
 if (typeof scriptArgs != "undefined") {
  arguments_ = scriptArgs;
 } else if (typeof arguments != "undefined") {
  arguments_ = arguments;
 }
 if (typeof quit == "function") {
  quit_ = (status, toThrow) => {
   logExceptionOnExit(toThrow);
   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 (typeof document != "undefined" && document.currentScript) {
  scriptDirectory = document.currentScript.src;
 }
 if (scriptDirectory.indexOf("blob:") !== 0) {
  scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
 } else {
  scriptDirectory = "";
 }
 if (!(typeof window == "object" || typeof importScripts == "function")) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
 {
  read_ = url => {
   var xhr = new XMLHttpRequest();
   xhr.open("GET", url, false);
   xhr.send(null);
   return xhr.responseText;
  };
  if (ENVIRONMENT_IS_WORKER) {
   readBinary = url => {
    var xhr = new XMLHttpRequest();
    xhr.open("GET", url, false);
    xhr.responseType = "arraybuffer";
    xhr.send(null);
    return new Uint8Array(xhr.response);
   };
  }
  readAsync = (url, onload, onerror) => {
   var xhr = new XMLHttpRequest();
   xhr.open("GET", url, true);
   xhr.responseType = "arraybuffer";
   xhr.onload = () => {
    if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
     onload(xhr.response);
     return;
    }
    onerror();
   };
   xhr.onerror = onerror;
   xhr.send(null);
  };
 }
 setWindowTitle = title => document.title = title;
} else {
 throw new Error("environment detection error");
}

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

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

Object.assign(Module, moduleOverrides);

moduleOverrides = null;

checkIncomingModuleAPI();

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

legacyModuleProp("arguments", "arguments_");

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

legacyModuleProp("thisProgram", "thisProgram");

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

legacyModuleProp("quit", "quit_");

assert(typeof Module["memoryInitializerPrefixURL"] == "undefined", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");

assert(typeof Module["pthreadMainPrefixURL"] == "undefined", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");

assert(typeof Module["cdInitializerPrefixURL"] == "undefined", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");

assert(typeof Module["filePackagePrefixURL"] == "undefined", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead");

assert(typeof Module["read"] == "undefined", "Module.read option was removed (modify read_ in JS)");

assert(typeof Module["readAsync"] == "undefined", "Module.readAsync option was removed (modify readAsync in JS)");

assert(typeof Module["readBinary"] == "undefined", "Module.readBinary option was removed (modify readBinary in JS)");

assert(typeof Module["setWindowTitle"] == "undefined", "Module.setWindowTitle option was removed (modify setWindowTitle in JS)");

assert(typeof Module["TOTAL_MEMORY"] == "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");

legacyModuleProp("read", "read_");

legacyModuleProp("readAsync", "readAsync");

legacyModuleProp("readBinary", "readBinary");

legacyModuleProp("setWindowTitle", "setWindowTitle");

var IDBFS = "IDBFS is no longer included by default; build with -lidbfs.js";

var PROXYFS = "PROXYFS is no longer included by default; build with -lproxyfs.js";

var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js";

var NODEFS = "NODEFS is no longer included by default; build with -lnodefs.js";

assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time.  Add 'shell' to `-sENVIRONMENT` to enable.");

var STACK_ALIGN = 16;

var POINTER_SIZE = 4;

function getNativeTypeSize(type) {
 switch (type) {
 case "i1":
 case "i8":
 case "u8":
  return 1;

 case "i16":
 case "u16":
  return 2;

 case "i32":
 case "u32":
  return 4;

 case "i64":
 case "u64":
  return 8;

 case "float":
  return 4;

 case "double":
  return 8;

 default:
  {
   if (type[type.length - 1] === "*") {
    return POINTER_SIZE;
   }
   if (type[0] === "i") {
    const bits = Number(type.substr(1));
    assert(bits % 8 === 0, "getNativeTypeSize invalid bits " + bits + ", type " + type);
    return bits / 8;
   }
   return 0;
  }
 }
}

function legacyModuleProp(prop, newName) {
 if (!Object.getOwnPropertyDescriptor(Module, prop)) {
  Object.defineProperty(Module, prop, {
   configurable: true,
   get: function() {
    abort("Module." + prop + " has been replaced with plain " + newName + " (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)");
   }
  });
 }
}

function ignoredModuleProp(prop) {
 if (Object.getOwnPropertyDescriptor(Module, prop)) {
  abort("`Module." + prop + "` was supplied but `" + prop + "` not included in INCOMING_MODULE_JS_API");
 }
}

function isExportedByForceFilesystem(name) {
 return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_unlink" || name === "addRunDependency" || name === "FS_createLazyFile" || name === "FS_createDevice" || name === "removeRunDependency";
}

function missingLibrarySymbol(sym) {
 if (typeof globalThis !== "undefined" && !Object.getOwnPropertyDescriptor(globalThis, sym)) {
  Object.defineProperty(globalThis, sym, {
   configurable: true,
   get: function() {
    var msg = "`" + sym + "` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line";
    var librarySymbol = sym;
    if (!librarySymbol.startsWith("_")) {
     librarySymbol = "$" + sym;
    }
    msg += " (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE=" + librarySymbol + ")";
    if (isExportedByForceFilesystem(sym)) {
     msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
    }
    warnOnce(msg);
    return undefined;
   }
  });
 }
}

function unexportedRuntimeSymbol(sym) {
 if (!Object.getOwnPropertyDescriptor(Module, sym)) {
  Object.defineProperty(Module, sym, {
   configurable: true,
   get: function() {
    var msg = "'" + sym + "' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the FAQ)";
    if (isExportedByForceFilesystem(sym)) {
     msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
    }
    abort(msg);
   }
  });
 }
}

var wasmBinary;

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

legacyModuleProp("wasmBinary", "wasmBinary");

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

legacyModuleProp("noExitRuntime", "noExitRuntime");

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

var wasmMemory;

var ABORT = false;

var EXITSTATUS;

function assert(condition, text) {
 if (!condition) {
  abort("Assertion failed" + (text ? ": " + text : ""));
 }
}

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

function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
 idx >>>= 0;
 var endIdx = idx + maxBytesToRead;
 var endPtr = idx;
 while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
 if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
  return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
 }
 var str = "";
 while (idx < endPtr) {
  var u0 = heapOrArray[idx++];
  if (!(u0 & 128)) {
   str += String.fromCharCode(u0);
   continue;
  }
  var u1 = heapOrArray[idx++] & 63;
  if ((u0 & 224) == 192) {
   str += String.fromCharCode((u0 & 31) << 6 | u1);
   continue;
  }
  var u2 = heapOrArray[idx++] & 63;
  if ((u0 & 240) == 224) {
   u0 = (u0 & 15) << 12 | u1 << 6 | u2;
  } else {
   if ((u0 & 248) != 240) warnOnce("Invalid UTF-8 leading byte " + ptrToString(u0) + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!");
   u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
  }
  if (u0 < 65536) {
   str += String.fromCharCode(u0);
  } else {
   var ch = u0 - 65536;
   str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
  }
 }
 return str;
}

function UTF8ToString(ptr, maxBytesToRead) {
 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;
   if (u > 1114111) warnOnce("Invalid Unicode code point " + ptrToString(u) + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).");
   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) {
 assert(typeof maxBytesToWrite == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
 return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
}

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

var HEAP, 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 STACK_SIZE = 5242880;

if (Module["STACK_SIZE"]) assert(STACK_SIZE === Module["STACK_SIZE"], "the stack size can no longer be determined at runtime");

var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 1610612736;

legacyModuleProp("INITIAL_MEMORY", "INITIAL_MEMORY");

assert(INITIAL_MEMORY >= STACK_SIZE, "INITIAL_MEMORY should be larger than STACK_SIZE, was " + INITIAL_MEMORY + "! (STACK_SIZE=" + STACK_SIZE + ")");

assert(typeof Int32Array != "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, "JS engine does not provide full typed array support");

assert(!Module["wasmMemory"], "Use of `wasmMemory` detected.  Use -sIMPORTED_MEMORY to define wasmMemory externally");

assert(INITIAL_MEMORY == 1610612736, "Detected runtime INITIAL_MEMORY setting.  Use -sIMPORTED_MEMORY to define wasmMemory dynamically");

var wasmTable;

function writeStackCookie() {
 var max = _emscripten_stack_get_end();
 assert((max & 3) == 0);
 if (max == 0) {
  max += 4;
 }
 HEAPU32[max >>> 2] = 34821223;
 HEAPU32[max + 4 >>> 2] = 2310721022;
 HEAPU32[0 >>> 0] = 1668509029;
}

function checkStackCookie() {
 if (ABORT) return;
 var max = _emscripten_stack_get_end();
 if (max == 0) {
  max += 4;
 }
 var cookie1 = HEAPU32[max >>> 2];
 var cookie2 = HEAPU32[max + 4 >>> 2];
 if (cookie1 != 34821223 || cookie2 != 2310721022) {
  abort("Stack overflow! Stack cookie has been overwritten at " + ptrToString(max) + ", expected hex dwords 0x89BACDFE and 0x2135467, but received " + ptrToString(cookie2) + " " + ptrToString(cookie1));
 }
 if (HEAPU32[0 >>> 0] !== 1668509029) {
  abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
 }
}

(function() {
 var h16 = new Int16Array(1);
 var h8 = new Int8Array(h16.buffer);
 h16[0] = 25459;
 if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)";
})();

var __ATPRERUN__ = [];

var __ATINIT__ = [];

var __ATMAIN__ = [];

var __ATEXIT__ = [];

var __ATPOSTRUN__ = [];

var runtimeInitialized = false;

function keepRuntimeAlive() {
 return noExitRuntime;
}

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() {
 assert(!runtimeInitialized);
 runtimeInitialized = true;
 checkStackCookie();
 if (!Module["noFSInit"] && !FS.init.initialized) FS.init();
 FS.ignorePermissions = false;
 TTY.init();
 callRuntimeCallbacks(__ATINIT__);
}

function preMain() {
 checkStackCookie();
 callRuntimeCallbacks(__ATMAIN__);
}

function postRun() {
 checkStackCookie();
 if (Module["postRun"]) {
  if (typeof Module["postRun"] == "function") Module["postRun"] = [ Module["postRun"] ];
  while (Module["postRun"].length) {
   addOnPostRun(Module["postRun"].shift());
  }
 }
 callRuntimeCallbacks(__ATPOSTRUN__);
}

function addOnPreRun(cb) {
 __ATPRERUN__.unshift(cb);
}

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

function addOnPreMain(cb) {
 __ATMAIN__.unshift(cb);
}

function addOnExit(cb) {}

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

assert(Math.imul, "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");

assert(Math.fround, "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");

assert(Math.clz32, "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");

assert(Math.trunc, "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");

var runDependencies = 0;

var runDependencyWatcher = null;

var dependenciesFulfilled = null;

var runDependencyTracking = {};

function getUniqueRunDependency(id) {
 var orig = id;
 while (1) {
  if (!runDependencyTracking[id]) return id;
  id = orig + Math.random();
 }
}

function addRunDependency(id) {
 runDependencies++;
 if (Module["monitorRunDependencies"]) {
  Module["monitorRunDependencies"](runDependencies);
 }
 if (id) {
  assert(!runDependencyTracking[id]);
  runDependencyTracking[id] = 1;
  if (runDependencyWatcher === null && typeof setInterval != "undefined") {
   runDependencyWatcher = setInterval(function() {
    if (ABORT) {
     clearInterval(runDependencyWatcher);
     runDependencyWatcher = null;
     return;
    }
    var shown = false;
    for (var dep in runDependencyTracking) {
     if (!shown) {
      shown = true;
      err("still waiting on run dependencies:");
     }
     err("dependency: " + dep);
    }
    if (shown) {
     err("(end of list)");
    }
   }, 1e4);
  }
 } else {
  err("warning: run dependency added without ID");
 }
}

function removeRunDependency(id) {
 runDependencies--;
 if (Module["monitorRunDependencies"]) {
  Module["monitorRunDependencies"](runDependencies);
 }
 if (id) {
  assert(runDependencyTracking[id]);
  delete runDependencyTracking[id];
 } else {
  err("warning: run dependency removed without ID");
 }
 if (runDependencies == 0) {
  if (runDependencyWatcher !== null) {
   clearInterval(runDependencyWatcher);
   runDependencyWatcher = null;
  }
  if (dependenciesFulfilled) {
   var callback = dependenciesFulfilled;
   dependenciesFulfilled = null;
   callback();
  }
 }
}

function abort(what) {
 if (Module["onAbort"]) {
  Module["onAbort"](what);
 }
 what = "Aborted(" + what + ")";
 err(what);
 ABORT = true;
 EXITSTATUS = 1;
 var e = new WebAssembly.RuntimeError(what);
 throw e;
}

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

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

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

function createExportWrapper(name, fixedasm) {
 return function() {
  var displayName = name;
  var asm = fixedasm;
  if (!fixedasm) {
   asm = Module["asm"];
  }
  assert(runtimeInitialized, "native function `" + displayName + "` called before runtime initialization");
  if (!asm[name]) {
   assert(asm[name], "exported native function `" + displayName + "` not found");
  }
  return asm[name].apply(null, arguments);
 };
}

var wasmBinaryFile;

wasmBinaryFile = "g3012.wasm";

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

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

function getBinaryPromise() {
 if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
  if (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(wasmBinaryFile);
   });
  } else {
   if (readAsync) {
    return new Promise(function(resolve, reject) {
     readAsync(wasmBinaryFile, function(response) {
      resolve(new Uint8Array(response));
     }, reject);
    });
   }
  }
 }
 return Promise.resolve().then(function() {
  return getBinary(wasmBinaryFile);
 });
}

function createWasm() {
 var info = {
  "env": asmLibraryArg,
  "wasi_snapshot_preview1": asmLibraryArg
 };
 function receiveInstance(instance, module) {
  var exports = instance.exports;
  Module["asm"] = exports;
  wasmMemory = Module["asm"]["memory"];
  assert(wasmMemory, "memory not found in wasm exports");
  updateGlobalBufferAndViews(wasmMemory.buffer);
  wasmTable = Module["asm"]["__indirect_function_table"];
  assert(wasmTable, "table not found in wasm exports");
  addOnInit(Module["asm"]["__wasm_call_ctors"]);
  removeRunDependency("wasm-instantiate");
 }
 addRunDependency("wasm-instantiate");
 var trueModule = Module;
 function receiveInstantiationResult(result) {
  assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");
  trueModule = null;
  receiveInstance(result["instance"]);
 }
 function instantiateArrayBuffer(receiver) {
  return getBinaryPromise().then(function(binary) {
   return WebAssembly.instantiate(binary, info);
  }).then(function(instance) {
   return instance;
  }).then(receiver, function(reason) {
   err("failed to asynchronously prepare wasm: " + reason);
   if (isFileURI(wasmBinaryFile)) {
    err("warning: Loading from a file URI (" + wasmBinaryFile + ") is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing");
   }
   abort(reason);
  });
 }
 function instantiateAsync() {
  if (!wasmBinary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(wasmBinaryFile) && !isFileURI(wasmBinaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
   return fetch(wasmBinaryFile, {
    credentials: "same-origin"
   }).then(function(response) {
    var result = WebAssembly.instantiateStreaming(response, info);
    return result.then(receiveInstantiationResult, function(reason) {
     err("wasm streaming compile failed: " + reason);
     err("falling back to ArrayBuffer instantiation");
     return instantiateArrayBuffer(receiveInstantiationResult);
    });
   });
  } else {
   return instantiateArrayBuffer(receiveInstantiationResult);
  }
 }
 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;

var ASM_CONSTS = {
 5318210: () => {
  return parseInt(window.innerHeight);
 },
 5318249: () => {
  FS.mkdir("/snd");
  FS.mkdir("/shader");
 },
 5318292: $0 => {
  var str = UTF8ToString($0) + "\n\n" + "Abort/Retry/Ignore/AlwaysIgnore? [ariA] :";
  var reply = window.prompt(str, "i");
  if (reply === null) {
   reply = "i";
  }
  return allocate(intArrayFromString(reply), "i8", ALLOC_NORMAL);
 },
 5318517: () => {
  if (typeof AudioContext !== "undefined") {
   return true;
  } else if (typeof webkitAudioContext !== "undefined") {
   return true;
  }
  return false;
 },
 5318664: () => {
  if (typeof navigator.mediaDevices !== "undefined" && typeof navigator.mediaDevices.getUserMedia !== "undefined") {
   return true;
  } else if (typeof navigator.webkitGetUserMedia !== "undefined") {
   return true;
  }
  return false;
 },
 5318898: $0 => {
  if (typeof Module["SDL2"] === "undefined") {
   Module["SDL2"] = {};
  }
  var SDL2 = Module["SDL2"];
  if (!$0) {
   SDL2.audio = {};
  } else {
   SDL2.capture = {};
  }
  if (!SDL2.audioContext) {
   if (typeof AudioContext !== "undefined") {
    SDL2.audioContext = new AudioContext();
   } else if (typeof webkitAudioContext !== "undefined") {
    SDL2.audioContext = new webkitAudioContext();
   }
   if (SDL2.audioContext) {
    autoResumeAudioContext(SDL2.audioContext);
   }
  }
  return SDL2.audioContext === undefined ? -1 : 0;
 },
 5319391: () => {
  var SDL2 = Module["SDL2"];
  return SDL2.audioContext.sampleRate;
 },
 5319459: ($0, $1, $2, $3) => {
  var SDL2 = Module["SDL2"];
  var have_microphone = function(stream) {
   if (SDL2.capture.silenceTimer !== undefined) {
    clearTimeout(SDL2.capture.silenceTimer);
    SDL2.capture.silenceTimer = undefined;
   }
   SDL2.capture.mediaStreamNode = SDL2.audioContext.createMediaStreamSource(stream);
   SDL2.capture.scriptProcessorNode = SDL2.audioContext.createScriptProcessor($1, $0, 1);
   SDL2.capture.scriptProcessorNode.onaudioprocess = function(audioProcessingEvent) {
    if (SDL2 === undefined || SDL2.capture === undefined) {
     return;
    }
    audioProcessingEvent.outputBuffer.getChannelData(0).fill(0);
    SDL2.capture.currentCaptureBuffer = audioProcessingEvent.inputBuffer;
    dynCall("vi", $2, [ $3 ]);
   };
   SDL2.capture.mediaStreamNode.connect(SDL2.capture.scriptProcessorNode);
   SDL2.capture.scriptProcessorNode.connect(SDL2.audioContext.destination);
   SDL2.capture.stream = stream;
  };
  var no_microphone = function(error) {};
  SDL2.capture.silenceBuffer = SDL2.audioContext.createBuffer($0, $1, SDL2.audioContext.sampleRate);
  SDL2.capture.silenceBuffer.getChannelData(0).fill(0);
  var silence_callback = function() {
   SDL2.capture.currentCaptureBuffer = SDL2.capture.silenceBuffer;
   dynCall("vi", $2, [ $3 ]);
  };
  SDL2.capture.silenceTimer = setTimeout(silence_callback, $1 / SDL2.audioContext.sampleRate * 1e3);
  if (navigator.mediaDevices !== undefined && navigator.mediaDevices.getUserMedia !== undefined) {
   navigator.mediaDevices.getUserMedia({
    audio: true,
    video: false
   }).then(have_microphone).catch(no_microphone);
  } else if (navigator.webkitGetUserMedia !== undefined) {
   navigator.webkitGetUserMedia({
    audio: true,
    video: false
   }, have_microphone, no_microphone);
  }
 },
 5321111: ($0, $1, $2, $3) => {
  var SDL2 = Module["SDL2"];
  SDL2.audio.scriptProcessorNode = SDL2.audioContext["createScriptProcessor"]($1, 0, $0);
  SDL2.audio.scriptProcessorNode["onaudioprocess"] = function(e) {
   if (SDL2 === undefined || SDL2.audio === undefined) {
    return;
   }
   SDL2.audio.currentOutputBuffer = e["outputBuffer"];
   dynCall("vi", $2, [ $3 ]);
  };
  SDL2.audio.scriptProcessorNode["connect"](SDL2.audioContext["destination"]);
 },
 5321521: ($0, $1) => {
  var SDL2 = Module["SDL2"];
  var numChannels = SDL2.capture.currentCaptureBuffer.numberOfChannels;
  for (var c = 0; c < numChannels; ++c) {
   var channelData = SDL2.capture.currentCaptureBuffer.getChannelData(c);
   if (channelData.length != $1) {
    throw "Web Audio capture buffer length mismatch! Destination size: " + channelData.length + " samples vs expected " + $1 + " samples!";
   }
   if (numChannels == 1) {
    for (var j = 0; j < $1; ++j) {
     setValue($0 + j * 4, channelData[j], "float");
    }
   } else {
    for (var j = 0; j < $1; ++j) {
     setValue($0 + (j * numChannels + c) * 4, channelData[j], "float");
    }
   }
  }
 },
 5322126: ($0, $1) => {
  var SDL2 = Module["SDL2"];
  var numChannels = SDL2.audio.currentOutputBuffer["numberOfChannels"];
  for (var c = 0; c < numChannels; ++c) {
   var channelData = SDL2.audio.currentOutputBuffer["getChannelData"](c);
   if (channelData.length != $1) {
    throw "Web Audio output buffer length mismatch! Destination size: " + channelData.length + " samples vs expected " + $1 + " samples!";
   }
   for (var j = 0; j < $1; ++j) {
    channelData[j] = HEAPF32[$0 + (j * numChannels + c << 2) >>> 2];
   }
  }
 },
 5322606: $0 => {
  var SDL2 = Module["SDL2"];
  if ($0) {
   if (SDL2.capture.silenceTimer !== undefined) {
    clearTimeout(SDL2.capture.silenceTimer);
   }
   if (SDL2.capture.stream !== undefined) {
    var tracks = SDL2.capture.stream.getAudioTracks();
    for (var i = 0; i < tracks.length; i++) {
     SDL2.capture.stream.removeTrack(tracks[i]);
    }
    SDL2.capture.stream = undefined;
   }
   if (SDL2.capture.scriptProcessorNode !== undefined) {
    SDL2.capture.scriptProcessorNode.onaudioprocess = function(audioProcessingEvent) {};
    SDL2.capture.scriptProcessorNode.disconnect();
    SDL2.capture.scriptProcessorNode = undefined;
   }
   if (SDL2.capture.mediaStreamNode !== undefined) {
    SDL2.capture.mediaStreamNode.disconnect();
    SDL2.capture.mediaStreamNode = undefined;
   }
   if (SDL2.capture.silenceBuffer !== undefined) {
    SDL2.capture.silenceBuffer = undefined;
   }
   SDL2.capture = undefined;
  } else {
   if (SDL2.audio.scriptProcessorNode != undefined) {
    SDL2.audio.scriptProcessorNode.disconnect();
    SDL2.audio.scriptProcessorNode = undefined;
   }
   SDL2.audio = undefined;
  }
  if (SDL2.audioContext !== undefined && SDL2.audio === undefined && SDL2.capture === undefined) {
   SDL2.audioContext.close();
   SDL2.audioContext = undefined;
  }
 },
 5323778: ($0, $1, $2) => {
  var w = $0;
  var h = $1;
  var pixels = $2;
  if (!Module["SDL2"]) Module["SDL2"] = {};
  var SDL2 = Module["SDL2"];
  if (SDL2.ctxCanvas !== Module["canvas"]) {
   SDL2.ctx = Module["createContext"](Module["canvas"], false, true);
   SDL2.ctxCanvas = Module["canvas"];
  }
  if (SDL2.w !== w || SDL2.h !== h || SDL2.imageCtx !== SDL2.ctx) {
   SDL2.image = SDL2.ctx.createImageData(w, h);
   SDL2.w = w;
   SDL2.h = h;
   SDL2.imageCtx = SDL2.ctx;
  }
  var data = SDL2.image.data;
  var src = pixels >> 2;
  var dst = 0;
  var num;
  if (typeof CanvasPixelArray !== "undefined" && data instanceof CanvasPixelArray) {
   num = data.length;
   while (dst < num) {
    var val = HEAP32[src >>> 0];
    data[dst] = val & 255;
    data[dst + 1] = val >> 8 & 255;
    data[dst + 2] = val >> 16 & 255;
    data[dst + 3] = 255;
    src++;
    dst += 4;
   }
  } else {
   if (SDL2.data32Data !== data) {
    SDL2.data32 = new Int32Array(data.buffer);
    SDL2.data8 = new Uint8Array(data.buffer);
    SDL2.data32Data = data;
   }
   var data32 = SDL2.data32;
   num = data32.length;
   data32.set(HEAP32.subarray(src >>> 0, src + num >>> 0));
   var data8 = SDL2.data8;
   var i = 3;
   var j = i + 4 * num;
   if (num % 8 == 0) {
    while (i < j) {
     data8[i] = 255;
     i = i + 4 | 0;
     data8[i] = 255;
     i = i + 4 | 0;
     data8[i] = 255;
     i = i + 4 | 0;
     data8[i] = 255;
     i = i + 4 | 0;
     data8[i] = 255;
     i = i + 4 | 0;
     data8[i] = 255;
     i = i + 4 | 0;
     data8[i] = 255;
     i = i + 4 | 0;
     data8[i] = 255;
     i = i + 4 | 0;
    }
   } else {
    while (i < j) {
     data8[i] = 255;
     i = i + 4 | 0;
    }
   }
  }
  SDL2.ctx.putImageData(SDL2.image, 0, 0);
 },
 5325247: ($0, $1, $2, $3, $4) => {
  var w = $0;
  var h = $1;
  var hot_x = $2;
  var hot_y = $3;
  var pixels = $4;
  var canvas = document.createElement("canvas");
  canvas.width = w;
  canvas.height = h;
  var ctx = canvas.getContext("2d");
  var image = ctx.createImageData(w, h);
  var data = image.data;
  var src = pixels >> 2;
  var dst = 0;
  var num;
  if (typeof CanvasPixelArray !== "undefined" && data instanceof CanvasPixelArray) {
   num = data.length;
   while (dst < num) {
    var val = HEAP32[src >>> 0];
    data[dst] = val & 255;
    data[dst + 1] = val >> 8 & 255;
    data[dst + 2] = val >> 16 & 255;
    data[dst + 3] = val >> 24 & 255;
    src++;
    dst += 4;
   }
  } else {
   var data32 = new Int32Array(data.buffer);
   num = data32.length;
   data32.set(HEAP32.subarray(src >>> 0, src + num >>> 0));
  }
  ctx.putImageData(image, 0, 0);
  var url = hot_x === 0 && hot_y === 0 ? "url(" + canvas.toDataURL() + "), auto" : "url(" + canvas.toDataURL() + ") " + hot_x + " " + hot_y + ", auto";
  var urlBuf = _malloc(url.length + 1);
  stringToUTF8(url, urlBuf, url.length + 1);
  return urlBuf;
 },
 5326236: $0 => {
  if (Module["canvas"]) {
   Module["canvas"].style["cursor"] = UTF8ToString($0);
  }
 },
 5326319: () => {
  if (Module["canvas"]) {
   Module["canvas"].style["cursor"] = "none";
  }
 },
 5326388: () => {
  return window.innerWidth;
 },
 5326418: () => {
  return window.innerHeight;
 }
};

function ma() {
 let w$ = parseInt(document.getElementById("wid").innerHTML, 10);
 let h$ = parseInt(document.getElementById("hig").innerHTML, 10);
 var vv = document.getElementById("mv");
 var $H = Module.HEAPF32.buffer;
 let la = h$ * h$ * 4;
 var pointa = 77 * la;
 var agav = new Float32Array($H, pointa, 300);
 let sz = h$ * h$ / 8;
 var avag = .75;
 var min = 1;
 var max = 0;
 agav.fill(avag, 0, 33);
 agav.fill(min, 100, 33);
 agav.fill(max, 200, 33);
 const bcanvas = document.getElementById("bcanvas");
 const contx = bcanvas.getContext("webgl2", {
  colorSpace: "srgb",
  antialias: true,
  alpha: true,
  imageSmoothingEnabled: true,
  stencil: true,
  depth: true,
  preserveDrawingBuffer: false,
  premultipliedAlpha: false,
  lowLatency: true,
  powerPreference: "high-performance",
  majorVersion: 2,
  minorVersion: 0,
  desynchronized: false
 });
 contx.getExtension("EXT_color_buffer_float");
 contx.getExtension("OES_texture_float_linear");
 const g = new GPU({
  canvas: bcanvas,
  webGl: contx
 });
 const g2 = new GPU();
 const glslAve = `float Ave(float a,float b,float c) {return (a+b+c)/3.0;}`;
 const glslAlphe = `float Alphe(float a,float b,float c,float d,float e,float f,float g){return ((0.7+(3.0*((1.0-b)-(((((1.0-f)-(a)+b)*1.5)/2.0)+((f-0.5)*((1.0-f)*0.25))-((0.5-f)*(f*0.25))-((g-e)*((1.0-g)*0.1))))))/4.0);}`;
 const glslAveg = `float Aveg(float a,float b) {return (0.9999522-(((a)-(b))*((a)*(0.9999522/(0.9999522-b))))) ;}`;
 g.addNativeFunction("Ave", glslAve, {
  returnType: "Number"
 });
 g.addNativeFunction("Alphe", glslAlphe, {
  returnType: "Number"
 });
 g.addNativeFunction("Aveg", glslAveg, {
  returnType: "Number"
 });
 g2.addNativeFunction("Aveg", glslAveg, {
  returnType: "Number"
 });
 g2.addNativeFunction("Ave", glslAve, {
  returnType: "Number"
 });
 const R = g2.createKernel(function(tv) {
  var Pa = tv[this.thread.y][this.thread.x * 4];
  return Ave(Pa[0], Pa[1], Pa[2]);
 }).setTactic("speed").setDynamicOutput(true).setArgumentTypes([ "HTMLVideo" ]).setOutput([ sz ]);
 const t = g.createKernel(function(v) {
  var P = v[this.thread.y][this.thread.x - this.constants.blnk - this.constants.nblnk];
  var av$ = Ave(P[0], P[1], P[2]);
  return [ P[0], P[1], P[2], av$ ];
 }).setTactic("precision").setPipeline(true).setArgumentTypes([ "HTMLVideo" ]).setDynamicOutput(true).setOutput([ w$, h$ ]);
 const r = g.createKernel(function(f) {
  var p = f[this.thread.y][this.thread.x - this.constants.nblnk - this.constants.blnk];
  var $fmax = this.constants.fmax;
  var $fmin = this.constants.fmin;
  var $amax = this.constants.amax;
  var $amin = this.constants.amin;
  var $favg = this.constants.favg;
  var $aavg = this.constants.aavg;
  var alph = Alphe($amax, $amin, $fmax, $fmin, $favg, $aavg, p[3]);
  var Min = 4 * (($fmax - ($aavg - $fmin)) / 2);
  var ouT = Math.max(Min, alph);
  var aveg = Aveg(p[3], ouT);
  this.color(p[0], p[1], p[2], aveg);
 }).setTactic("precision").setGraphical(true).setArgumentTypes([ "HTMLVideo" ]).setDynamicOutput(true).setOutput([ w$, h$ ]);
 w$ = parseInt(document.getElementById("wid").innerHTML, 10);
 h$ = parseInt(document.getElementById("hig").innerHTML, 10);
 vv = document.getElementById("mv");
 var blank$ = Math.max((w$ - h$) * 0 / 2, 0);
 var nblank$ = Math.max((h$ - w$) * 0 / 2, 0);
 let l = w$ * h$ * 16;
 la = h$ * h$ * 4;
 let al = w$ * h$ * 8;
 sz = h$ * h$ / 8;
 var pointa = 77 * la;
 var agav = new Float32Array($H, pointa, 300);
 R.setOutput([ sz ]);
 for (i = 0; i < 65; i++) {
  var j = i + 1;
  eval("var point" + j + "=" + i + "*la;var $" + j + "=new Float32Array($H,point" + j + ",la);");
 }
 var pointb = 77 * la;
 var $B = new Float32Array($H, pointb, sz);
 var $F = 1;
 var $Bu = 33;
 r.setConstants({
  nblnk: nblank$,
  blnk: blank$,
  favg: agav[$F],
  fmin: agav[$F + 100],
  fmax: agav[$F + 200],
  amin: agav[100],
  amax: agav[200],
  aavg: agav[0]
 });
 t.setConstants({
  nblnk: nblank$,
  blnk: blank$
 });
 var $$1 = t(vv);
 for (i = 0; i < 65; i++) {
  var j = i + 1;
  eval("$" + j + ".set($$1);");
 }
 var d = S();
 if (d) d();
 d = S();
 function S() {
  w$ = parseInt(document.getElementById("wid").innerHTML, 10);
  h$ = parseInt(document.getElementById("hig").innerHTML, 10);
  var blank$ = Math.max((w$ - h$) * 0 / 2, 0);
  var nblank$ = Math.max((h$ - w$) * 0 / 2, 0);
  l = w$ * h$ * 16;
  la = h$ * h$ * 4;
  al = w$ * h$ * 8;
  sz = h$ * h$ / 8;
  var pointa = 77 * la;
  var agav = new Float32Array($H, pointa, 300);
  R.setOutput([ sz ]);
  for (i = 0; i < 65; i++) {
   var j = i + 1;
   eval("var point" + j + "=" + i + "*la;var $" + j + "=new Float32Array($H,point" + j + ",la);");
  }
  var pointb = 66 * la;
  var $B = new Float32Array($H, pointb, sz);
  r.setConstants({
   nblnk: nblank$,
   blnk: blank$,
   favg: agav[$F],
   fmin: agav[$F + 100],
   fmax: agav[$F + 200],
   amin: agav[100],
   amax: agav[200],
   aavg: agav[0]
  });
  t.setConstants({
   nblnk: nblank$,
   blnk: blank$
  });
  var T = false;
  function M() {
   var vv = document.getElementById("mv");
   t.setConstants({
    nblnk: nblank$,
    blnk: blank$
   });
   r.setConstants({
    nblnk: nblank$,
    blnk: blank$,
    favg: agav[$F],
    fmin: agav[$F + 100],
    fmax: agav[$F + 200],
    amin: agav[100],
    amax: agav[200],
    aavg: agav[0]
   });
   if (T) {
    return;
   }
   for (i = 64; i > 0; i--) {
    var loca = $F + 1;
    if (loca > 64) {
     loca = 1;
    }
    var locb = $Bu + 1;
    if (locb > 64) {
     locb = 1;
    }
    eval("if ($F==" + i + "){var $r" + i + "=t($" + i + ");r($r" + i + ");var $$" + $Bu + "=t(vv);$" + $Bu + ".set($$" + $Bu + ");$F=" + loca + ";$Bu=" + locb + ";}");
   }
   var $bb = R(vv);
   $B.set($bb, 0, sz);
   pointb = 66 * la;
   Module.ccall("nano", null, [ "Number", "Number", "Number", "Number" ], [ $F, sz, pointb, pointa ]);
   setTimeout(function() {
    M();
   }, 12);
  }
  M();
  document.getElementById("di").onclick = function() {
   T = true;
   S();
  };
  return () => {
   T = true;
  };
 }
}

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

function listenOnce(object, event, func) {
 object.addEventListener(event, func, {
  "once": true
 });
}

function autoResumeAudioContext(ctx, elements) {
 if (!elements) {
  elements = [ document, document.getElementById("canvas") ];
 }
 [ "keydown", "mousedown", "touchstart" ].forEach(function(event) {
  elements.forEach(function(element) {
   if (element) {
    listenOnce(element, event, () => {
     if (ctx.state === "suspended") ctx.resume();
    });
   }
  });
 });
}

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

function dynCallLegacy(sig, ptr, args) {
 assert("dynCall_" + sig in Module, "bad function pointer type - dynCall function not found for sig '" + sig + "'");
 if (args && args.length) {
  assert(args.length === sig.substring(1).replace(/j/g, "--").length);
 } else {
  assert(sig.length == 1);
 }
 var f = Module["dynCall_" + sig];
 return args && args.length ? f.apply(null, [ ptr ].concat(args)) : f.call(null, ptr);
}

var wasmTableMirror = [];

function getWasmTableEntry(funcPtr) {
 var func = wasmTableMirror[funcPtr];
 if (!func) {
  if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
  wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
 }
 assert(wasmTable.get(funcPtr) == func, "JavaScript-side Wasm function table mirror is out of date!");
 return func;
}

function dynCall(sig, ptr, args) {
 if (sig.includes("j")) {
  return dynCallLegacy(sig, ptr, args);
 }
 assert(getWasmTableEntry(ptr), "missing table entry in dynCall: " + ptr);
 var rtn = getWasmTableEntry(ptr).apply(null, args);
 return rtn;
}

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

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

 case "i16":
  return HEAP16[ptr >>> 1];

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

 case "i64":
  return HEAP32[ptr >>> 2];

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

 case "double":
  return HEAPF64[ptr >>> 3];

 case "*":
  return HEAPU32[ptr >>> 2];

 default:
  abort("invalid type for getValue: " + type);
 }
 return null;
}

function ptrToString(ptr) {
 return "0x" + ptr.toString(16).padStart(8, "0");
}

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

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

 case "i16":
  HEAP16[ptr >>> 1] = value;
  break;

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

 case "i64":
  tempI64 = [ value >>> 0, (tempDouble = value, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) ], 
  HEAP32[ptr >>> 2] = tempI64[0], HEAP32[ptr + 4 >>> 2] = tempI64[1];
  break;

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

 case "double":
  HEAPF64[ptr >>> 3] = value;
  break;

 case "*":
  HEAPU32[ptr >>> 2] = value;
  break;

 default:
  abort("invalid type for setValue: " + type);
 }
}

function warnOnce(text) {
 if (!warnOnce.shown) warnOnce.shown = {};
 if (!warnOnce.shown[text]) {
  warnOnce.shown[text] = 1;
  if (ENVIRONMENT_IS_NODE) text = "warning: " + text;
  err(text);
 }
}

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

var PATH = {
 isAbs: path => path.charAt(0) === "/",
 splitPath: filename => {
  var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
  return splitPathRe.exec(filename).slice(1);
 },
 normalizeArray: (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: path => {
  var isAbsolute = PATH.isAbs(path), trailingSlash = path.substr(-1) === "/";
  path = PATH.normalizeArray(path.split("/").filter(p => !!p), !isAbsolute).join("/");
  if (!path && !isAbsolute) {
   path = ".";
  }
  if (path && trailingSlash) {
   path += "/";
  }
  return (isAbsolute ? "/" : "") + path;
 },
 dirname: 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: path => {
  if (path === "/") return "/";
  path = PATH.normalize(path);
  path = path.replace(/\/$/, "");
  var lastSlash = path.lastIndexOf("/");
  if (lastSlash === -1) return path;
  return path.substr(lastSlash + 1);
 },
 join: function() {
  var paths = Array.prototype.slice.call(arguments);
  return PATH.normalize(paths.join("/"));
 },
 join2: (l, r) => {
  return PATH.normalize(l + "/" + r);
 }
};

function getRandomDevice() {
 if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") {
  var randomBuffer = new Uint8Array(1);
  return () => {
   crypto.getRandomValues(randomBuffer);
   return randomBuffer[0];
  };
 } else if (ENVIRONMENT_IS_NODE) {
  try {
   var crypto_module = require("crypto");
   return () => crypto_module["randomBytes"](1)[0];
  } catch (e) {}
 }
 return () => abort("no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: function(array) { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };");
}

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.isAbs(path);
  }
  resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(p => !!p), !resolvedAbsolute).join("/");
  return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
 },
 relative: (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("/");
 }
};

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 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.fsync(stream.tty);
  },
  fsync: function(stream) {
   stream.tty.ops.fsync(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(BUFSIZE);
     var bytesRead = 0;
     try {
      bytesRead = fs.readSync(process.stdin.fd, buf, 0, BUFSIZE, -1);
     } catch (e) {
      if (e.toString().includes("EOF")) 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);
   }
  },
  fsync: 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);
   }
  },
  fsync: function(tty) {
   if (tty.output && tty.output.length > 0) {
    err(UTF8ArrayToString(tty.output, 0));
    tty.output = [];
   }
  }
 }
};

function zeroMemory(address, size) {
 HEAPU8.fill(0, address, address + size);
 return address;
}

function alignMemory(size, alignment) {
 assert(alignment, "alignment argument is required");
 return Math.ceil(size / alignment) * alignment;
}

function mmapAlloc(size) {
 abort("internal error: mmapAlloc called but `emscripten_builtin_memalign` native symbol not exported");
}

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;
   parent.timestamp = node.timestamp;
  }
  return node;
 },
 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);
 },
 resizeFileStorage: function(node, newSize) {
  newSize >>>= 0;
  if (node.usedBytes == newSize) return;
  if (newSize == 0) {
   node.contents = null;
   node.usedBytes = 0;
  } else {
   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;
  }
 },
 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.parent.timestamp = Date.now();
   old_node.name = new_name;
   new_dir.contents[new_name] = old_node;
   new_dir.timestamp = old_node.parent.timestamp;
   old_node.parent = new_dir;
  },
  unlink: function(parent, name) {
   delete parent.contents[name];
   parent.timestamp = Date.now();
  },
  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];
   parent.timestamp = Date.now();
  },
  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);
   assert(size >= 0);
   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) {
   assert(!(buffer instanceof ArrayBuffer));
   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) {
     assert(position === 0, "canOwn must imply no weird position inside the file");
     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, length, position, prot, flags) {
   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 = 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) {
   MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
   return 0;
  }
 }
};

function asyncLoad(url, onload, onerror, noRunDep) {
 var dep = !noRunDep ? getUniqueRunDependency("al " + url) : "";
 readAsync(url, arrayBuffer => {
  assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).');
  onload(new Uint8Array(arrayBuffer));
  if (dep) removeRunDependency(dep);
 }, event => {
  if (onerror) {
   onerror();
  } else {
   throw 'Loading data file "' + url + '" failed.';
  }
 });
 if (dep) addRunDependency(dep);
}

var ERRNO_MESSAGES = {
 0: "Success",
 1: "Arg list too long",
 2: "Permission denied",
 3: "Address already in use",
 4: "Address not available",
 5: "Address family not supported by protocol family",
 6: "No more processes",
 7: "Socket already connected",
 8: "Bad file number",
 9: "Trying to read unreadable message",
 10: "Mount device busy",
 11: "Operation canceled",
 12: "No children",
 13: "Connection aborted",
 14: "Connection refused",
 15: "Connection reset by peer",
 16: "File locking deadlock error",
 17: "Destination address required",
 18: "Math arg out of domain of func",
 19: "Quota exceeded",
 20: "File exists",
 21: "Bad address",
 22: "File too large",
 23: "Host is unreachable",
 24: "Identifier removed",
 25: "Illegal byte sequence",
 26: "Connection already in progress",
 27: "Interrupted system call",
 28: "Invalid argument",
 29: "I/O error",
 30: "Socket is already connected",
 31: "Is a directory",
 32: "Too many symbolic links",
 33: "Too many open files",
 34: "Too many links",
 35: "Message too long",
 36: "Multihop attempted",
 37: "File or path name too long",
 38: "Network interface is not configured",
 39: "Connection reset by network",
 40: "Network is unreachable",
 41: "Too many open files in system",
 42: "No buffer space available",
 43: "No such device",
 44: "No such file or directory",
 45: "Exec format error",
 46: "No record locks available",
 47: "The link has been severed",
 48: "Not enough core",
 49: "No message of desired type",
 50: "Protocol not available",
 51: "No space left on device",
 52: "Function not implemented",
 53: "Socket is not connected",
 54: "Not a directory",
 55: "Directory not empty",
 56: "State not recoverable",
 57: "Socket operation on non-socket",
 59: "Not a typewriter",
 60: "No such device or address",
 61: "Value too large for defined data type",
 62: "Previous owner died",
 63: "Not super-user",
 64: "Broken pipe",
 65: "Protocol error",
 66: "Unknown protocol",
 67: "Protocol wrong type for socket",
 68: "Math result not representable",
 69: "Read only file system",
 70: "Illegal seek",
 71: "No such process",
 72: "Stale file handle",
 73: "Connection timed out",
 74: "Text file busy",
 75: "Cross-device link",
 100: "Device not a stream",
 101: "Bad font file fmt",
 102: "Invalid slot",
 103: "Invalid request code",
 104: "No anode",
 105: "Block device required",
 106: "Channel number out of range",
 107: "Level 3 halted",
 108: "Level 3 reset",
 109: "Link number out of range",
 110: "Protocol driver not attached",
 111: "No CSI structure available",
 112: "Level 2 halted",
 113: "Invalid exchange",
 114: "Invalid request descriptor",
 115: "Exchange full",
 116: "No data (for no delay io)",
 117: "Timer expired",
 118: "Out of streams resources",
 119: "Machine is not on the network",
 120: "Package not installed",
 121: "The object is remote",
 122: "Advertise error",
 123: "Srmount error",
 124: "Communication error on send",
 125: "Cross mount point (not really error)",
 126: "Given log. name not unique",
 127: "f.d. invalid for this operation",
 128: "Remote address changed",
 129: "Can   access a needed shared lib",
 130: "Accessing a corrupted shared lib",
 131: ".lib section in a.out corrupted",
 132: "Attempting to link in too many libs",
 133: "Attempting to exec a shared library",
 135: "Streams pipe error",
 136: "Too many users",
 137: "Socket type not supported",
 138: "Not supported",
 139: "Protocol family not supported",
 140: "Can't send after socket shutdown",
 141: "Too many references",
 142: "Host is down",
 148: "No medium (in tape drive)",
 156: "Level 2 not synchronized"
};

var ERRNO_CODES = {};

function withStackSave(f) {
 var stack = stackSave();
 var ret = f();
 stackRestore(stack);
 return ret;
}

function demangle(func) {
 warnOnce("warning: build with -sDEMANGLE_SUPPORT to link in libcxxabi demangling");
 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 + "]";
 });
}

var FS = {
 root: null,
 mounts: [],
 devices: {},
 streams: [],
 nextInode: 1,
 nameTable: null,
 currentPath: "/",
 initialized: false,
 ignorePermissions: true,
 ErrnoError: null,
 genericErrors: {},
 filesystems: null,
 syncFSRequests: 0,
 lookupPath: (path, opts = {}) => {
  path = PATH_FS.resolve(path);
  if (!path) return {
   path: "",
   node: null
  };
  var defaults = {
   follow_mount: true,
   recurse_count: 0
  };
  opts = Object.assign(defaults, opts);
  if (opts.recurse_count > 8) {
   throw new FS.ErrnoError(32);
  }
  var parts = path.split("/").filter(p => !!p);
  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 + 1
     });
     current = lookup.node;
     if (count++ > 40) {
      throw new FS.ErrnoError(32);
     }
    }
   }
  }
  return {
   path: current_path,
   node: current
  };
 },
 getPath: 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: (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: node => {
  var hash = FS.hashName(node.parent.id, node.name);
  node.name_next = FS.nameTable[hash];
  FS.nameTable[hash] = node;
 },
 hashRemoveNode: 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: (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: (parent, name, mode, rdev) => {
  assert(typeof parent == "object");
  var node = new FS.FSNode(parent, name, mode, rdev);
  FS.hashAddNode(node);
  return node;
 },
 destroyNode: node => {
  FS.hashRemoveNode(node);
 },
 isRoot: node => {
  return node === node.parent;
 },
 isMountpoint: node => {
  return !!node.mounted;
 },
 isFile: mode => {
  return (mode & 61440) === 32768;
 },
 isDir: mode => {
  return (mode & 61440) === 16384;
 },
 isLink: mode => {
  return (mode & 61440) === 40960;
 },
 isChrdev: mode => {
  return (mode & 61440) === 8192;
 },
 isBlkdev: mode => {
  return (mode & 61440) === 24576;
 },
 isFIFO: mode => {
  return (mode & 61440) === 4096;
 },
 isSocket: mode => {
  return (mode & 49152) === 49152;
 },
 flagModes: {
  "r": 0,
  "r+": 2,
  "w": 577,
  "w+": 578,
  "a": 1089,
  "a+": 1090
 },
 modeStringToFlags: str => {
  var flags = FS.flagModes[str];
  if (typeof flags == "undefined") {
   throw new Error("Unknown file open mode: " + str);
  }
  return flags;
 },
 flagsToPermissionString: flag => {
  var perms = [ "r", "w", "rw" ][flag & 3];
  if (flag & 512) {
   perms += "w";
  }
  return perms;
 },
 nodePermissions: (node, perms) => {
  if (FS.ignorePermissions) {
   return 0;
  }
  if (perms.includes("r") && !(node.mode & 292)) {
   return 2;
  } else if (perms.includes("w") && !(node.mode & 146)) {
   return 2;
  } else if (perms.includes("x") && !(node.mode & 73)) {
   return 2;
  }
  return 0;
 },
 mayLookup: dir => {
  var errCode = FS.nodePermissions(dir, "x");
  if (errCode) return errCode;
  if (!dir.node_ops.lookup) return 2;
  return 0;
 },
 mayCreate: (dir, name) => {
  try {
   var node = FS.lookupNode(dir, name);
   return 20;
  } catch (e) {}
  return FS.nodePermissions(dir, "wx");
 },
 mayDelete: (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: (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: (fd_start = 0, 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: fd => FS.streams[fd],
 createStream: (stream, fd_start, fd_end) => {
  if (!FS.FSStream) {
   FS.FSStream = function() {
    this.shared = {};
   };
   FS.FSStream.prototype = {};
   Object.defineProperties(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;
     }
    },
    flags: {
     get: function() {
      return this.shared.flags;
     },
     set: function(val) {
      this.shared.flags = val;
     }
    },
    position: {
     get: function() {
      return this.shared.position;
     },
     set: function(val) {
      this.shared.position = val;
     }
    }
   });
  }
  stream = Object.assign(new FS.FSStream(), stream);
  var fd = FS.nextfd(fd_start, fd_end);
  stream.fd = fd;
  FS.streams[fd] = stream;
  return stream;
 },
 closeStream: fd => {
  FS.streams[fd] = null;
 },
 chrdev_stream_ops: {
  open: 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: () => {
   throw new FS.ErrnoError(70);
  }
 },
 major: dev => dev >> 8,
 minor: dev => dev & 255,
 makedev: (ma, mi) => ma << 8 | mi,
 registerDevice: (dev, ops) => {
  FS.devices[dev] = {
   stream_ops: ops
  };
 },
 getDevice: dev => FS.devices[dev],
 getMounts: 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: (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) {
   assert(FS.syncFSRequests > 0);
   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(mount => {
   if (!mount.type.syncfs) {
    return done(null);
   }
   mount.type.syncfs(mount, populate, done);
  });
 },
 mount: (type, opts, mountpoint) => {
  if (typeof type == "string") {
   throw type;
  }
  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: 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(hash => {
   var current = FS.nameTable[hash];
   while (current) {
    var next = current.name_next;
    if (mounts.includes(current.mount)) {
     FS.destroyNode(current);
    }
    current = next;
   }
  });
  node.mounted = null;
  var idx = node.mount.mounts.indexOf(mount);
  assert(idx !== -1);
  node.mount.mounts.splice(idx, 1);
 },
 lookup: (parent, name) => {
  return parent.node_ops.lookup(parent, name);
 },
 mknod: (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: (path, mode) => {
  mode = mode !== undefined ? mode : 438;
  mode &= 4095;
  mode |= 32768;
  return FS.mknod(path, mode, 0);
 },
 mkdir: (path, mode) => {
  mode = mode !== undefined ? mode : 511;
  mode &= 511 | 512;
  mode |= 16384;
  return FS.mknod(path, mode, 0);
 },
 mkdirTree: (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: (path, mode, dev) => {
  if (typeof dev == "undefined") {
   dev = mode;
   mode = 438;
  }
  mode |= 8192;
  return FS.mknod(path, mode, dev);
 },
 symlink: (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: (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;
  lookup = FS.lookupPath(old_path, {
   parent: true
  });
  old_dir = lookup.node;
  lookup = FS.lookupPath(new_path, {
   parent: true
  });
  new_dir = lookup.node;
  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);
   }
  }
  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);
  }
 },
 rmdir: 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);
  }
  parent.node_ops.rmdir(parent, name);
  FS.destroyNode(node);
 },
 readdir: 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: path => {
  var lookup = FS.lookupPath(path, {
   parent: true
  });
  var parent = lookup.node;
  if (!parent) {
   throw new FS.ErrnoError(44);
  }
  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);
  }
  parent.node_ops.unlink(parent, name);
  FS.destroyNode(node);
 },
 readlink: 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: (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: path => {
  return FS.stat(path, true);
 },
 chmod: (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: (path, mode) => {
  FS.chmod(path, mode, true);
 },
 fchmod: (fd, mode) => {
  var stream = FS.getStream(fd);
  if (!stream) {
   throw new FS.ErrnoError(8);
  }
  FS.chmod(stream.node, mode);
 },
 chown: (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: (path, uid, gid) => {
  FS.chown(path, uid, gid, true);
 },
 fchown: (fd, uid, gid) => {
  var stream = FS.getStream(fd);
  if (!stream) {
   throw new FS.ErrnoError(8);
  }
  FS.chown(stream.node, uid, gid);
 },
 truncate: (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: (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: (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: (path, flags, mode) => {
  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 && !created) {
   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
  });
  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;
   }
  }
  return stream;
 },
 close: 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: stream => {
  return stream.fd === null;
 },
 llseek: (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: (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: (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;
  return bytesWritten;
 },
 allocate: (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: (stream, length, position, prot, flags) => {
  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, length, position, prot, flags);
 },
 msync: (stream, buffer, offset, length, mmapFlags) => {
  offset >>>= 0;
  if (!stream.stream_ops.msync) {
   return 0;
  }
  return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
 },
 munmap: stream => 0,
 ioctl: (stream, cmd, arg) => {
  if (!stream.stream_ops.ioctl) {
   throw new FS.ErrnoError(59);
  }
  return stream.stream_ops.ioctl(stream, cmd, arg);
 },
 readFile: (path, opts = {}) => {
  opts.flags = opts.flags || 0;
  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: (path, data, opts = {}) => {
  opts.flags = opts.flags || 577;
  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: () => FS.currentPath,
 chdir: 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: () => {
  FS.mkdir("/tmp");
  FS.mkdir("/home");
  FS.mkdir("/home/web_user");
 },
 createDefaultDevices: () => {
  FS.mkdir("/dev");
  FS.registerDevice(FS.makedev(1, 3), {
   read: () => 0,
   write: (stream, buffer, offset, length, pos) => 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 = getRandomDevice();
  FS.createDevice("/dev", "random", random_device);
  FS.createDevice("/dev", "urandom", random_device);
  FS.mkdir("/dev/shm");
  FS.mkdir("/dev/shm/tmp");
 },
 createSpecialDirectories: () => {
  FS.mkdir("/proc");
  var proc_self = FS.mkdir("/proc/self");
  FS.mkdir("/proc/self/fd");
  FS.mount({
   mount: () => {
    var node = FS.createNode(proc_self, "fd", 16384 | 511, 73);
    node.node_ops = {
     lookup: (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: () => stream.path
       }
      };
      ret.parent = ret;
      return ret;
     }
    };
    return node;
   }
  }, {}, "/proc/self/fd");
 },
 createStandardStreams: () => {
  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", 0);
  var stdout = FS.open("/dev/stdout", 1);
  var stderr = FS.open("/dev/stderr", 1);
  assert(stdin.fd === 0, "invalid handle for stdin (" + stdin.fd + ")");
  assert(stdout.fd === 1, "invalid handle for stdout (" + stdout.fd + ")");
  assert(stderr.fd === 2, "invalid handle for stderr (" + stderr.fd + ")");
 },
 ensureErrnoError: () => {
  if (FS.ErrnoError) return;
  FS.ErrnoError = function ErrnoError(errno, node) {
   this.node = node;
   this.setErrno = function(errno) {
    this.errno = errno;
    for (var key in ERRNO_CODES) {
     if (ERRNO_CODES[key] === errno) {
      this.code = key;
      break;
     }
    }
   };
   this.setErrno(errno);
   this.message = ERRNO_MESSAGES[errno];
   if (this.stack) {
    Object.defineProperty(this, "stack", {
     value: new Error().stack,
     writable: true
    });
    this.stack = demangleAll(this.stack);
   }
  };
  FS.ErrnoError.prototype = new Error();
  FS.ErrnoError.prototype.constructor = FS.ErrnoError;
  [ 44 ].forEach(code => {
   FS.genericErrors[code] = new FS.ErrnoError(code);
   FS.genericErrors[code].stack = "<generic error, no stack>";
  });
 },
 staticInit: () => {
  FS.ensureErrnoError();
  FS.nameTable = new Array(4096);
  FS.mount(MEMFS, {}, "/");
  FS.createDefaultDirectories();
  FS.createDefaultDevices();
  FS.createSpecialDirectories();
  FS.filesystems = {
   "MEMFS": MEMFS
  };
 },
 init: (input, output, error) => {
  assert(!FS.init.initialized, "FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)");
  FS.init.initialized = true;
  FS.ensureErrnoError();
  Module["stdin"] = input || Module["stdin"];
  Module["stdout"] = output || Module["stdout"];
  Module["stderr"] = error || Module["stderr"];
  FS.createStandardStreams();
 },
 quit: () => {
  FS.init.initialized = false;
  _fflush(0);
  for (var i = 0; i < FS.streams.length; i++) {
   var stream = FS.streams[i];
   if (!stream) {
    continue;
   }
   FS.close(stream);
  }
 },
 getMode: (canRead, canWrite) => {
  var mode = 0;
  if (canRead) mode |= 292 | 73;
  if (canWrite) mode |= 146;
  return mode;
 },
 findObject: (path, dontResolveLastLink) => {
  var ret = FS.analyzePath(path, dontResolveLastLink);
  if (!ret.exists) {
   return null;
  }
  return ret.object;
 },
 analyzePath: (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;
 },
 createPath: (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: (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: (parent, name, data, canRead, canWrite, canOwn) => {
  var path = name;
  if (parent) {
   parent = typeof parent == "string" ? parent : FS.getPath(parent);
   path = name ? PATH.join2(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, 577);
   FS.write(stream, data, 0, data.length, 0, canOwn);
   FS.close(stream);
   FS.chmod(node, mode);
  }
  return node;
 },
 createDevice: (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: stream => {
    stream.seekable = false;
   },
   close: stream => {
    if (output && output.buffer && output.buffer.length) {
     output(10);
    }
   },
   read: (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: (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);
 },
 forceLoadFile: obj => {
  if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return 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) {
    throw new FS.ErrnoError(29);
   }
  } else {
   throw new Error("Cannot load without read() or XMLHttpRequest.");
  }
 },
 createLazyFile: (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 = (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);
    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 || []);
    }
    return intArrayFromString(xhr.responseText || "", true);
   };
   var lazyArray = this;
   lazyArray.setDataGetter(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(key => {
   var fn = node.stream_ops[key];
   stream_ops[key] = function forceLoadLazyFile() {
    FS.forceLoadFile(node);
    return fn.apply(null, arguments);
   };
  });
  function writeChunks(stream, buffer, offset, length, position) {
   var contents = stream.node.contents;
   if (position >= contents.length) return 0;
   var size = Math.min(contents.length - position, length);
   assert(size >= 0);
   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;
  }
  stream_ops.read = (stream, buffer, offset, length, position) => {
   FS.forceLoadFile(node);
   return writeChunks(stream, buffer, offset, length, position);
  };
  stream_ops.mmap = (stream, length, position, prot, flags) => {
   FS.forceLoadFile(node);
   var ptr = mmapAlloc(length);
   if (!ptr) {
    throw new FS.ErrnoError(48);
   }
   writeChunks(stream, HEAP8, ptr, length, position);
   return {
    ptr: ptr,
    allocated: true
   };
  };
  node.stream_ops = stream_ops;
  return node;
 },
 createPreloadedFile: (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
  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);
   }
   if (Browser.handledByPreloadPlugin(byteArray, fullname, finish, () => {
    if (onerror) onerror();
    removeRunDependency(dep);
   })) {
    return;
   }
   finish(byteArray);
  }
  addRunDependency(dep);
  if (typeof url == "string") {
   asyncLoad(url, byteArray => processData(byteArray), onerror);
  } else {
   processData(url);
  }
 },
 indexedDB: () => {
  return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
 },
 DB_NAME: () => {
  return "EM_FS_" + window.location.pathname;
 },
 DB_VERSION: 20,
 DB_STORE_NAME: "FILE_DATA",
 saveFilesToDB: (paths, onload, onerror) => {
  onload = onload || (() => {});
  onerror = onerror || (() => {});
  var indexedDB = FS.indexedDB();
  try {
   var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION);
  } catch (e) {
   return onerror(e);
  }
  openRequest.onupgradeneeded = () => {
   out("creating db");
   var db = openRequest.result;
   db.createObjectStore(FS.DB_STORE_NAME);
  };
  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(path => {
    var putRequest = files.put(FS.analyzePath(path).object.contents, path);
    putRequest.onsuccess = () => {
     ok++;
     if (ok + fail == total) finish();
    };
    putRequest.onerror = () => {
     fail++;
     if (ok + fail == total) finish();
    };
   });
   transaction.onerror = onerror;
  };
  openRequest.onerror = onerror;
 },
 loadFilesFromDB: (paths, onload, onerror) => {
  onload = onload || (() => {});
  onerror = onerror || (() => {});
  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 = () => {
   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(path => {
    var getRequest = files.get(path);
    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 = () => {
     fail++;
     if (ok + fail == total) finish();
    };
   });
   transaction.onerror = onerror;
  };
  openRequest.onerror = onerror;
 },
 absolutePath: () => {
  abort("FS.absolutePath has been removed; use PATH_FS.resolve instead");
 },
 createFolder: () => {
  abort("FS.createFolder has been removed; use FS.mkdir instead");
 },
 createLink: () => {
  abort("FS.createLink has been removed; use FS.symlink instead");
 },
 joinPath: () => {
  abort("FS.joinPath has been removed; use PATH.join instead");
 },
 mmapAlloc: () => {
  abort("FS.mmapAlloc has been replaced by the top level function mmapAlloc");
 },
 standardizePath: () => {
  abort("FS.standardizePath has been removed; use PATH.normalize instead");
 }
};

var SYSCALLS = {
 DEFAULT_POLLMASK: 5,
 calculateAt: function(dirfd, path, allowEmpty) {
  if (PATH.isAbs(path)) {
   return path;
  }
  var dir;
  if (dirfd === -100) {
   dir = FS.cwd();
  } else {
   var dirstream = SYSCALLS.getStreamFromFD(dirfd);
   dir = dirstream.path;
  }
  if (path.length == 0) {
   if (!allowEmpty) {
    throw new FS.ErrnoError(44);
   }
   return dir;
  }
  return PATH.join2(dir, 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 + 8 >>> 2] = stat.ino;
  HEAP32[buf + 12 >>> 2] = stat.mode;
  HEAPU32[buf + 16 >>> 2] = stat.nlink;
  HEAP32[buf + 20 >>> 2] = stat.uid;
  HEAP32[buf + 24 >>> 2] = stat.gid;
  HEAP32[buf + 28 >>> 2] = stat.rdev;
  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;
  tempI64 = [ Math.floor(stat.atime.getTime() / 1e3) >>> 0, (tempDouble = Math.floor(stat.atime.getTime() / 1e3), 
  +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 + 56 >>> 2] = tempI64[0], HEAP32[buf + 60 >>> 2] = tempI64[1];
  HEAPU32[buf + 64 >>> 2] = 0;
  tempI64 = [ Math.floor(stat.mtime.getTime() / 1e3) >>> 0, (tempDouble = Math.floor(stat.mtime.getTime() / 1e3), 
  +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 + 72 >>> 2] = tempI64[0], HEAP32[buf + 76 >>> 2] = tempI64[1];
  HEAPU32[buf + 80 >>> 2] = 0;
  tempI64 = [ Math.floor(stat.ctime.getTime() / 1e3) >>> 0, (tempDouble = Math.floor(stat.ctime.getTime() / 1e3), 
  +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 + 88 >>> 2] = tempI64[0], HEAP32[buf + 92 >>> 2] = tempI64[1];
  HEAPU32[buf + 96 >>> 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 + 104 >>> 2] = tempI64[0], HEAP32[buf + 108 >>> 2] = tempI64[1];
  return 0;
 },
 doMsync: function(addr, stream, len, flags, offset) {
  if (!FS.isFile(stream.node.mode)) {
   throw new FS.ErrnoError(43);
  }
  if (flags & 2) {
   return 0;
  }
  addr >>>= 0;
  var buffer = HEAPU8.slice(addr, addr + len);
  FS.msync(stream, buffer, offset, len, flags);
 },
 varargs: undefined,
 get: function() {
  assert(SYSCALLS.varargs != undefined);
  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;
 }
};

function ___syscall_fcntl64(fd, cmd, varargs) {
 SYSCALLS.varargs = varargs;
 try {
  var stream = SYSCALLS.getStreamFromFD(fd);
  switch (cmd) {
  case 0:
   {
    var arg = SYSCALLS.get();
    if (arg < 0) {
     return -28;
    }
    var newStream;
    newStream = FS.createStream(stream, arg);
    return newStream.fd;
   }

  case 1:
  case 2:
   return 0;

  case 3:
   return stream.flags;

  case 4:
   {
    var arg = SYSCALLS.get();
    stream.flags |= arg;
    return 0;
   }

  case 5:
   {
    var arg = SYSCALLS.get();
    var offset = 0;
    HEAP16[arg + offset >>> 1] = 2;
    return 0;
   }

  case 6:
  case 7:
   return 0;

  case 16:
  case 8:
   return -28;

  case 9:
   setErrNo(28);
   return -1;

  default:
   {
    return -28;
   }
  }
 } catch (e) {
  if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e;
  return -e.errno;
 }
}

function ___syscall_ioctl(fd, op, varargs) {
 SYSCALLS.varargs = varargs;
 try {
  var stream = SYSCALLS.getStreamFromFD(fd);
  switch (op) {
  case 21509:
  case 21505:
   {
    if (!stream.tty) return -59;
    return 0;
   }

  case 21510:
  case 21511:
  case 21512:
  case 21506:
  case 21507:
  case 21508:
   {
    if (!stream.tty) return -59;
    return 0;
   }

  case 21519:
   {
    if (!stream.tty) return -59;
    var argp = SYSCALLS.get();
    HEAP32[argp >>> 2] = 0;
    return 0;
   }

  case 21520:
   {
    if (!stream.tty) return -59;
    return -28;
   }

  case 21531:
   {
    var argp = SYSCALLS.get();
    return FS.ioctl(stream, op, argp);
   }

  case 21523:
   {
    if (!stream.tty) return -59;
    return 0;
   }

  case 21524:
   {
    if (!stream.tty) return -59;
    return 0;
   }

  default:
   return -28;
  }
 } catch (e) {
  if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e;
  return -e.errno;
 }
}

function ___syscall_openat(dirfd, path, flags, varargs) {
 SYSCALLS.varargs = varargs;
 try {
  path = SYSCALLS.getStr(path);
  path = SYSCALLS.calculateAt(dirfd, path);
  var mode = varargs ? SYSCALLS.get() : 0;
  return FS.open(path, flags, mode).fd;
 } catch (e) {
  if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e;
  return -e.errno;
 }
}

var nowIsMonotonic = true;

function __emscripten_get_now_is_monotonic() {
 return nowIsMonotonic;
}

function _abort() {
 abort("native code called abort()");
}

function _emscripten_set_main_loop_timing(mode, value) {
 Browser.mainLoop.timingMode = mode;
 Browser.mainLoop.timingValue = value;
 if (!Browser.mainLoop.func) {
  err("emscripten_set_main_loop_timing: Cannot set timing mode for main loop since a main loop does not exist! Call emscripten_set_main_loop first to set one up.");
  return 1;
 }
 if (!Browser.mainLoop.running) {
  Browser.mainLoop.running = true;
 }
 if (mode == 0) {
  Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setTimeout() {
   var timeUntilNextTick = Math.max(0, Browser.mainLoop.tickStartTime + value - _emscripten_get_now()) | 0;
   setTimeout(Browser.mainLoop.runner, timeUntilNextTick);
  };
  Browser.mainLoop.method = "timeout";
 } else if (mode == 1) {
  Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_rAF() {
   Browser.requestAnimationFrame(Browser.mainLoop.runner);
  };
  Browser.mainLoop.method = "rAF";
 } else if (mode == 2) {
  if (typeof setImmediate == "undefined") {
   var setImmediates = [];
   var emscriptenMainLoopMessageId = "setimmediate";
   var Browser_setImmediate_messageHandler = event => {
    if (event.data === emscriptenMainLoopMessageId || event.data.target === emscriptenMainLoopMessageId) {
     event.stopPropagation();
     setImmediates.shift()();
    }
   };
   addEventListener("message", Browser_setImmediate_messageHandler, true);
   setImmediate = function Browser_emulated_setImmediate(func) {
    setImmediates.push(func);
    if (ENVIRONMENT_IS_WORKER) {
     if (Module["setImmediates"] === undefined) Module["setImmediates"] = [];
     Module["setImmediates"].push(func);
     postMessage({
      target: emscriptenMainLoopMessageId
     });
    } else postMessage(emscriptenMainLoopMessageId, "*");
   };
  }
  Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_setImmediate() {
   setImmediate(Browser.mainLoop.runner);
  };
  Browser.mainLoop.method = "immediate";
 }
 return 0;
}

var _emscripten_get_now;

if (ENVIRONMENT_IS_NODE) {
 _emscripten_get_now = () => {
  var t = process["hrtime"]();
  return t[0] * 1e3 + t[1] / 1e6;
 };
} else _emscripten_get_now = () => performance.now();

function _proc_exit(code) {
 EXITSTATUS = code;
 if (!keepRuntimeAlive()) {
  if (Module["onExit"]) Module["onExit"](code);
  ABORT = true;
 }
 quit_(code, new ExitStatus(code));
}

function exitJS(status, implicit) {
 EXITSTATUS = status;
 checkUnflushedContent();
 if (keepRuntimeAlive() && !implicit) {
  var msg = "program exited (with status: " + status + "), but EXIT_RUNTIME is not set, so halting execution but not exiting the runtime or preventing further async execution (build with EXIT_RUNTIME=1, if you want a true shutdown)";
  err(msg);
 }
 _proc_exit(status);
}

var _exit = exitJS;

function handleException(e) {
 if (e instanceof ExitStatus || e == "unwind") {
  return EXITSTATUS;
 }
 checkStackCookie();
 if (e instanceof WebAssembly.RuntimeError) {
  if (_emscripten_stack_get_current() <= 0) {
   err("Stack overflow detected.  You can try increasing -sSTACK_SIZE (currently set to " + STACK_SIZE + ")");
  }
 }
 quit_(1, e);
}

function maybeExit() {}

function setMainLoop(browserIterationFunc, fps, simulateInfiniteLoop, arg, noSetTiming) {
 assert(!Browser.mainLoop.func, "emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters.");
 Browser.mainLoop.func = browserIterationFunc;
 Browser.mainLoop.arg = arg;
 var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop;
 function checkIsRunning() {
  if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) {
   maybeExit();
   return false;
  }
  return true;
 }
 Browser.mainLoop.running = false;
 Browser.mainLoop.runner = function Browser_mainLoop_runner() {
  if (ABORT) return;
  if (Browser.mainLoop.queue.length > 0) {
   var start = Date.now();
   var blocker = Browser.mainLoop.queue.shift();
   blocker.func(blocker.arg);
   if (Browser.mainLoop.remainingBlockers) {
    var remaining = Browser.mainLoop.remainingBlockers;
    var next = remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining);
    if (blocker.counted) {
     Browser.mainLoop.remainingBlockers = next;
    } else {
     next = next + .5;
     Browser.mainLoop.remainingBlockers = (8 * remaining + next) / 9;
    }
   }
   out('main loop blocker "' + blocker.name + '" took ' + (Date.now() - start) + " ms");
   Browser.mainLoop.updateStatus();
   if (!checkIsRunning()) return;
   setTimeout(Browser.mainLoop.runner, 0);
   return;
  }
  if (!checkIsRunning()) return;
  Browser.mainLoop.currentFrameNumber = Browser.mainLoop.currentFrameNumber + 1 | 0;
  if (Browser.mainLoop.timingMode == 1 && Browser.mainLoop.timingValue > 1 && Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue != 0) {
   Browser.mainLoop.scheduler();
   return;
  } else if (Browser.mainLoop.timingMode == 0) {
   Browser.mainLoop.tickStartTime = _emscripten_get_now();
  }
  GL.newRenderingFrameStarted();
  if (Browser.mainLoop.method === "timeout" && Module.ctx) {
   warnOnce("Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!");
   Browser.mainLoop.method = "";
  }
  Browser.mainLoop.runIter(browserIterationFunc);
  checkStackCookie();
  if (!checkIsRunning()) return;
  if (typeof SDL == "object" && SDL.audio && SDL.audio.queueNewAudioData) SDL.audio.queueNewAudioData();
  Browser.mainLoop.scheduler();
 };
 if (!noSetTiming) {
  if (fps && fps > 0) _emscripten_set_main_loop_timing(0, 1e3 / fps); else _emscripten_set_main_loop_timing(1, 1);
  Browser.mainLoop.scheduler();
 }
 if (simulateInfiniteLoop) {
  throw "unwind";
 }
}

function callUserCallback(func) {
 if (ABORT) {
  err("user callback triggered after runtime exited or application aborted.  Ignoring.");
  return;
 }
 try {
  func();
 } catch (e) {
  handleException(e);
 }
}

function safeSetTimeout(func, timeout) {
 return setTimeout(function() {
  callUserCallback(func);
 }, timeout);
}

var Browser = {
 mainLoop: {
  running: false,
  scheduler: null,
  method: "",
  currentlyRunningMainloop: 0,
  func: null,
  arg: 0,
  timingMode: 0,
  timingValue: 0,
  currentFrameNumber: 0,
  queue: [],
  pause: function() {
   Browser.mainLoop.scheduler = null;
   Browser.mainLoop.currentlyRunningMainloop++;
  },
  resume: function() {
   Browser.mainLoop.currentlyRunningMainloop++;
   var timingMode = Browser.mainLoop.timingMode;
   var timingValue = Browser.mainLoop.timingValue;
   var func = Browser.mainLoop.func;
   Browser.mainLoop.func = null;
   setMainLoop(func, 0, false, Browser.mainLoop.arg, true);
   _emscripten_set_main_loop_timing(timingMode, timingValue);
   Browser.mainLoop.scheduler();
  },
  updateStatus: function() {
   if (Module["setStatus"]) {
    var message = Module["statusMessage"] || "Please wait...";
    var remaining = Browser.mainLoop.remainingBlockers;
    var expected = Browser.mainLoop.expectedBlockers;
    if (remaining) {
     if (remaining < expected) {
      Module["setStatus"](message + " (" + (expected - remaining) + "/" + expected + ")");
     } else {
      Module["setStatus"](message);
     }
    } else {
     Module["setStatus"]("");
    }
   }
  },
  runIter: function(func) {
   if (ABORT) return;
   if (Module["preMainLoop"]) {
    var preRet = Module["preMainLoop"]();
    if (preRet === false) {
     return;
    }
   }
   callUserCallback(func);
   if (Module["postMainLoop"]) Module["postMainLoop"]();
  }
 },
 isFullscreen: false,
 pointerLock: false,
 moduleContextCreatedCallbacks: [],
 workers: [],
 init: function() {
  if (!Module["preloadPlugins"]) Module["preloadPlugins"] = [];
  if (Browser.initted) return;
  Browser.initted = true;
  try {
   new Blob();
   Browser.hasBlobConstructor = true;
  } catch (e) {
   Browser.hasBlobConstructor = false;
   err("warning: no blob constructor, cannot create blobs with mimetypes");
  }
  Browser.BlobBuilder = typeof MozBlobBuilder != "undefined" ? MozBlobBuilder : typeof WebKitBlobBuilder != "undefined" ? WebKitBlobBuilder : !Browser.hasBlobConstructor ? err("warning: no BlobBuilder") : null;
  Browser.URLObject = typeof window != "undefined" ? window.URL ? window.URL : window.webkitURL : undefined;
  if (!Module.noImageDecoding && typeof Browser.URLObject == "undefined") {
   err("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.");
   Module.noImageDecoding = true;
  }
  var imagePlugin = {};
  imagePlugin["canHandle"] = function imagePlugin_canHandle(name) {
   return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
  };
  imagePlugin["handle"] = function imagePlugin_handle(byteArray, name, onload, onerror) {
   var b = null;
   if (Browser.hasBlobConstructor) {
    try {
     b = new Blob([ byteArray ], {
      type: Browser.getMimetype(name)
     });
     if (b.size !== byteArray.length) {
      b = new Blob([ new Uint8Array(byteArray).buffer ], {
       type: Browser.getMimetype(name)
      });
     }
    } catch (e) {
     warnOnce("Blob constructor present but fails: " + e + "; falling back to blob builder");
    }
   }
   if (!b) {
    var bb = new Browser.BlobBuilder();
    bb.append(new Uint8Array(byteArray).buffer);
    b = bb.getBlob();
   }
   var url = Browser.URLObject.createObjectURL(b);
   assert(typeof url == "string", "createObjectURL must return a url as a string");
   var img = new Image();
   img.onload = () => {
    assert(img.complete, "Image " + name + " could not be decoded");
    var canvas = document.createElement("canvas");
    canvas.width = img.width;
    canvas.height = img.height;
    var ctx = canvas.getContext("2d");
    ctx.drawImage(img, 0, 0);
    preloadedImages[name] = canvas;
    Browser.URLObject.revokeObjectURL(url);
    if (onload) onload(byteArray);
   };
   img.onerror = event => {
    out("Image " + url + " could not be decoded");
    if (onerror) onerror();
   };
   img.src = url;
  };
  Module["preloadPlugins"].push(imagePlugin);
  var audioPlugin = {};
  audioPlugin["canHandle"] = function audioPlugin_canHandle(name) {
   return !Module.noAudioDecoding && name.substr(-4) in {
    ".ogg": 1,
    ".wav": 1,
    ".mp3": 1
   };
  };
  audioPlugin["handle"] = function audioPlugin_handle(byteArray, name, onload, onerror) {
   var done = false;
   function finish(audio) {
    if (done) return;
    done = true;
    preloadedAudios[name] = audio;
    if (onload) onload(byteArray);
   }
   function fail() {
    if (done) return;
    done = true;
    preloadedAudios[name] = new Audio();
    if (onerror) onerror();
   }
   if (Browser.hasBlobConstructor) {
    try {
     var b = new Blob([ byteArray ], {
      type: Browser.getMimetype(name)
     });
    } catch (e) {
     return fail();
    }
    var url = Browser.URLObject.createObjectURL(b);
    assert(typeof url == "string", "createObjectURL must return a url as a string");
    var audio = new Audio();
    audio.addEventListener("canplaythrough", () => finish(audio), false);
    audio.onerror = function audio_onerror(event) {
     if (done) return;
     err("warning: browser could not fully decode audio " + name + ", trying slower base64 approach");
     function encode64(data) {
      var BASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
      var PAD = "=";
      var ret = "";
      var leftchar = 0;
      var leftbits = 0;
      for (var i = 0; i < data.length; i++) {
       leftchar = leftchar << 8 | data[i];
       leftbits += 8;
       while (leftbits >= 6) {
        var curr = leftchar >> leftbits - 6 & 63;
        leftbits -= 6;
        ret += BASE[curr];
       }
      }
      if (leftbits == 2) {
       ret += BASE[(leftchar & 3) << 4];
       ret += PAD + PAD;
      } else if (leftbits == 4) {
       ret += BASE[(leftchar & 15) << 2];
       ret += PAD;
      }
      return ret;
     }
     audio.src = "data:audio/x-" + name.substr(-3) + ";base64," + encode64(byteArray);
     finish(audio);
    };
    audio.src = url;
    safeSetTimeout(function() {
     finish(audio);
    }, 1e4);
   } else {
    return fail();
   }
  };
  Module["preloadPlugins"].push(audioPlugin);
  function pointerLockChange() {
   Browser.pointerLock = document["pointerLockElement"] === Module["canvas"] || document["mozPointerLockElement"] === Module["canvas"] || document["webkitPointerLockElement"] === Module["canvas"] || document["msPointerLockElement"] === Module["canvas"];
  }
  var canvas = Module["canvas"];
  if (canvas) {
   canvas.requestPointerLock = canvas["requestPointerLock"] || canvas["mozRequestPointerLock"] || canvas["webkitRequestPointerLock"] || canvas["msRequestPointerLock"] || (() => {});
   canvas.exitPointerLock = document["exitPointerLock"] || document["mozExitPointerLock"] || document["webkitExitPointerLock"] || document["msExitPointerLock"] || (() => {});
   canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
   document.addEventListener("pointerlockchange", pointerLockChange, false);
   document.addEventListener("mozpointerlockchange", pointerLockChange, false);
   document.addEventListener("webkitpointerlockchange", pointerLockChange, false);
   document.addEventListener("mspointerlockchange", pointerLockChange, false);
   if (Module["elementPointerLock"]) {
    canvas.addEventListener("click", ev => {
     if (!Browser.pointerLock && Module["canvas"].requestPointerLock) {
      Module["canvas"].requestPointerLock();
      ev.preventDefault();
     }
    }, false);
   }
  }
 },
 handledByPreloadPlugin: function(byteArray, fullname, finish, onerror) {
  Browser.init();
  var handled = false;
  Module["preloadPlugins"].forEach(function(plugin) {
   if (handled) return;
   if (plugin["canHandle"](fullname)) {
    plugin["handle"](byteArray, fullname, finish, onerror);
    handled = true;
   }
  });
  return handled;
 },
 createContext: function(canvas, useWebGL, setInModule, webGLContextAttributes) {
  if (useWebGL && Module.ctx && canvas == Module.canvas) return Module.ctx;
  var ctx;
  var contextHandle;
  if (useWebGL) {
   var contextAttributes = {
    antialias: false,
    alpha: false,
    majorVersion: 2
   };
   if (webGLContextAttributes) {
    for (var attribute in webGLContextAttributes) {
     contextAttributes[attribute] = webGLContextAttributes[attribute];
    }
   }
   if (typeof GL != "undefined") {
    contextHandle = GL.createContext(canvas, contextAttributes);
    if (contextHandle) {
     ctx = GL.getContext(contextHandle).GLctx;
    }
   }
  } else {
   ctx = canvas.getContext("2d");
  }
  if (!ctx) return null;
  if (setInModule) {
   if (!useWebGL) assert(typeof GLctx == "undefined", "cannot set in module if GLctx is used, but we are a non-GL context that would replace it");
   Module.ctx = ctx;
   if (useWebGL) GL.makeContextCurrent(contextHandle);
   Module.useWebGL = useWebGL;
   Browser.moduleContextCreatedCallbacks.forEach(function(callback) {
    callback();
   });
   Browser.init();
  }
  return ctx;
 },
 destroyContext: function(canvas, useWebGL, setInModule) {},
 fullscreenHandlersInstalled: false,
 lockPointer: undefined,
 resizeCanvas: undefined,
 requestFullscreen: function(lockPointer, resizeCanvas) {
  Browser.lockPointer = lockPointer;
  Browser.resizeCanvas = resizeCanvas;
  if (typeof Browser.lockPointer == "undefined") Browser.lockPointer = true;
  if (typeof Browser.resizeCanvas == "undefined") Browser.resizeCanvas = false;
  var canvas = Module["canvas"];
  function fullscreenChange() {
   Browser.isFullscreen = false;
   var canvasContainer = canvas.parentNode;
   if ((document["fullscreenElement"] || document["mozFullScreenElement"] || document["msFullscreenElement"] || document["webkitFullscreenElement"] || document["webkitCurrentFullScreenElement"]) === canvasContainer) {
    canvas.exitFullscreen = Browser.exitFullscreen;
    if (Browser.lockPointer) canvas.requestPointerLock();
    Browser.isFullscreen = true;
    if (Browser.resizeCanvas) {
     Browser.setFullscreenCanvasSize();
    } else {
     Browser.updateCanvasDimensions(canvas);
    }
   } else {
    canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
    canvasContainer.parentNode.removeChild(canvasContainer);
    if (Browser.resizeCanvas) {
     Browser.setWindowedCanvasSize();
    } else {
     Browser.updateCanvasDimensions(canvas);
    }
   }
   if (Module["onFullScreen"]) Module["onFullScreen"](Browser.isFullscreen);
   if (Module["onFullscreen"]) Module["onFullscreen"](Browser.isFullscreen);
  }
  if (!Browser.fullscreenHandlersInstalled) {
   Browser.fullscreenHandlersInstalled = true;
   document.addEventListener("fullscreenchange", fullscreenChange, false);
   document.addEventListener("mozfullscreenchange", fullscreenChange, false);
   document.addEventListener("webkitfullscreenchange", fullscreenChange, false);
   document.addEventListener("MSFullscreenChange", fullscreenChange, false);
  }
  var canvasContainer = document.createElement("div");
  canvas.parentNode.insertBefore(canvasContainer, canvas);
  canvasContainer.appendChild(canvas);
  canvasContainer.requestFullscreen = canvasContainer["requestFullscreen"] || canvasContainer["mozRequestFullScreen"] || canvasContainer["msRequestFullscreen"] || (canvasContainer["webkitRequestFullscreen"] ? () => canvasContainer["webkitRequestFullscreen"](Element["ALLOW_KEYBOARD_INPUT"]) : null) || (canvasContainer["webkitRequestFullScreen"] ? () => canvasContainer["webkitRequestFullScreen"](Element["ALLOW_KEYBOARD_INPUT"]) : null);
  canvasContainer.requestFullscreen();
 },
 requestFullScreen: function() {
  abort("Module.requestFullScreen has been replaced by Module.requestFullscreen (without a capital S)");
 },
 exitFullscreen: function() {
  if (!Browser.isFullscreen) {
   return false;
  }
  var CFS = document["exitFullscreen"] || document["cancelFullScreen"] || document["mozCancelFullScreen"] || document["msExitFullscreen"] || document["webkitCancelFullScreen"] || function() {};
  CFS.apply(document, []);
  return true;
 },
 nextRAF: 0,
 fakeRequestAnimationFrame: function(func) {
  var now = Date.now();
  if (Browser.nextRAF === 0) {
   Browser.nextRAF = now + 1e3 / 60;
  } else {
   while (now + 2 >= Browser.nextRAF) {
    Browser.nextRAF += 1e3 / 60;
   }
  }
  var delay = Math.max(Browser.nextRAF - now, 0);
  setTimeout(func, delay);
 },
 requestAnimationFrame: function(func) {
  if (typeof requestAnimationFrame == "function") {
   requestAnimationFrame(func);
   return;
  }
  var RAF = Browser.fakeRequestAnimationFrame;
  RAF(func);
 },
 safeSetTimeout: function(func, timeout) {
  return safeSetTimeout(func, timeout);
 },
 safeRequestAnimationFrame: function(func) {
  return Browser.requestAnimationFrame(function() {
   callUserCallback(func);
  });
 },
 getMimetype: function(name) {
  return {
   "jpg": "image/jpeg",
   "jpeg": "image/jpeg",
   "png": "image/png",
   "bmp": "image/bmp",
   "ogg": "audio/ogg",
   "wav": "audio/wav",
   "mp3": "audio/mpeg"
  }[name.substr(name.lastIndexOf(".") + 1)];
 },
 getUserMedia: function(func) {
  if (!window.getUserMedia) {
   window.getUserMedia = navigator["getUserMedia"] || navigator["mozGetUserMedia"];
  }
  window.getUserMedia(func);
 },
 getMovementX: function(event) {
  return event["movementX"] || event["mozMovementX"] || event["webkitMovementX"] || 0;
 },
 getMovementY: function(event) {
  return event["movementY"] || event["mozMovementY"] || event["webkitMovementY"] || 0;
 },
 getMouseWheelDelta: function(event) {
  var delta = 0;
  switch (event.type) {
  case "DOMMouseScroll":
   delta = event.detail / 3;
   break;

  case "mousewheel":
   delta = event.wheelDelta / 120;
   break;

  case "wheel":
   delta = event.deltaY;
   switch (event.deltaMode) {
   case 0:
    delta /= 100;
    break;

   case 1:
    delta /= 3;
    break;

   case 2:
    delta *= 80;
    break;

   default:
    throw "unrecognized mouse wheel delta mode: " + event.deltaMode;
   }
   break;

  default:
   throw "unrecognized mouse wheel event: " + event.type;
  }
  return delta;
 },
 mouseX: 0,
 mouseY: 0,
 mouseMovementX: 0,
 mouseMovementY: 0,
 touches: {},
 lastTouches: {},
 calculateMouseEvent: function(event) {
  if (Browser.pointerLock) {
   if (event.type != "mousemove" && "mozMovementX" in event) {
    Browser.mouseMovementX = Browser.mouseMovementY = 0;
   } else {
    Browser.mouseMovementX = Browser.getMovementX(event);
    Browser.mouseMovementY = Browser.getMovementY(event);
   }
   if (typeof SDL != "undefined") {
    Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
    Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
   } else {
    Browser.mouseX += Browser.mouseMovementX;
    Browser.mouseY += Browser.mouseMovementY;
   }
  } else {
   var rect = Module["canvas"].getBoundingClientRect();
   var cw = Module["canvas"].width;
   var ch = Module["canvas"].height;
   var scrollX = typeof window.scrollX != "undefined" ? window.scrollX : window.pageXOffset;
   var scrollY = typeof window.scrollY != "undefined" ? window.scrollY : window.pageYOffset;
   assert(typeof scrollX != "undefined" && typeof scrollY != "undefined", "Unable to retrieve scroll position, mouse positions likely broken.");
   if (event.type === "touchstart" || event.type === "touchend" || event.type === "touchmove") {
    var touch = event.touch;
    if (touch === undefined) {
     return;
    }
    var adjustedX = touch.pageX - (scrollX + rect.left);
    var adjustedY = touch.pageY - (scrollY + rect.top);
    adjustedX = adjustedX * (cw / rect.width);
    adjustedY = adjustedY * (ch / rect.height);
    var coords = {
     x: adjustedX,
     y: adjustedY
    };
    if (event.type === "touchstart") {
     Browser.lastTouches[touch.identifier] = coords;
     Browser.touches[touch.identifier] = coords;
    } else if (event.type === "touchend" || event.type === "touchmove") {
     var last = Browser.touches[touch.identifier];
     if (!last) last = coords;
     Browser.lastTouches[touch.identifier] = last;
     Browser.touches[touch.identifier] = coords;
    }
    return;
   }
   var x = event.pageX - (scrollX + rect.left);
   var y = event.pageY - (scrollY + rect.top);
   x = x * (cw / rect.width);
   y = y * (ch / rect.height);
   Browser.mouseMovementX = x - Browser.mouseX;
   Browser.mouseMovementY = y - Browser.mouseY;
   Browser.mouseX = x;
   Browser.mouseY = y;
  }
 },
 resizeListeners: [],
 updateResizeListeners: function() {
  var canvas = Module["canvas"];
  Browser.resizeListeners.forEach(function(listener) {
   listener(canvas.width, canvas.height);
  });
 },
 setCanvasSize: function(width, height, noUpdates) {
  var canvas = Module["canvas"];
  Browser.updateCanvasDimensions(canvas, width, height);
  if (!noUpdates) Browser.updateResizeListeners();
 },
 windowedWidth: 0,
 windowedHeight: 0,
 setFullscreenCanvasSize: function() {
  if (typeof SDL != "undefined") {
   var flags = HEAPU32[SDL.screen >>> 2];
   flags = flags | 8388608;
   HEAP32[SDL.screen >>> 2] = flags;
  }
  Browser.updateCanvasDimensions(Module["canvas"]);
  Browser.updateResizeListeners();
 },
 setWindowedCanvasSize: function() {
  if (typeof SDL != "undefined") {
   var flags = HEAPU32[SDL.screen >>> 2];
   flags = flags & ~8388608;
   HEAP32[SDL.screen >>> 2] = flags;
  }
  Browser.updateCanvasDimensions(Module["canvas"]);
  Browser.updateResizeListeners();
 },
 updateCanvasDimensions: function(canvas, wNative, hNative) {
  if (wNative && hNative) {
   canvas.widthNative = wNative;
   canvas.heightNative = hNative;
  } else {
   wNative = canvas.widthNative;
   hNative = canvas.heightNative;
  }
  var w = wNative;
  var h = hNative;
  if (Module["forcedAspectRatio"] && Module["forcedAspectRatio"] > 0) {
   if (w / h < Module["forcedAspectRatio"]) {
    w = Math.round(h * Module["forcedAspectRatio"]);
   } else {
    h = Math.round(w / Module["forcedAspectRatio"]);
   }
  }
  if ((document["fullscreenElement"] || document["mozFullScreenElement"] || document["msFullscreenElement"] || document["webkitFullscreenElement"] || document["webkitCurrentFullScreenElement"]) === canvas.parentNode && typeof screen != "undefined") {
   var factor = Math.min(screen.width / w, screen.height / h);
   w = Math.round(w * factor);
   h = Math.round(h * factor);
  }
  if (Browser.resizeCanvas) {
   if (canvas.width != w) canvas.width = w;
   if (canvas.height != h) canvas.height = h;
   if (typeof canvas.style != "undefined") {
    canvas.style.removeProperty("width");
    canvas.style.removeProperty("height");
   }
  } else {
   if (canvas.width != wNative) canvas.width = wNative;
   if (canvas.height != hNative) canvas.height = hNative;
   if (typeof canvas.style != "undefined") {
    if (w != wNative || h != hNative) {
     canvas.style.setProperty("width", w + "px", "important");
     canvas.style.setProperty("height", h + "px", "important");
    } else {
     canvas.style.removeProperty("width");
     canvas.style.removeProperty("height");
    }
   }
  }
 }
};

var EGL = {
 errorCode: 12288,
 defaultDisplayInitialized: false,
 currentContext: 0,
 currentReadSurface: 0,
 currentDrawSurface: 0,
 contextAttributes: {
  alpha: false,
  depth: false,
  stencil: false,
  antialias: false
 },
 stringCache: {},
 setErrorCode: function(code) {
  EGL.errorCode = code;
 },
 chooseConfig: function(display, attribList, config, config_size, numConfigs) {
  if (display != 62e3) {
   EGL.setErrorCode(12296);
   return 0;
  }
  if (attribList) {
   for (;;) {
    var param = HEAP32[attribList >>> 2];
    if (param == 12321) {
     var alphaSize = HEAP32[attribList + 4 >>> 2];
     EGL.contextAttributes.alpha = alphaSize > 0;
    } else if (param == 12325) {
     var depthSize = HEAP32[attribList + 4 >>> 2];
     EGL.contextAttributes.depth = depthSize > 0;
    } else if (param == 12326) {
     var stencilSize = HEAP32[attribList + 4 >>> 2];
     EGL.contextAttributes.stencil = stencilSize > 0;
    } else if (param == 12337) {
     var samples = HEAP32[attribList + 4 >>> 2];
     EGL.contextAttributes.antialias = samples > 0;
    } else if (param == 12338) {
     var samples = HEAP32[attribList + 4 >>> 2];
     EGL.contextAttributes.antialias = samples == 1;
    } else if (param == 12544) {
     var requestedPriority = HEAP32[attribList + 4 >>> 2];
     EGL.contextAttributes.lowLatency = requestedPriority != 12547;
    } else if (param == 12344) {
     break;
    }
    attribList += 8;
   }
  }
  if ((!config || !config_size) && !numConfigs) {
   EGL.setErrorCode(12300);
   return 0;
  }
  if (numConfigs) {
   HEAP32[numConfigs >>> 2] = 1;
  }
  if (config && config_size > 0) {
   HEAP32[config >>> 2] = 62002;
  }
  EGL.setErrorCode(12288);
  return 1;
 }
};

function _eglBindAPI(api) {
 if (api == 12448) {
  EGL.setErrorCode(12288);
  return 1;
 }
 EGL.setErrorCode(12300);
 return 0;
}

function _eglChooseConfig(display, attrib_list, configs, config_size, numConfigs) {
 return EGL.chooseConfig(display, attrib_list, configs, config_size, numConfigs);
}

function __webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(ctx) {
 return !!(ctx.dibvbi = ctx.getExtension("WEBGL_draw_instanced_base_vertex_base_instance"));
}

function __webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(ctx) {
 return !!(ctx.mdibvbi = ctx.getExtension("WEBGL_multi_draw_instanced_base_vertex_base_instance"));
}

function __webgl_enable_WEBGL_multi_draw(ctx) {
 return !!(ctx.multiDrawWebgl = ctx.getExtension("WEBGL_multi_draw"));
}

var GL = {
 counter: 1,
 buffers: [],
 mappedBuffers: {},
 programs: [],
 framebuffers: [],
 renderbuffers: [],
 textures: [],
 shaders: [],
 vaos: [],
 contexts: [],
 offscreenCanvases: {},
 queries: [],
 samplers: [],
 transformFeedbacks: [],
 syncs: [],
 byteSizeByTypeRoot: 5120,
 byteSizeByType: [ 1, 1, 2, 2, 4, 4, 4, 2, 3, 4, 8 ],
 stringCache: {},
 stringiCache: {},
 unpackAlignment: 4,
 recordError: function recordError(errorCode) {
  if (!GL.lastError) {
   GL.lastError = errorCode;
  }
 },
 getNewId: function(table) {
  var ret = GL.counter++;
  for (var i = table.length; i < ret; i++) {
   table[i] = null;
  }
  return ret;
 },
 MAX_TEMP_BUFFER_SIZE: 2097152,
 numTempVertexBuffersPerSize: 64,
 log2ceilLookup: function(i) {
  return 32 - Math.clz32(i === 0 ? 0 : i - 1);
 },
 generateTempBuffers: function(quads, context) {
  var largestIndex = GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE);
  context.tempVertexBufferCounters1 = [];
  context.tempVertexBufferCounters2 = [];
  context.tempVertexBufferCounters1.length = context.tempVertexBufferCounters2.length = largestIndex + 1;
  context.tempVertexBuffers1 = [];
  context.tempVertexBuffers2 = [];
  context.tempVertexBuffers1.length = context.tempVertexBuffers2.length = largestIndex + 1;
  context.tempIndexBuffers = [];
  context.tempIndexBuffers.length = largestIndex + 1;
  for (var i = 0; i <= largestIndex; ++i) {
   context.tempIndexBuffers[i] = null;
   context.tempVertexBufferCounters1[i] = context.tempVertexBufferCounters2[i] = 0;
   var ringbufferLength = GL.numTempVertexBuffersPerSize;
   context.tempVertexBuffers1[i] = [];
   context.tempVertexBuffers2[i] = [];
   var ringbuffer1 = context.tempVertexBuffers1[i];
   var ringbuffer2 = context.tempVertexBuffers2[i];
   ringbuffer1.length = ringbuffer2.length = ringbufferLength;
   for (var j = 0; j < ringbufferLength; ++j) {
    ringbuffer1[j] = ringbuffer2[j] = null;
   }
  }
  if (quads) {
   context.tempQuadIndexBuffer = GLctx.createBuffer();
   context.GLctx.bindBuffer(34963, context.tempQuadIndexBuffer);
   var numIndexes = GL.MAX_TEMP_BUFFER_SIZE >> 1;
   var quadIndexes = new Uint16Array(numIndexes);
   var i = 0, v = 0;
   while (1) {
    quadIndexes[i++] = v;
    if (i >= numIndexes) break;
    quadIndexes[i++] = v + 1;
    if (i >= numIndexes) break;
    quadIndexes[i++] = v + 2;
    if (i >= numIndexes) break;
    quadIndexes[i++] = v;
    if (i >= numIndexes) break;
    quadIndexes[i++] = v + 2;
    if (i >= numIndexes) break;
    quadIndexes[i++] = v + 3;
    if (i >= numIndexes) break;
    v += 4;
   }
   context.GLctx.bufferData(34963, quadIndexes, 35044);
   context.GLctx.bindBuffer(34963, null);
  }
 },
 getTempVertexBuffer: function getTempVertexBuffer(sizeBytes) {
  var idx = GL.log2ceilLookup(sizeBytes);
  var ringbuffer = GL.currentContext.tempVertexBuffers1[idx];
  var nextFreeBufferIndex = GL.currentContext.tempVertexBufferCounters1[idx];
  GL.currentContext.tempVertexBufferCounters1[idx] = GL.currentContext.tempVertexBufferCounters1[idx] + 1 & GL.numTempVertexBuffersPerSize - 1;
  var vbo = ringbuffer[nextFreeBufferIndex];
  if (vbo) {
   return vbo;
  }
  var prevVBO = GLctx.getParameter(34964);
  ringbuffer[nextFreeBufferIndex] = GLctx.createBuffer();
  GLctx.bindBuffer(34962, ringbuffer[nextFreeBufferIndex]);
  GLctx.bufferData(34962, 1 << idx, 35048);
  GLctx.bindBuffer(34962, prevVBO);
  return ringbuffer[nextFreeBufferIndex];
 },
 getTempIndexBuffer: function getTempIndexBuffer(sizeBytes) {
  var idx = GL.log2ceilLookup(sizeBytes);
  var ibo = GL.currentContext.tempIndexBuffers[idx];
  if (ibo) {
   return ibo;
  }
  var prevIBO = GLctx.getParameter(34965);
  GL.currentContext.tempIndexBuffers[idx] = GLctx.createBuffer();
  GLctx.bindBuffer(34963, GL.currentContext.tempIndexBuffers[idx]);
  GLctx.bufferData(34963, 1 << idx, 35048);
  GLctx.bindBuffer(34963, prevIBO);
  return GL.currentContext.tempIndexBuffers[idx];
 },
 newRenderingFrameStarted: function newRenderingFrameStarted() {
  if (!GL.currentContext) {
   return;
  }
  var vb = GL.currentContext.tempVertexBuffers1;
  GL.currentContext.tempVertexBuffers1 = GL.currentContext.tempVertexBuffers2;
  GL.currentContext.tempVertexBuffers2 = vb;
  vb = GL.currentContext.tempVertexBufferCounters1;
  GL.currentContext.tempVertexBufferCounters1 = GL.currentContext.tempVertexBufferCounters2;
  GL.currentContext.tempVertexBufferCounters2 = vb;
  var largestIndex = GL.log2ceilLookup(GL.MAX_TEMP_BUFFER_SIZE);
  for (var i = 0; i <= largestIndex; ++i) {
   GL.currentContext.tempVertexBufferCounters1[i] = 0;
  }
 },
 getSource: function(shader, count, string, length) {
  var source = "";
  for (var i = 0; i < count; ++i) {
   var len = length ? HEAP32[length + i * 4 >>> 2] : -1;
   source += UTF8ToString(HEAP32[string + i * 4 >>> 2], len < 0 ? undefined : len);
  }
  return source;
 },
 calcBufLength: function calcBufLength(size, type, stride, count) {
  if (stride > 0) {
   return count * stride;
  }
  var typeSize = GL.byteSizeByType[type - GL.byteSizeByTypeRoot];
  return size * typeSize * count;
 },
 usedTempBuffers: [],
 preDrawHandleClientVertexAttribBindings: function preDrawHandleClientVertexAttribBindings(count) {
  GL.resetBufferBinding = false;
  for (var i = 0; i < GL.currentContext.maxVertexAttribs; ++i) {
   var cb = GL.currentContext.clientBuffers[i];
   if (!cb.clientside || !cb.enabled) continue;
   GL.resetBufferBinding = true;
   var size = GL.calcBufLength(cb.size, cb.type, cb.stride, count);
   var buf = GL.getTempVertexBuffer(size);
   GLctx.bindBuffer(34962, buf);
   GLctx.bufferSubData(34962, 0, HEAPU8.subarray(cb.ptr >>> 0, cb.ptr + size >>> 0));
   cb.vertexAttribPointerAdaptor.call(GLctx, i, cb.size, cb.type, cb.normalized, cb.stride, 0);
  }
 },
 postDrawHandleClientVertexAttribBindings: function postDrawHandleClientVertexAttribBindings() {
  if (GL.resetBufferBinding) {
   GLctx.bindBuffer(34962, GL.buffers[GLctx.currentArrayBufferBinding]);
  }
 },
 createContext: function(canvas, webGLContextAttributes) {
  if (!canvas.getContextSafariWebGL2Fixed) {
   canvas.getContextSafariWebGL2Fixed = canvas.getContext;
   function fixedGetContext(ver, attrs) {
    var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs);
    return ver == "webgl" == gl instanceof WebGLRenderingContext ? gl : null;
   }
   canvas.getContext = fixedGetContext;
  }
  var ctx = canvas.getContext("webgl2", webGLContextAttributes);
  if (!ctx) return 0;
  var handle = GL.registerContext(ctx, webGLContextAttributes);
  return handle;
 },
 registerContext: function(ctx, webGLContextAttributes) {
  var handle = GL.getNewId(GL.contexts);
  var context = {
   handle: handle,
   attributes: webGLContextAttributes,
   version: webGLContextAttributes.majorVersion,
   GLctx: ctx
  };
  if (ctx.canvas) ctx.canvas.GLctxObject = context;
  GL.contexts[handle] = context;
  if (typeof webGLContextAttributes.enableExtensionsByDefault == "undefined" || webGLContextAttributes.enableExtensionsByDefault) {
   GL.initExtensions(context);
  }
  context.maxVertexAttribs = context.GLctx.getParameter(34921);
  context.clientBuffers = [];
  for (var i = 0; i < context.maxVertexAttribs; i++) {
   context.clientBuffers[i] = {
    enabled: false,
    clientside: false,
    size: 0,
    type: 0,
    normalized: 0,
    stride: 0,
    ptr: 0,
    vertexAttribPointerAdaptor: null
   };
  }
  GL.generateTempBuffers(false, context);
  return handle;
 },
 makeContextCurrent: function(contextHandle) {
  GL.currentContext = GL.contexts[contextHandle];
  Module.ctx = GLctx = GL.currentContext && GL.currentContext.GLctx;
  return !(contextHandle && !GLctx);
 },
 getContext: function(contextHandle) {
  return GL.contexts[contextHandle];
 },
 deleteContext: function(contextHandle) {
  if (GL.currentContext === GL.contexts[contextHandle]) GL.currentContext = null;
  if (typeof JSEvents == "object") JSEvents.removeAllHandlersOnTarget(GL.contexts[contextHandle].GLctx.canvas);
  if (GL.contexts[contextHandle] && GL.contexts[contextHandle].GLctx.canvas) GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined;
  GL.contexts[contextHandle] = null;
 },
 initExtensions: function(context) {
  if (!context) context = GL.currentContext;
  if (context.initExtensionsDone) return;
  context.initExtensionsDone = true;
  var GLctx = context.GLctx;
  __webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx);
  __webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx);
  if (context.version >= 2) {
   GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query_webgl2");
  }
  if (context.version < 2 || !GLctx.disjointTimerQueryExt) {
   GLctx.disjointTimerQueryExt = GLctx.getExtension("EXT_disjoint_timer_query");
  }
  __webgl_enable_WEBGL_multi_draw(GLctx);
  var exts = GLctx.getSupportedExtensions() || [];
  exts.forEach(function(ext) {
   if (!ext.includes("lose_context") && !ext.includes("debug")) {
    GLctx.getExtension(ext);
   }
  });
 }
};

function _eglCreateContext(display, config, hmm, contextAttribs) {
 if (display != 62e3) {
  EGL.setErrorCode(12296);
  return 0;
 }
 var glesContextVersion = 1;
 for (;;) {
  var param = HEAP32[contextAttribs >>> 2];
  if (param == 12440) {
   glesContextVersion = HEAP32[contextAttribs + 4 >>> 2];
  } else if (param == 12344) {
   break;
  } else {
   EGL.setErrorCode(12292);
   return 0;
  }
  contextAttribs += 8;
 }
 if (glesContextVersion < 2 || glesContextVersion > 3) {
  EGL.setErrorCode(12293);
  return 0;
 }
 EGL.contextAttributes.majorVersion = glesContextVersion - 1;
 EGL.contextAttributes.minorVersion = 0;
 EGL.context = GL.createContext(Module["canvas"], EGL.contextAttributes);
 if (EGL.context != 0) {
  EGL.setErrorCode(12288);
  GL.makeContextCurrent(EGL.context);
  Module.useWebGL = true;
  Browser.moduleContextCreatedCallbacks.forEach(function(callback) {
   callback();
  });
  GL.makeContextCurrent(null);
  return 62004;
 } else {
  EGL.setErrorCode(12297);
  return 0;
 }
}

function _eglCreateWindowSurface(display, config, win, attrib_list) {
 if (display != 62e3) {
  EGL.setErrorCode(12296);
  return 0;
 }
 if (config != 62002) {
  EGL.setErrorCode(12293);
  return 0;
 }
 EGL.setErrorCode(12288);
 return 62006;
}

function _eglDestroyContext(display, context) {
 if (display != 62e3) {
  EGL.setErrorCode(12296);
  return 0;
 }
 if (context != 62004) {
  EGL.setErrorCode(12294);
  return 0;
 }
 GL.deleteContext(EGL.context);
 EGL.setErrorCode(12288);
 if (EGL.currentContext == context) {
  EGL.currentContext = 0;
 }
 return 1;
}

function _eglDestroySurface(display, surface) {
 if (display != 62e3) {
  EGL.setErrorCode(12296);
  return 0;
 }
 if (surface != 62006) {
  EGL.setErrorCode(12301);
  return 1;
 }
 if (EGL.currentReadSurface == surface) {
  EGL.currentReadSurface = 0;
 }
 if (EGL.currentDrawSurface == surface) {
  EGL.currentDrawSurface = 0;
 }
 EGL.setErrorCode(12288);
 return 1;
}

function _eglGetConfigAttrib(display, config, attribute, value) {
 if (display != 62e3) {
  EGL.setErrorCode(12296);
  return 0;
 }
 if (config != 62002) {
  EGL.setErrorCode(12293);
  return 0;
 }
 if (!value) {
  EGL.setErrorCode(12300);
  return 0;
 }
 EGL.setErrorCode(12288);
 switch (attribute) {
 case 12320:
  HEAP32[value >>> 2] = EGL.contextAttributes.alpha ? 32 : 24;
  return 1;

 case 12321:
  HEAP32[value >>> 2] = EGL.contextAttributes.alpha ? 8 : 0;
  return 1;

 case 12322:
  HEAP32[value >>> 2] = 8;
  return 1;

 case 12323:
  HEAP32[value >>> 2] = 8;
  return 1;

 case 12324:
  HEAP32[value >>> 2] = 8;
  return 1;

 case 12325:
  HEAP32[value >>> 2] = EGL.contextAttributes.depth ? 24 : 0;
  return 1;

 case 12326:
  HEAP32[value >>> 2] = EGL.contextAttributes.stencil ? 8 : 0;
  return 1;

 case 12327:
  HEAP32[value >>> 2] = 12344;
  return 1;

 case 12328:
  HEAP32[value >>> 2] = 62002;
  return 1;

 case 12329:
  HEAP32[value >>> 2] = 0;
  return 1;

 case 12330:
  HEAP32[value >>> 2] = 4096;
  return 1;

 case 12331:
  HEAP32[value >>> 2] = 16777216;
  return 1;

 case 12332:
  HEAP32[value >>> 2] = 4096;
  return 1;

 case 12333:
  HEAP32[value >>> 2] = 0;
  return 1;

 case 12334:
  HEAP32[value >>> 2] = 0;
  return 1;

 case 12335:
  HEAP32[value >>> 2] = 12344;
  return 1;

 case 12337:
  HEAP32[value >>> 2] = EGL.contextAttributes.antialias ? 4 : 0;
  return 1;

 case 12338:
  HEAP32[value >>> 2] = EGL.contextAttributes.antialias ? 1 : 0;
  return 1;

 case 12339:
  HEAP32[value >>> 2] = 4;
  return 1;

 case 12340:
  HEAP32[value >>> 2] = 12344;
  return 1;

 case 12341:
 case 12342:
 case 12343:
  HEAP32[value >>> 2] = -1;
  return 1;

 case 12345:
 case 12346:
  HEAP32[value >>> 2] = 0;
  return 1;

 case 12347:
  HEAP32[value >>> 2] = 0;
  return 1;

 case 12348:
  HEAP32[value >>> 2] = 1;
  return 1;

 case 12349:
 case 12350:
  HEAP32[value >>> 2] = 0;
  return 1;

 case 12351:
  HEAP32[value >>> 2] = 12430;
  return 1;

 case 12352:
  HEAP32[value >>> 2] = 4;
  return 1;

 case 12354:
  HEAP32[value >>> 2] = 0;
  return 1;

 default:
  EGL.setErrorCode(12292);
  return 0;
 }
}

function _eglGetDisplay(nativeDisplayType) {
 EGL.setErrorCode(12288);
 return 62e3;
}

function _eglGetError() {
 return EGL.errorCode;
}

function _eglInitialize(display, majorVersion, minorVersion) {
 if (display != 62e3) {
  EGL.setErrorCode(12296);
  return 0;
 }
 if (majorVersion) {
  HEAP32[majorVersion >>> 2] = 1;
 }
 if (minorVersion) {
  HEAP32[minorVersion >>> 2] = 4;
 }
 EGL.defaultDisplayInitialized = true;
 EGL.setErrorCode(12288);
 return 1;
}

function _eglMakeCurrent(display, draw, read, context) {
 if (display != 62e3) {
  EGL.setErrorCode(12296);
  return 0;
 }
 if (context != 0 && context != 62004) {
  EGL.setErrorCode(12294);
  return 0;
 }
 if (read != 0 && read != 62006 || draw != 0 && draw != 62006) {
  EGL.setErrorCode(12301);
  return 0;
 }
 GL.makeContextCurrent(context ? EGL.context : null);
 EGL.currentContext = context;
 EGL.currentDrawSurface = draw;
 EGL.currentReadSurface = read;
 EGL.setErrorCode(12288);
 return 1;
}

function allocateUTF8(str) {
 var size = lengthBytesUTF8(str) + 1;
 var ret = _malloc(size);
 if (ret) stringToUTF8Array(str, HEAP8, ret, size);
 return ret;
}

function _eglQueryString(display, name) {
 if (display != 62e3) {
  EGL.setErrorCode(12296);
  return 0;
 }
 EGL.setErrorCode(12288);
 if (EGL.stringCache[name]) return EGL.stringCache[name];
 var ret;
 switch (name) {
 case 12371:
  ret = allocateUTF8("Emscripten");
  break;

 case 12372:
  ret = allocateUTF8("1.4 Emscripten EGL");
  break;

 case 12373:
  ret = allocateUTF8("");
  break;

 case 12429:
  ret = allocateUTF8("OpenGL_ES");
  break;

 default:
  EGL.setErrorCode(12300);
  return 0;
 }
 EGL.stringCache[name] = ret;
 return ret;
}

function _eglSwapBuffers() {
 if (!EGL.defaultDisplayInitialized) {
  EGL.setErrorCode(12289);
 } else if (!Module.ctx) {
  EGL.setErrorCode(12290);
 } else if (Module.ctx.isContextLost()) {
  EGL.setErrorCode(12302);
 } else {
  EGL.setErrorCode(12288);
  return 1;
 }
 return 0;
}

function _eglSwapInterval(display, interval) {
 if (display != 62e3) {
  EGL.setErrorCode(12296);
  return 0;
 }
 if (interval == 0) _emscripten_set_main_loop_timing(0, 0); else _emscripten_set_main_loop_timing(1, interval);
 EGL.setErrorCode(12288);
 return 1;
}

function _eglTerminate(display) {
 if (display != 62e3) {
  EGL.setErrorCode(12296);
  return 0;
 }
 EGL.currentContext = 0;
 EGL.currentReadSurface = 0;
 EGL.currentDrawSurface = 0;
 EGL.defaultDisplayInitialized = false;
 EGL.setErrorCode(12288);
 return 1;
}

function _eglWaitClient() {
 EGL.setErrorCode(12288);
 return 1;
}

var _eglWaitGL = _eglWaitClient;

function _eglWaitNative(nativeEngineId) {
 EGL.setErrorCode(12288);
 return 1;
}

var readEmAsmArgsArray = [];

function readEmAsmArgs(sigPtr, buf) {
 assert(Array.isArray(readEmAsmArgsArray));
 assert(buf % 16 == 0);
 readEmAsmArgsArray.length = 0;
 var ch;
 buf >>= 2;
 while (ch = HEAPU8[sigPtr++ >>> 0]) {
  var chr = String.fromCharCode(ch);
  var validChars = [ "d", "f", "i" ];
  assert(validChars.includes(chr), "Invalid character " + ch + '("' + chr + '") in readEmAsmArgs! Use only [' + validChars + '], and do not specify "v" for void return argument.');
  buf += ch != 105 & buf;
  readEmAsmArgsArray.push(ch == 105 ? HEAP32[buf >>> 0] : HEAPF64[buf++ >>> 1]);
  ++buf;
 }
 return readEmAsmArgsArray;
}

function runEmAsmFunction(code, sigPtr, argbuf) {
 var args = readEmAsmArgs(sigPtr, argbuf);
 if (!ASM_CONSTS.hasOwnProperty(code)) abort("No EM_ASM constant found at address " + code);
 return ASM_CONSTS[code].apply(null, args);
}

function _emscripten_asm_const_int(code, sigPtr, argbuf) {
 return runEmAsmFunction(code, sigPtr, argbuf);
}

function runMainThreadEmAsm(code, sigPtr, argbuf, sync) {
 var args = readEmAsmArgs(sigPtr, argbuf);
 if (!ASM_CONSTS.hasOwnProperty(code)) abort("No EM_ASM constant found at address " + code);
 return ASM_CONSTS[code].apply(null, args);
}

function _emscripten_asm_const_int_sync_on_main_thread(code, sigPtr, argbuf) {
 return runMainThreadEmAsm(code, sigPtr, argbuf, 1);
}

function _emscripten_cancel_main_loop() {
 Browser.mainLoop.pause();
 Browser.mainLoop.func = null;
}

function _emscripten_date_now() {
 return Date.now();
}

var JSEvents = {
 inEventHandler: 0,
 removeAllEventListeners: function() {
  for (var i = JSEvents.eventHandlers.length - 1; i >= 0; --i) {
   JSEvents._removeHandler(i);
  }
  JSEvents.eventHandlers = [];
  JSEvents.deferredCalls = [];
 },
 registerRemoveEventListeners: function() {
  if (!JSEvents.removeEventListenersRegistered) {
   __ATEXIT__.push(JSEvents.removeAllEventListeners);
   JSEvents.removeEventListenersRegistered = true;
  }
 },
 deferredCalls: [],
 deferCall: function(targetFunction, precedence, argsList) {
  function arraysHaveEqualContent(arrA, arrB) {
   if (arrA.length != arrB.length) return false;
   for (var i in arrA) {
    if (arrA[i] != arrB[i]) return false;
   }
   return true;
  }
  for (var i in JSEvents.deferredCalls) {
   var call = JSEvents.deferredCalls[i];
   if (call.targetFunction == targetFunction && arraysHaveEqualContent(call.argsList, argsList)) {
    return;
   }
  }
  JSEvents.deferredCalls.push({
   targetFunction: targetFunction,
   precedence: precedence,
   argsList: argsList
  });
  JSEvents.deferredCalls.sort(function(x, y) {
   return x.precedence < y.precedence;
  });
 },
 removeDeferredCalls: function(targetFunction) {
  for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
   if (JSEvents.deferredCalls[i].targetFunction == targetFunction) {
    JSEvents.deferredCalls.splice(i, 1);
    --i;
   }
  }
 },
 canPerformEventHandlerRequests: function() {
  return JSEvents.inEventHandler && JSEvents.currentEventHandler.allowsDeferredCalls;
 },
 runDeferredCalls: function() {
  if (!JSEvents.canPerformEventHandlerRequests()) {
   return;
  }
  for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
   var call = JSEvents.deferredCalls[i];
   JSEvents.deferredCalls.splice(i, 1);
   --i;
   call.targetFunction.apply(null, call.argsList);
  }
 },
 eventHandlers: [],
 removeAllHandlersOnTarget: function(target, eventTypeString) {
  for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
   if (JSEvents.eventHandlers[i].target == target && (!eventTypeString || eventTypeString == JSEvents.eventHandlers[i].eventTypeString)) {
    JSEvents._removeHandler(i--);
   }
  }
 },
 _removeHandler: function(i) {
  var h = JSEvents.eventHandlers[i];
  h.target.removeEventListener(h.eventTypeString, h.eventListenerFunc, h.useCapture);
  JSEvents.eventHandlers.splice(i, 1);
 },
 registerOrRemoveHandler: function(eventHandler) {
  var jsEventHandler = function jsEventHandler(event) {
   ++JSEvents.inEventHandler;
   JSEvents.currentEventHandler = eventHandler;
   JSEvents.runDeferredCalls();
   eventHandler.handlerFunc(event);
   JSEvents.runDeferredCalls();
   --JSEvents.inEventHandler;
  };
  if (eventHandler.callbackfunc) {
   eventHandler.eventListenerFunc = jsEventHandler;
   eventHandler.target.addEventListener(eventHandler.eventTypeString, jsEventHandler, eventHandler.useCapture);
   JSEvents.eventHandlers.push(eventHandler);
   JSEvents.registerRemoveEventListeners();
  } else {
   for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
    if (JSEvents.eventHandlers[i].target == eventHandler.target && JSEvents.eventHandlers[i].eventTypeString == eventHandler.eventTypeString) {
     JSEvents._removeHandler(i--);
    }
   }
  }
 },
 getNodeNameForTarget: function(target) {
  if (!target) return "";
  if (target == window) return "#window";
  if (target == screen) return "#screen";
  return target && target.nodeName ? target.nodeName : "";
 },
 fullscreenEnabled: function() {
  return document.fullscreenEnabled || document.webkitFullscreenEnabled;
 }
};

var currentFullscreenStrategy = {};

function maybeCStringToJsString(cString) {
 return cString > 2 ? UTF8ToString(cString) : cString;
}

var specialHTMLTargets = [ 0, typeof document != "undefined" ? document : 0, typeof window != "undefined" ? window : 0 ];

function findEventTarget(target) {
 target = maybeCStringToJsString(target);
 var domElement = specialHTMLTargets[target] || (typeof document != "undefined" ? document.querySelector(target) : undefined);
 return domElement;
}

function findCanvasEventTarget(target) {
 return findEventTarget(target);
}

function _emscripten_get_canvas_element_size(target, width, height) {
 var canvas = findCanvasEventTarget(target);
 if (!canvas) return -4;
 HEAP32[width >>> 2] = canvas.width;
 HEAP32[height >>> 2] = canvas.height;
}

function getCanvasElementSize(target) {
 return withStackSave(function() {
  var w = stackAlloc(8);
  var h = w + 4;
  var targetInt = stackAlloc(target.id.length + 1);
  stringToUTF8(target.id, targetInt, target.id.length + 1);
  var ret = _emscripten_get_canvas_element_size(targetInt, w, h);
  var size = [ HEAP32[w >>> 2], HEAP32[h >>> 2] ];
  return size;
 });
}

function _emscripten_set_canvas_element_size(target, width, height) {
 var canvas = findCanvasEventTarget(target);
 if (!canvas) return -4;
 canvas.width = width;
 canvas.height = height;
 return 0;
}

function setCanvasElementSize(target, width, height) {
 if (!target.controlTransferredOffscreen) {
  target.width = width;
  target.height = height;
 } else {
  withStackSave(function() {
   var targetInt = stackAlloc(target.id.length + 1);
   stringToUTF8(target.id, targetInt, target.id.length + 1);
   _emscripten_set_canvas_element_size(targetInt, width, height);
  });
 }
}

function registerRestoreOldStyle(canvas) {
 var canvasSize = getCanvasElementSize(canvas);
 var oldWidth = canvasSize[0];
 var oldHeight = canvasSize[1];
 var oldCssWidth = canvas.style.width;
 var oldCssHeight = canvas.style.height;
 var oldBackgroundColor = canvas.style.backgroundColor;
 var oldDocumentBackgroundColor = document.body.style.backgroundColor;
 var oldPaddingLeft = canvas.style.paddingLeft;
 var oldPaddingRight = canvas.style.paddingRight;
 var oldPaddingTop = canvas.style.paddingTop;
 var oldPaddingBottom = canvas.style.paddingBottom;
 var oldMarginLeft = canvas.style.marginLeft;
 var oldMarginRight = canvas.style.marginRight;
 var oldMarginTop = canvas.style.marginTop;
 var oldMarginBottom = canvas.style.marginBottom;
 var oldDocumentBodyMargin = document.body.style.margin;
 var oldDocumentOverflow = document.documentElement.style.overflow;
 var oldDocumentScroll = document.body.scroll;
 var oldImageRendering = canvas.style.imageRendering;
 function restoreOldStyle() {
  var fullscreenElement = document.fullscreenElement || document.webkitFullscreenElement;
  if (!fullscreenElement) {
   document.removeEventListener("fullscreenchange", restoreOldStyle);
   document.removeEventListener("webkitfullscreenchange", restoreOldStyle);
   setCanvasElementSize(canvas, oldWidth, oldHeight);
   canvas.style.width = oldCssWidth;
   canvas.style.height = oldCssHeight;
   canvas.style.backgroundColor = oldBackgroundColor;
   if (!oldDocumentBackgroundColor) document.body.style.backgroundColor = "white";
   document.body.style.backgroundColor = oldDocumentBackgroundColor;
   canvas.style.paddingLeft = oldPaddingLeft;
   canvas.style.paddingRight = oldPaddingRight;
   canvas.style.paddingTop = oldPaddingTop;
   canvas.style.paddingBottom = oldPaddingBottom;
   canvas.style.marginLeft = oldMarginLeft;
   canvas.style.marginRight = oldMarginRight;
   canvas.style.marginTop = oldMarginTop;
   canvas.style.marginBottom = oldMarginBottom;
   document.body.style.margin = oldDocumentBodyMargin;
   document.documentElement.style.overflow = oldDocumentOverflow;
   document.body.scroll = oldDocumentScroll;
   canvas.style.imageRendering = oldImageRendering;
   if (canvas.GLctxObject) canvas.GLctxObject.GLctx.viewport(0, 0, oldWidth, oldHeight);
   if (currentFullscreenStrategy.canvasResizedCallback) {
    getWasmTableEntry(currentFullscreenStrategy.canvasResizedCallback)(37, 0, currentFullscreenStrategy.canvasResizedCallbackUserData);
   }
  }
 }
 document.addEventListener("fullscreenchange", restoreOldStyle);
 document.addEventListener("webkitfullscreenchange", restoreOldStyle);
 return restoreOldStyle;
}

function setLetterbox(element, topBottom, leftRight) {
 element.style.paddingLeft = element.style.paddingRight = leftRight + "px";
 element.style.paddingTop = element.style.paddingBottom = topBottom + "px";
}

function getBoundingClientRect(e) {
 return specialHTMLTargets.indexOf(e) < 0 ? e.getBoundingClientRect() : {
  "left": 0,
  "top": 0
 };
}

function JSEvents_resizeCanvasForFullscreen(target, strategy) {
 var restoreOldStyle = registerRestoreOldStyle(target);
 var cssWidth = strategy.softFullscreen ? innerWidth : screen.width;
 var cssHeight = strategy.softFullscreen ? innerHeight : screen.height;
 var rect = getBoundingClientRect(target);
 var windowedCssWidth = rect.width;
 var windowedCssHeight = rect.height;
 var canvasSize = getCanvasElementSize(target);
 var windowedRttWidth = canvasSize[0];
 var windowedRttHeight = canvasSize[1];
 if (strategy.scaleMode == 3) {
  setLetterbox(target, (cssHeight - windowedCssHeight) / 2, (cssWidth - windowedCssWidth) / 2);
  cssWidth = windowedCssWidth;
  cssHeight = windowedCssHeight;
 } else if (strategy.scaleMode == 2) {
  if (cssWidth * windowedRttHeight < windowedRttWidth * cssHeight) {
   var desiredCssHeight = windowedRttHeight * cssWidth / windowedRttWidth;
   setLetterbox(target, (cssHeight - desiredCssHeight) / 2, 0);
   cssHeight = desiredCssHeight;
  } else {
   var desiredCssWidth = windowedRttWidth * cssHeight / windowedRttHeight;
   setLetterbox(target, 0, (cssWidth - desiredCssWidth) / 2);
   cssWidth = desiredCssWidth;
  }
 }
 if (!target.style.backgroundColor) target.style.backgroundColor = "black";
 if (!document.body.style.backgroundColor) document.body.style.backgroundColor = "black";
 target.style.width = cssWidth + "px";
 target.style.height = cssHeight + "px";
 if (strategy.filteringMode == 1) {
  target.style.imageRendering = "optimizeSpeed";
  target.style.imageRendering = "-moz-crisp-edges";
  target.style.imageRendering = "-o-crisp-edges";
  target.style.imageRendering = "-webkit-optimize-contrast";
  target.style.imageRendering = "optimize-contrast";
  target.style.imageRendering = "crisp-edges";
  target.style.imageRendering = "pixelated";
 }
 var dpiScale = strategy.canvasResolutionScaleMode == 2 ? devicePixelRatio : 1;
 if (strategy.canvasResolutionScaleMode != 0) {
  var newWidth = cssWidth * dpiScale | 0;
  var newHeight = cssHeight * dpiScale | 0;
  setCanvasElementSize(target, newWidth, newHeight);
  if (target.GLctxObject) target.GLctxObject.GLctx.viewport(0, 0, newWidth, newHeight);
 }
 return restoreOldStyle;
}

function JSEvents_requestFullscreen(target, strategy) {
 if (strategy.scaleMode != 0 || strategy.canvasResolutionScaleMode != 0) {
  JSEvents_resizeCanvasForFullscreen(target, strategy);
 }
 if (target.requestFullscreen) {
  target.requestFullscreen();
 } else if (target.webkitRequestFullscreen) {
  target.webkitRequestFullscreen(Element.ALLOW_KEYBOARD_INPUT);
 } else {
  return JSEvents.fullscreenEnabled() ? -3 : -1;
 }
 currentFullscreenStrategy = strategy;
 if (strategy.canvasResizedCallback) {
  getWasmTableEntry(strategy.canvasResizedCallback)(37, 0, strategy.canvasResizedCallbackUserData);
 }
 return 0;
}

function _emscripten_exit_fullscreen() {
 if (!JSEvents.fullscreenEnabled()) return -1;
 JSEvents.removeDeferredCalls(JSEvents_requestFullscreen);
 var d = specialHTMLTargets[1];
 if (d.exitFullscreen) {
  d.fullscreenElement && d.exitFullscreen();
 } else if (d.webkitExitFullscreen) {
  d.webkitFullscreenElement && d.webkitExitFullscreen();
 } else {
  return -1;
 }
 return 0;
}

function requestPointerLock(target) {
 if (target.requestPointerLock) {
  target.requestPointerLock();
 } else {
  if (document.body.requestPointerLock) {
   return -3;
  }
  return -1;
 }
 return 0;
}

function _emscripten_exit_pointerlock() {
 JSEvents.removeDeferredCalls(requestPointerLock);
 if (document.exitPointerLock) {
  document.exitPointerLock();
 } else {
  return -1;
 }
 return 0;
}

function _emscripten_get_device_pixel_ratio() {
 return typeof devicePixelRatio == "number" && devicePixelRatio || 1;
}

function _emscripten_get_element_css_size(target, width, height) {
 target = findEventTarget(target);
 if (!target) return -4;
 var rect = getBoundingClientRect(target);
 HEAPF64[width >>> 3] = rect.width;
 HEAPF64[height >>> 3] = rect.height;
 return 0;
}

function fillGamepadEventData(eventStruct, e) {
 HEAPF64[eventStruct >>> 3] = e.timestamp;
 for (var i = 0; i < e.axes.length; ++i) {
  HEAPF64[eventStruct + i * 8 + 16 >>> 3] = e.axes[i];
 }
 for (var i = 0; i < e.buttons.length; ++i) {
  if (typeof e.buttons[i] == "object") {
   HEAPF64[eventStruct + i * 8 + 528 >>> 3] = e.buttons[i].value;
  } else {
   HEAPF64[eventStruct + i * 8 + 528 >>> 3] = e.buttons[i];
  }
 }
 for (var i = 0; i < e.buttons.length; ++i) {
  if (typeof e.buttons[i] == "object") {
   HEAP32[eventStruct + i * 4 + 1040 >>> 2] = e.buttons[i].pressed;
  } else {
   HEAP32[eventStruct + i * 4 + 1040 >>> 2] = e.buttons[i] == 1;
  }
 }
 HEAP32[eventStruct + 1296 >>> 2] = e.connected;
 HEAP32[eventStruct + 1300 >>> 2] = e.index;
 HEAP32[eventStruct + 8 >>> 2] = e.axes.length;
 HEAP32[eventStruct + 12 >>> 2] = e.buttons.length;
 stringToUTF8(e.id, eventStruct + 1304, 64);
 stringToUTF8(e.mapping, eventStruct + 1368, 64);
}

function _emscripten_get_gamepad_status(index, gamepadState) {
 if (!JSEvents.lastGamepadState) throw "emscripten_get_gamepad_status() can only be called after having first called emscripten_sample_gamepad_data() and that function has returned EMSCRIPTEN_RESULT_SUCCESS!";
 if (index < 0 || index >= JSEvents.lastGamepadState.length) return -5;
 if (!JSEvents.lastGamepadState[index]) return -7;
 fillGamepadEventData(gamepadState, JSEvents.lastGamepadState[index]);
 return 0;
}

function _emscripten_get_num_gamepads() {
 if (!JSEvents.lastGamepadState) throw "emscripten_get_num_gamepads() can only be called after having first called emscripten_sample_gamepad_data() and that function has returned EMSCRIPTEN_RESULT_SUCCESS!";
 return JSEvents.lastGamepadState.length;
}

function _emscripten_get_screen_size(width, height) {
 HEAP32[width >>> 2] = screen.width;
 HEAP32[height >>> 2] = screen.height;
}

function _emscripten_glActiveTexture(x0) {
 GLctx["activeTexture"](x0);
}

function _emscripten_glAttachShader(program, shader) {
 GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
}

function _emscripten_glBeginQuery(target, id) {
 GLctx["beginQuery"](target, GL.queries[id]);
}

function _emscripten_glBeginQueryEXT(target, id) {
 GLctx.disjointTimerQueryExt["beginQueryEXT"](target, GL.queries[id]);
}

function _emscripten_glBeginTransformFeedback(x0) {
 GLctx["beginTransformFeedback"](x0);
}

function _emscripten_glBindAttribLocation(program, index, name) {
 GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name));
}

function _emscripten_glBindBuffer(target, buffer) {
 if (target == 34962) {
  GLctx.currentArrayBufferBinding = buffer;
 } else if (target == 34963) {
  GLctx.currentElementArrayBufferBinding = buffer;
 }
 if (target == 35051) {
  GLctx.currentPixelPackBufferBinding = buffer;
 } else if (target == 35052) {
  GLctx.currentPixelUnpackBufferBinding = buffer;
 }
 GLctx.bindBuffer(target, GL.buffers[buffer]);
}

function _emscripten_glBindBufferBase(target, index, buffer) {
 GLctx["bindBufferBase"](target, index, GL.buffers[buffer]);
}

function _emscripten_glBindBufferRange(target, index, buffer, offset, ptrsize) {
 GLctx["bindBufferRange"](target, index, GL.buffers[buffer], offset, ptrsize);
}

function _emscripten_glBindFramebuffer(target, framebuffer) {
 GLctx.bindFramebuffer(target, GL.framebuffers[framebuffer]);
}

function _emscripten_glBindRenderbuffer(target, renderbuffer) {
 GLctx.bindRenderbuffer(target, GL.renderbuffers[renderbuffer]);
}

function _emscripten_glBindSampler(unit, sampler) {
 GLctx["bindSampler"](unit, GL.samplers[sampler]);
}

function _emscripten_glBindTexture(target, texture) {
 GLctx.bindTexture(target, GL.textures[texture]);
}

function _emscripten_glBindTransformFeedback(target, id) {
 GLctx["bindTransformFeedback"](target, GL.transformFeedbacks[id]);
}

function _emscripten_glBindVertexArray(vao) {
 GLctx["bindVertexArray"](GL.vaos[vao]);
 var ibo = GLctx.getParameter(34965);
 GLctx.currentElementArrayBufferBinding = ibo ? ibo.name | 0 : 0;
}

function _emscripten_glBindVertexArrayOES(vao) {
 GLctx["bindVertexArray"](GL.vaos[vao]);
 var ibo = GLctx.getParameter(34965);
 GLctx.currentElementArrayBufferBinding = ibo ? ibo.name | 0 : 0;
}

function _emscripten_glBlendColor(x0, x1, x2, x3) {
 GLctx["blendColor"](x0, x1, x2, x3);
}

function _emscripten_glBlendEquation(x0) {
 GLctx["blendEquation"](x0);
}

function _emscripten_glBlendEquationSeparate(x0, x1) {
 GLctx["blendEquationSeparate"](x0, x1);
}

function _emscripten_glBlendFunc(x0, x1) {
 GLctx["blendFunc"](x0, x1);
}

function _emscripten_glBlendFuncSeparate(x0, x1, x2, x3) {
 GLctx["blendFuncSeparate"](x0, x1, x2, x3);
}

function _emscripten_glBlitFramebuffer(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) {
 GLctx["blitFramebuffer"](x0, x1, x2, x3, x4, x5, x6, x7, x8, x9);
}

function _emscripten_glBufferData(target, size, data, usage) {
 if (true) {
  if (data && size) {
   GLctx.bufferData(target, HEAPU8, usage, data, size);
  } else {
   GLctx.bufferData(target, size, usage);
  }
 } else {
  GLctx.bufferData(target, data ? HEAPU8.subarray(data >>> 0, data + size >>> 0) : size, usage);
 }
}

function _emscripten_glBufferSubData(target, offset, size, data) {
 if (true) {
  size && GLctx.bufferSubData(target, offset, HEAPU8, data, size);
  return;
 }
 GLctx.bufferSubData(target, offset, HEAPU8.subarray(data >>> 0, data + size >>> 0));
}

function _emscripten_glCheckFramebufferStatus(x0) {
 return GLctx["checkFramebufferStatus"](x0);
}

function _emscripten_glClear(x0) {
 GLctx["clear"](x0);
}

function _emscripten_glClearBufferfi(x0, x1, x2, x3) {
 GLctx["clearBufferfi"](x0, x1, x2, x3);
}

function _emscripten_glClearBufferfv(buffer, drawbuffer, value) {
 GLctx["clearBufferfv"](buffer, drawbuffer, HEAPF32, value >> 2);
}

function _emscripten_glClearBufferiv(buffer, drawbuffer, value) {
 GLctx["clearBufferiv"](buffer, drawbuffer, HEAP32, value >> 2);
}

function _emscripten_glClearBufferuiv(buffer, drawbuffer, value) {
 GLctx["clearBufferuiv"](buffer, drawbuffer, HEAPU32, value >> 2);
}

function _emscripten_glClearColor(x0, x1, x2, x3) {
 GLctx["clearColor"](x0, x1, x2, x3);
}

function _emscripten_glClearDepthf(x0) {
 GLctx["clearDepth"](x0);
}

function _emscripten_glClearStencil(x0) {
 GLctx["clearStencil"](x0);
}

function convertI32PairToI53(lo, hi) {
 assert(hi === (hi | 0));
 return (lo >>> 0) + hi * 4294967296;
}

function _emscripten_glClientWaitSync(sync, flags, timeoutLo, timeoutHi) {
 return GLctx.clientWaitSync(GL.syncs[sync], flags, convertI32PairToI53(timeoutLo, timeoutHi));
}

function _emscripten_glColorMask(red, green, blue, alpha) {
 GLctx.colorMask(!!red, !!green, !!blue, !!alpha);
}

function _emscripten_glCompileShader(shader) {
 GLctx.compileShader(GL.shaders[shader]);
}

function _emscripten_glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, data) {
 if (true) {
  if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
   GLctx["compressedTexImage2D"](target, level, internalFormat, width, height, border, imageSize, data);
  } else {
   GLctx["compressedTexImage2D"](target, level, internalFormat, width, height, border, HEAPU8, data, imageSize);
  }
  return;
 }
 GLctx["compressedTexImage2D"](target, level, internalFormat, width, height, border, data ? HEAPU8.subarray(data >>> 0, data + imageSize >>> 0) : null);
}

function _emscripten_glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, data) {
 if (GLctx.currentPixelUnpackBufferBinding) {
  GLctx["compressedTexImage3D"](target, level, internalFormat, width, height, depth, border, imageSize, data);
 } else {
  GLctx["compressedTexImage3D"](target, level, internalFormat, width, height, depth, border, HEAPU8, data, imageSize);
 }
}

function _emscripten_glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data) {
 if (true) {
  if (GLctx.currentPixelUnpackBufferBinding || !imageSize) {
   GLctx["compressedTexSubImage2D"](target, level, xoffset, yoffset, width, height, format, imageSize, data);
  } else {
   GLctx["compressedTexSubImage2D"](target, level, xoffset, yoffset, width, height, format, HEAPU8, data, imageSize);
  }
  return;
 }
 GLctx["compressedTexSubImage2D"](target, level, xoffset, yoffset, width, height, format, data ? HEAPU8.subarray(data >>> 0, data + imageSize >>> 0) : null);
}

function _emscripten_glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) {
 if (GLctx.currentPixelUnpackBufferBinding) {
  GLctx["compressedTexSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 } else {
  GLctx["compressedTexSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, HEAPU8, data, imageSize);
 }
}

function _emscripten_glCopyBufferSubData(x0, x1, x2, x3, x4) {
 GLctx["copyBufferSubData"](x0, x1, x2, x3, x4);
}

function _emscripten_glCopyTexImage2D(x0, x1, x2, x3, x4, x5, x6, x7) {
 GLctx["copyTexImage2D"](x0, x1, x2, x3, x4, x5, x6, x7);
}

function _emscripten_glCopyTexSubImage2D(x0, x1, x2, x3, x4, x5, x6, x7) {
 GLctx["copyTexSubImage2D"](x0, x1, x2, x3, x4, x5, x6, x7);
}

function _emscripten_glCopyTexSubImage3D(x0, x1, x2, x3, x4, x5, x6, x7, x8) {
 GLctx["copyTexSubImage3D"](x0, x1, x2, x3, x4, x5, x6, x7, x8);
}

function _emscripten_glCreateProgram() {
 var id = GL.getNewId(GL.programs);
 var program = GLctx.createProgram();
 program.name = id;
 program.maxUniformLength = program.maxAttributeLength = program.maxUniformBlockNameLength = 0;
 program.uniformIdCounter = 1;
 GL.programs[id] = program;
 return id;
}

function _emscripten_glCreateShader(shaderType) {
 var id = GL.getNewId(GL.shaders);
 GL.shaders[id] = GLctx.createShader(shaderType);
 return id;
}

function _emscripten_glCullFace(x0) {
 GLctx["cullFace"](x0);
}

function _emscripten_glDeleteBuffers(n, buffers) {
 for (var i = 0; i < n; i++) {
  var id = HEAP32[buffers + i * 4 >>> 2];
  var buffer = GL.buffers[id];
  if (!buffer) continue;
  GLctx.deleteBuffer(buffer);
  buffer.name = 0;
  GL.buffers[id] = null;
  if (id == GLctx.currentArrayBufferBinding) GLctx.currentArrayBufferBinding = 0;
  if (id == GLctx.currentElementArrayBufferBinding) GLctx.currentElementArrayBufferBinding = 0;
  if (id == GLctx.currentPixelPackBufferBinding) GLctx.currentPixelPackBufferBinding = 0;
  if (id == GLctx.currentPixelUnpackBufferBinding) GLctx.currentPixelUnpackBufferBinding = 0;
 }
}

function _emscripten_glDeleteFramebuffers(n, framebuffers) {
 for (var i = 0; i < n; ++i) {
  var id = HEAP32[framebuffers + i * 4 >>> 2];
  var framebuffer = GL.framebuffers[id];
  if (!framebuffer) continue;
  GLctx.deleteFramebuffer(framebuffer);
  framebuffer.name = 0;
  GL.framebuffers[id] = null;
 }
}

function _emscripten_glDeleteProgram(id) {
 if (!id) return;
 var program = GL.programs[id];
 if (!program) {
  GL.recordError(1281);
  return;
 }
 GLctx.deleteProgram(program);
 program.name = 0;
 GL.programs[id] = null;
}

function _emscripten_glDeleteQueries(n, ids) {
 for (var i = 0; i < n; i++) {
  var id = HEAP32[ids + i * 4 >>> 2];
  var query = GL.queries[id];
  if (!query) continue;
  GLctx["deleteQuery"](query);
  GL.queries[id] = null;
 }
}

function _emscripten_glDeleteQueriesEXT(n, ids) {
 for (var i = 0; i < n; i++) {
  var id = HEAP32[ids + i * 4 >>> 2];
  var query = GL.queries[id];
  if (!query) continue;
  GLctx.disjointTimerQueryExt["deleteQueryEXT"](query);
  GL.queries[id] = null;
 }
}

function _emscripten_glDeleteRenderbuffers(n, renderbuffers) {
 for (var i = 0; i < n; i++) {
  var id = HEAP32[renderbuffers + i * 4 >>> 2];
  var renderbuffer = GL.renderbuffers[id];
  if (!renderbuffer) continue;
  GLctx.deleteRenderbuffer(renderbuffer);
  renderbuffer.name = 0;
  GL.renderbuffers[id] = null;
 }
}

function _emscripten_glDeleteSamplers(n, samplers) {
 for (var i = 0; i < n; i++) {
  var id = HEAP32[samplers + i * 4 >>> 2];
  var sampler = GL.samplers[id];
  if (!sampler) continue;
  GLctx["deleteSampler"](sampler);
  sampler.name = 0;
  GL.samplers[id] = null;
 }
}

function _emscripten_glDeleteShader(id) {
 if (!id) return;
 var shader = GL.shaders[id];
 if (!shader) {
  GL.recordError(1281);
  return;
 }
 GLctx.deleteShader(shader);
 GL.shaders[id] = null;
}

function _emscripten_glDeleteSync(id) {
 if (!id) return;
 var sync = GL.syncs[id];
 if (!sync) {
  GL.recordError(1281);
  return;
 }
 GLctx.deleteSync(sync);
 sync.name = 0;
 GL.syncs[id] = null;
}

function _emscripten_glDeleteTextures(n, textures) {
 for (var i = 0; i < n; i++) {
  var id = HEAP32[textures + i * 4 >>> 2];
  var texture = GL.textures[id];
  if (!texture) continue;
  GLctx.deleteTexture(texture);
  texture.name = 0;
  GL.textures[id] = null;
 }
}

function _emscripten_glDeleteTransformFeedbacks(n, ids) {
 for (var i = 0; i < n; i++) {
  var id = HEAP32[ids + i * 4 >>> 2];
  var transformFeedback = GL.transformFeedbacks[id];
  if (!transformFeedback) continue;
  GLctx["deleteTransformFeedback"](transformFeedback);
  transformFeedback.name = 0;
  GL.transformFeedbacks[id] = null;
 }
}

function _emscripten_glDeleteVertexArrays(n, vaos) {
 for (var i = 0; i < n; i++) {
  var id = HEAP32[vaos + i * 4 >>> 2];
  GLctx["deleteVertexArray"](GL.vaos[id]);
  GL.vaos[id] = null;
 }
}

function _emscripten_glDeleteVertexArraysOES(n, vaos) {
 for (var i = 0; i < n; i++) {
  var id = HEAP32[vaos + i * 4 >>> 2];
  GLctx["deleteVertexArray"](GL.vaos[id]);
  GL.vaos[id] = null;
 }
}

function _emscripten_glDepthFunc(x0) {
 GLctx["depthFunc"](x0);
}

function _emscripten_glDepthMask(flag) {
 GLctx.depthMask(!!flag);
}

function _emscripten_glDepthRangef(x0, x1) {
 GLctx["depthRange"](x0, x1);
}

function _emscripten_glDetachShader(program, shader) {
 GLctx.detachShader(GL.programs[program], GL.shaders[shader]);
}

function _emscripten_glDisable(x0) {
 GLctx["disable"](x0);
}

function _emscripten_glDisableVertexAttribArray(index) {
 var cb = GL.currentContext.clientBuffers[index];
 cb.enabled = false;
 GLctx.disableVertexAttribArray(index);
}

function _emscripten_glDrawArrays(mode, first, count) {
 GL.preDrawHandleClientVertexAttribBindings(first + count);
 GLctx.drawArrays(mode, first, count);
 GL.postDrawHandleClientVertexAttribBindings();
}

function _emscripten_glDrawArraysInstanced(mode, first, count, primcount) {
 GLctx["drawArraysInstanced"](mode, first, count, primcount);
}

function _emscripten_glDrawArraysInstancedANGLE(mode, first, count, primcount) {
 GLctx["drawArraysInstanced"](mode, first, count, primcount);
}

function _emscripten_glDrawArraysInstancedARB(mode, first, count, primcount) {
 GLctx["drawArraysInstanced"](mode, first, count, primcount);
}

function _emscripten_glDrawArraysInstancedEXT(mode, first, count, primcount) {
 GLctx["drawArraysInstanced"](mode, first, count, primcount);
}

function _emscripten_glDrawArraysInstancedNV(mode, first, count, primcount) {
 GLctx["drawArraysInstanced"](mode, first, count, primcount);
}

var tempFixedLengthArray = [];

function _emscripten_glDrawBuffers(n, bufs) {
 var bufArray = tempFixedLengthArray[n];
 for (var i = 0; i < n; i++) {
  bufArray[i] = HEAP32[bufs + i * 4 >>> 2];
 }
 GLctx["drawBuffers"](bufArray);
}

function _emscripten_glDrawBuffersEXT(n, bufs) {
 var bufArray = tempFixedLengthArray[n];
 for (var i = 0; i < n; i++) {
  bufArray[i] = HEAP32[bufs + i * 4 >>> 2];
 }
 GLctx["drawBuffers"](bufArray);
}

function _emscripten_glDrawBuffersWEBGL(n, bufs) {
 var bufArray = tempFixedLengthArray[n];
 for (var i = 0; i < n; i++) {
  bufArray[i] = HEAP32[bufs + i * 4 >>> 2];
 }
 GLctx["drawBuffers"](bufArray);
}

function _emscripten_glDrawElements(mode, count, type, indices) {
 var buf;
 if (!GLctx.currentElementArrayBufferBinding) {
  var size = GL.calcBufLength(1, type, 0, count);
  buf = GL.getTempIndexBuffer(size);
  GLctx.bindBuffer(34963, buf);
  GLctx.bufferSubData(34963, 0, HEAPU8.subarray(indices >>> 0, indices + size >>> 0));
  indices = 0;
 }
 GL.preDrawHandleClientVertexAttribBindings(count);
 GLctx.drawElements(mode, count, type, indices);
 GL.postDrawHandleClientVertexAttribBindings(count);
 if (!GLctx.currentElementArrayBufferBinding) {
  GLctx.bindBuffer(34963, null);
 }
}

function _emscripten_glDrawElementsInstanced(mode, count, type, indices, primcount) {
 GLctx["drawElementsInstanced"](mode, count, type, indices, primcount);
}

function _emscripten_glDrawElementsInstancedANGLE(mode, count, type, indices, primcount) {
 GLctx["drawElementsInstanced"](mode, count, type, indices, primcount);
}

function _emscripten_glDrawElementsInstancedARB(mode, count, type, indices, primcount) {
 GLctx["drawElementsInstanced"](mode, count, type, indices, primcount);
}

function _emscripten_glDrawElementsInstancedEXT(mode, count, type, indices, primcount) {
 GLctx["drawElementsInstanced"](mode, count, type, indices, primcount);
}

function _emscripten_glDrawElementsInstancedNV(mode, count, type, indices, primcount) {
 GLctx["drawElementsInstanced"](mode, count, type, indices, primcount);
}

function _glDrawElements(mode, count, type, indices) {
 var buf;
 if (!GLctx.currentElementArrayBufferBinding) {
  var size = GL.calcBufLength(1, type, 0, count);
  buf = GL.getTempIndexBuffer(size);
  GLctx.bindBuffer(34963, buf);
  GLctx.bufferSubData(34963, 0, HEAPU8.subarray(indices >>> 0, indices + size >>> 0));
  indices = 0;
 }
 GL.preDrawHandleClientVertexAttribBindings(count);
 GLctx.drawElements(mode, count, type, indices);
 GL.postDrawHandleClientVertexAttribBindings(count);
 if (!GLctx.currentElementArrayBufferBinding) {
  GLctx.bindBuffer(34963, null);
 }
}

function _emscripten_glDrawRangeElements(mode, start, end, count, type, indices) {
 _glDrawElements(mode, count, type, indices);
}

function _emscripten_glEnable(x0) {
 GLctx["enable"](x0);
}

function _emscripten_glEnableVertexAttribArray(index) {
 var cb = GL.currentContext.clientBuffers[index];
 cb.enabled = true;
 GLctx.enableVertexAttribArray(index);
}

function _emscripten_glEndQuery(x0) {
 GLctx["endQuery"](x0);
}

function _emscripten_glEndQueryEXT(target) {
 GLctx.disjointTimerQueryExt["endQueryEXT"](target);
}

function _emscripten_glEndTransformFeedback() {
 GLctx["endTransformFeedback"]();
}

function _emscripten_glFenceSync(condition, flags) {
 var sync = GLctx.fenceSync(condition, flags);
 if (sync) {
  var id = GL.getNewId(GL.syncs);
  sync.name = id;
  GL.syncs[id] = sync;
  return id;
 }
 return 0;
}

function _emscripten_glFinish() {
 GLctx["finish"]();
}

function _emscripten_glFlush() {
 GLctx["flush"]();
}

function emscriptenWebGLGetBufferBinding(target) {
 switch (target) {
 case 34962:
  target = 34964;
  break;

 case 34963:
  target = 34965;
  break;

 case 35051:
  target = 35053;
  break;

 case 35052:
  target = 35055;
  break;

 case 35982:
  target = 35983;
  break;

 case 36662:
  target = 36662;
  break;

 case 36663:
  target = 36663;
  break;

 case 35345:
  target = 35368;
  break;
 }
 var buffer = GLctx.getParameter(target);
 if (buffer) return buffer.name | 0; else return 0;
}

function emscriptenWebGLValidateMapBufferTarget(target) {
 switch (target) {
 case 34962:
 case 34963:
 case 36662:
 case 36663:
 case 35051:
 case 35052:
 case 35882:
 case 35982:
 case 35345:
  return true;

 default:
  return false;
 }
}

function _emscripten_glFlushMappedBufferRange(target, offset, length) {
 if (!emscriptenWebGLValidateMapBufferTarget(target)) {
  GL.recordError(1280);
  err("GL_INVALID_ENUM in glFlushMappedBufferRange");
  return;
 }
 var mapping = GL.mappedBuffers[emscriptenWebGLGetBufferBinding(target)];
 if (!mapping) {
  GL.recordError(1282);
  err("buffer was never mapped in glFlushMappedBufferRange");
  return;
 }
 if (!(mapping.access & 16)) {
  GL.recordError(1282);
  err("buffer was not mapped with GL_MAP_FLUSH_EXPLICIT_BIT in glFlushMappedBufferRange");
  return;
 }
 if (offset < 0 || length < 0 || offset + length > mapping.length) {
  GL.recordError(1281);
  err("invalid range in glFlushMappedBufferRange");
  return;
 }
 GLctx.bufferSubData(target, mapping.offset, HEAPU8.subarray(mapping.mem + offset >>> 0, mapping.mem + offset + length >>> 0));
}

function _emscripten_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) {
 GLctx.framebufferRenderbuffer(target, attachment, renderbuffertarget, GL.renderbuffers[renderbuffer]);
}

function _emscripten_glFramebufferTexture2D(target, attachment, textarget, texture, level) {
 GLctx.framebufferTexture2D(target, attachment, textarget, GL.textures[texture], level);
}

function _emscripten_glFramebufferTextureLayer(target, attachment, texture, level, layer) {
 GLctx.framebufferTextureLayer(target, attachment, GL.textures[texture], level, layer);
}

function _emscripten_glFrontFace(x0) {
 GLctx["frontFace"](x0);
}

function __glGenObject(n, buffers, createFunction, objectTable) {
 for (var i = 0; i < n; i++) {
  var buffer = GLctx[createFunction]();
  var id = buffer && GL.getNewId(objectTable);
  if (buffer) {
   buffer.name = id;
   objectTable[id] = buffer;
  } else {
   GL.recordError(1282);
  }
  HEAP32[buffers + i * 4 >>> 2] = id;
 }
}

function _emscripten_glGenBuffers(n, buffers) {
 __glGenObject(n, buffers, "createBuffer", GL.buffers);
}

function _emscripten_glGenFramebuffers(n, ids) {
 __glGenObject(n, ids, "createFramebuffer", GL.framebuffers);
}

function _emscripten_glGenQueries(n, ids) {
 __glGenObject(n, ids, "createQuery", GL.queries);
}

function _emscripten_glGenQueriesEXT(n, ids) {
 for (var i = 0; i < n; i++) {
  var query = GLctx.disjointTimerQueryExt["createQueryEXT"]();
  if (!query) {
   GL.recordError(1282);
   while (i < n) HEAP32[ids + i++ * 4 >>> 2] = 0;
   return;
  }
  var id = GL.getNewId(GL.queries);
  query.name = id;
  GL.queries[id] = query;
  HEAP32[ids + i * 4 >>> 2] = id;
 }
}

function _emscripten_glGenRenderbuffers(n, renderbuffers) {
 __glGenObject(n, renderbuffers, "createRenderbuffer", GL.renderbuffers);
}

function _emscripten_glGenSamplers(n, samplers) {
 __glGenObject(n, samplers, "createSampler", GL.samplers);
}

function _emscripten_glGenTextures(n, textures) {
 __glGenObject(n, textures, "createTexture", GL.textures);
}

function _emscripten_glGenTransformFeedbacks(n, ids) {
 __glGenObject(n, ids, "createTransformFeedback", GL.transformFeedbacks);
}

function _emscripten_glGenVertexArrays(n, arrays) {
 __glGenObject(n, arrays, "createVertexArray", GL.vaos);
}

function _emscripten_glGenVertexArraysOES(n, arrays) {
 __glGenObject(n, arrays, "createVertexArray", GL.vaos);
}

function _emscripten_glGenerateMipmap(x0) {
 GLctx["generateMipmap"](x0);
}

function __glGetActiveAttribOrUniform(funcName, program, index, bufSize, length, size, type, name) {
 program = GL.programs[program];
 var info = GLctx[funcName](program, index);
 if (info) {
  var numBytesWrittenExclNull = name && stringToUTF8(info.name, name, bufSize);
  if (length) HEAP32[length >>> 2] = numBytesWrittenExclNull;
  if (size) HEAP32[size >>> 2] = info.size;
  if (type) HEAP32[type >>> 2] = info.type;
 }
}

function _emscripten_glGetActiveAttrib(program, index, bufSize, length, size, type, name) {
 __glGetActiveAttribOrUniform("getActiveAttrib", program, index, bufSize, length, size, type, name);
}

function _emscripten_glGetActiveUniform(program, index, bufSize, length, size, type, name) {
 __glGetActiveAttribOrUniform("getActiveUniform", program, index, bufSize, length, size, type, name);
}

function _emscripten_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName) {
 program = GL.programs[program];
 var result = GLctx["getActiveUniformBlockName"](program, uniformBlockIndex);
 if (!result) return;
 if (uniformBlockName && bufSize > 0) {
  var numBytesWrittenExclNull = stringToUTF8(result, uniformBlockName, bufSize);
  if (length) HEAP32[length >>> 2] = numBytesWrittenExclNull;
 } else {
  if (length) HEAP32[length >>> 2] = 0;
 }
}

function _emscripten_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 program = GL.programs[program];
 if (pname == 35393) {
  var name = GLctx["getActiveUniformBlockName"](program, uniformBlockIndex);
  HEAP32[params >>> 2] = name.length + 1;
  return;
 }
 var result = GLctx["getActiveUniformBlockParameter"](program, uniformBlockIndex, pname);
 if (result === null) return;
 if (pname == 35395) {
  for (var i = 0; i < result.length; i++) {
   HEAP32[params + i * 4 >>> 2] = result[i];
  }
 } else {
  HEAP32[params >>> 2] = result;
 }
}

function _emscripten_glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 if (uniformCount > 0 && uniformIndices == 0) {
  GL.recordError(1281);
  return;
 }
 program = GL.programs[program];
 var ids = [];
 for (var i = 0; i < uniformCount; i++) {
  ids.push(HEAP32[uniformIndices + i * 4 >>> 2]);
 }
 var result = GLctx["getActiveUniforms"](program, ids, pname);
 if (!result) return;
 var len = result.length;
 for (var i = 0; i < len; i++) {
  HEAP32[params + i * 4 >>> 2] = result[i];
 }
}

function _emscripten_glGetAttachedShaders(program, maxCount, count, shaders) {
 var result = GLctx.getAttachedShaders(GL.programs[program]);
 var len = result.length;
 if (len > maxCount) {
  len = maxCount;
 }
 HEAP32[count >>> 2] = len;
 for (var i = 0; i < len; ++i) {
  var id = GL.shaders.indexOf(result[i]);
  HEAP32[shaders + i * 4 >>> 2] = id;
 }
}

function _emscripten_glGetAttribLocation(program, name) {
 return GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name));
}

function readI53FromI64(ptr) {
 return HEAPU32[ptr >>> 2] + HEAP32[ptr + 4 >>> 2] * 4294967296;
}

function readI53FromU64(ptr) {
 return HEAPU32[ptr >>> 2] + HEAPU32[ptr + 4 >>> 2] * 4294967296;
}

function writeI53ToI64(ptr, num) {
 HEAPU32[ptr >>> 2] = num;
 HEAPU32[ptr + 4 >>> 2] = (num - HEAPU32[ptr >>> 2]) / 4294967296;
 var deserialized = num >= 0 ? readI53FromU64(ptr) : readI53FromI64(ptr);
 if (deserialized != num) warnOnce("writeI53ToI64() out of range: serialized JS Number " + num + " to Wasm heap as bytes lo=" + ptrToString(HEAPU32[ptr >>> 2]) + ", hi=" + ptrToString(HEAPU32[ptr + 4 >>> 2]) + ", which deserializes back to " + deserialized + " instead!");
}

function emscriptenWebGLGet(name_, p, type) {
 if (!p) {
  GL.recordError(1281);
  return;
 }
 var ret = undefined;
 switch (name_) {
 case 36346:
  ret = 1;
  break;

 case 36344:
  if (type != 0 && type != 1) {
   GL.recordError(1280);
  }
  return;

 case 34814:
 case 36345:
  ret = 0;
  break;

 case 34466:
  var formats = GLctx.getParameter(34467);
  ret = formats ? formats.length : 0;
  break;

 case 33309:
  if (GL.currentContext.version < 2) {
   GL.recordError(1282);
   return;
  }
  var exts = GLctx.getSupportedExtensions() || [];
  ret = 2 * exts.length;
  break;

 case 33307:
 case 33308:
  if (GL.currentContext.version < 2) {
   GL.recordError(1280);
   return;
  }
  ret = name_ == 33307 ? 3 : 0;
  break;
 }
 if (ret === undefined) {
  var result = GLctx.getParameter(name_);
  switch (typeof result) {
  case "number":
   ret = result;
   break;

  case "boolean":
   ret = result ? 1 : 0;
   break;

  case "string":
   GL.recordError(1280);
   return;

  case "object":
   if (result === null) {
    switch (name_) {
    case 34964:
    case 35725:
    case 34965:
    case 36006:
    case 36007:
    case 32873:
    case 34229:
    case 36662:
    case 36663:
    case 35053:
    case 35055:
    case 36010:
    case 35097:
    case 35869:
    case 32874:
    case 36389:
    case 35983:
    case 35368:
    case 34068:
     {
      ret = 0;
      break;
     }

    default:
     {
      GL.recordError(1280);
      return;
     }
    }
   } else if (result instanceof Float32Array || result instanceof Uint32Array || result instanceof Int32Array || result instanceof Array) {
    for (var i = 0; i < result.length; ++i) {
     switch (type) {
     case 0:
      HEAP32[p + i * 4 >>> 2] = result[i];
      break;

     case 2:
      HEAPF32[p + i * 4 >>> 2] = result[i];
      break;

     case 4:
      HEAP8[p + i >>> 0] = result[i] ? 1 : 0;
      break;
     }
    }
    return;
   } else {
    try {
     ret = result.name | 0;
    } catch (e) {
     GL.recordError(1280);
     err("GL_INVALID_ENUM in glGet" + type + "v: Unknown object returned from WebGL getParameter(" + name_ + ")! (error: " + e + ")");
     return;
    }
   }
   break;

  default:
   GL.recordError(1280);
   err("GL_INVALID_ENUM in glGet" + type + "v: Native code calling glGet" + type + "v(" + name_ + ") and it returns " + result + " of type " + typeof result + "!");
   return;
  }
 }
 switch (type) {
 case 1:
  writeI53ToI64(p, ret);
  break;

 case 0:
  HEAP32[p >>> 2] = ret;
  break;

 case 2:
  HEAPF32[p >>> 2] = ret;
  break;

 case 4:
  HEAP8[p >>> 0] = ret ? 1 : 0;
  break;
 }
}

function _emscripten_glGetBooleanv(name_, p) {
 emscriptenWebGLGet(name_, p, 4);
}

function _emscripten_glGetBufferParameteri64v(target, value, data) {
 if (!data) {
  GL.recordError(1281);
  return;
 }
 writeI53ToI64(data, GLctx.getBufferParameter(target, value));
}

function _emscripten_glGetBufferParameteriv(target, value, data) {
 if (!data) {
  GL.recordError(1281);
  return;
 }
 HEAP32[data >>> 2] = GLctx.getBufferParameter(target, value);
}

function _emscripten_glGetBufferPointerv(target, pname, params) {
 if (pname == 35005) {
  var ptr = 0;
  var mappedBuffer = GL.mappedBuffers[emscriptenWebGLGetBufferBinding(target)];
  if (mappedBuffer) {
   ptr = mappedBuffer.mem;
  }
  HEAP32[params >>> 2] = ptr;
 } else {
  GL.recordError(1280);
  err("GL_INVALID_ENUM in glGetBufferPointerv");
 }
}

function _emscripten_glGetError() {
 var error = GLctx.getError() || GL.lastError;
 GL.lastError = 0;
 return error;
}

function _emscripten_glGetFloatv(name_, p) {
 emscriptenWebGLGet(name_, p, 2);
}

function _emscripten_glGetFragDataLocation(program, name) {
 return GLctx["getFragDataLocation"](GL.programs[program], UTF8ToString(name));
}

function _emscripten_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params) {
 var result = GLctx.getFramebufferAttachmentParameter(target, attachment, pname);
 if (result instanceof WebGLRenderbuffer || result instanceof WebGLTexture) {
  result = result.name | 0;
 }
 HEAP32[params >>> 2] = result;
}

function emscriptenWebGLGetIndexed(target, index, data, type) {
 if (!data) {
  GL.recordError(1281);
  return;
 }
 var result = GLctx["getIndexedParameter"](target, index);
 var ret;
 switch (typeof result) {
 case "boolean":
  ret = result ? 1 : 0;
  break;

 case "number":
  ret = result;
  break;

 case "object":
  if (result === null) {
   switch (target) {
   case 35983:
   case 35368:
    ret = 0;
    break;

   default:
    {
     GL.recordError(1280);
     return;
    }
   }
  } else if (result instanceof WebGLBuffer) {
   ret = result.name | 0;
  } else {
   GL.recordError(1280);
   return;
  }
  break;

 default:
  GL.recordError(1280);
  return;
 }
 switch (type) {
 case 1:
  writeI53ToI64(data, ret);
  break;

 case 0:
  HEAP32[data >>> 2] = ret;
  break;

 case 2:
  HEAPF32[data >>> 2] = ret;
  break;

 case 4:
  HEAP8[data >>> 0] = ret ? 1 : 0;
  break;

 default:
  throw "internal emscriptenWebGLGetIndexed() error, bad type: " + type;
 }
}

function _emscripten_glGetInteger64i_v(target, index, data) {
 emscriptenWebGLGetIndexed(target, index, data, 1);
}

function _emscripten_glGetInteger64v(name_, p) {
 emscriptenWebGLGet(name_, p, 1);
}

function _emscripten_glGetIntegeri_v(target, index, data) {
 emscriptenWebGLGetIndexed(target, index, data, 0);
}

function _emscripten_glGetIntegerv(name_, p) {
 emscriptenWebGLGet(name_, p, 0);
}

function _emscripten_glGetInternalformativ(target, internalformat, pname, bufSize, params) {
 if (bufSize < 0) {
  GL.recordError(1281);
  return;
 }
 if (!params) {
  GL.recordError(1281);
  return;
 }
 var ret = GLctx["getInternalformatParameter"](target, internalformat, pname);
 if (ret === null) return;
 for (var i = 0; i < ret.length && i < bufSize; ++i) {
  HEAP32[params + i * 4 >>> 2] = ret[i];
 }
}

function _emscripten_glGetProgramBinary(program, bufSize, length, binaryFormat, binary) {
 GL.recordError(1282);
}

function _emscripten_glGetProgramInfoLog(program, maxLength, length, infoLog) {
 var log = GLctx.getProgramInfoLog(GL.programs[program]);
 if (log === null) log = "(unknown error)";
 var numBytesWrittenExclNull = maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0;
 if (length) HEAP32[length >>> 2] = numBytesWrittenExclNull;
}

function _emscripten_glGetProgramiv(program, pname, p) {
 if (!p) {
  GL.recordError(1281);
  return;
 }
 if (program >= GL.counter) {
  GL.recordError(1281);
  return;
 }
 program = GL.programs[program];
 if (pname == 35716) {
  var log = GLctx.getProgramInfoLog(program);
  if (log === null) log = "(unknown error)";
  HEAP32[p >>> 2] = log.length + 1;
 } else if (pname == 35719) {
  if (!program.maxUniformLength) {
   for (var i = 0; i < GLctx.getProgramParameter(program, 35718); ++i) {
    program.maxUniformLength = Math.max(program.maxUniformLength, GLctx.getActiveUniform(program, i).name.length + 1);
   }
  }
  HEAP32[p >>> 2] = program.maxUniformLength;
 } else if (pname == 35722) {
  if (!program.maxAttributeLength) {
   for (var i = 0; i < GLctx.getProgramParameter(program, 35721); ++i) {
    program.maxAttributeLength = Math.max(program.maxAttributeLength, GLctx.getActiveAttrib(program, i).name.length + 1);
   }
  }
  HEAP32[p >>> 2] = program.maxAttributeLength;
 } else if (pname == 35381) {
  if (!program.maxUniformBlockNameLength) {
   for (var i = 0; i < GLctx.getProgramParameter(program, 35382); ++i) {
    program.maxUniformBlockNameLength = Math.max(program.maxUniformBlockNameLength, GLctx.getActiveUniformBlockName(program, i).length + 1);
   }
  }
  HEAP32[p >>> 2] = program.maxUniformBlockNameLength;
 } else {
  HEAP32[p >>> 2] = GLctx.getProgramParameter(program, pname);
 }
}

function _emscripten_glGetQueryObjecti64vEXT(id, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 var query = GL.queries[id];
 var param;
 if (GL.currentContext.version < 2) {
  param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
 } else {
  param = GLctx["getQueryParameter"](query, pname);
 }
 var ret;
 if (typeof param == "boolean") {
  ret = param ? 1 : 0;
 } else {
  ret = param;
 }
 writeI53ToI64(params, ret);
}

function _emscripten_glGetQueryObjectivEXT(id, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 var query = GL.queries[id];
 var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
 var ret;
 if (typeof param == "boolean") {
  ret = param ? 1 : 0;
 } else {
  ret = param;
 }
 HEAP32[params >>> 2] = ret;
}

function _emscripten_glGetQueryObjectui64vEXT(id, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 var query = GL.queries[id];
 var param;
 if (GL.currentContext.version < 2) {
  param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
 } else {
  param = GLctx["getQueryParameter"](query, pname);
 }
 var ret;
 if (typeof param == "boolean") {
  ret = param ? 1 : 0;
 } else {
  ret = param;
 }
 writeI53ToI64(params, ret);
}

function _emscripten_glGetQueryObjectuiv(id, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 var query = GL.queries[id];
 var param = GLctx["getQueryParameter"](query, pname);
 var ret;
 if (typeof param == "boolean") {
  ret = param ? 1 : 0;
 } else {
  ret = param;
 }
 HEAP32[params >>> 2] = ret;
}

function _emscripten_glGetQueryObjectuivEXT(id, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 var query = GL.queries[id];
 var param = GLctx.disjointTimerQueryExt["getQueryObjectEXT"](query, pname);
 var ret;
 if (typeof param == "boolean") {
  ret = param ? 1 : 0;
 } else {
  ret = param;
 }
 HEAP32[params >>> 2] = ret;
}

function _emscripten_glGetQueryiv(target, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 HEAP32[params >>> 2] = GLctx["getQuery"](target, pname);
}

function _emscripten_glGetQueryivEXT(target, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 HEAP32[params >>> 2] = GLctx.disjointTimerQueryExt["getQueryEXT"](target, pname);
}

function _emscripten_glGetRenderbufferParameteriv(target, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 HEAP32[params >>> 2] = GLctx.getRenderbufferParameter(target, pname);
}

function _emscripten_glGetSamplerParameterfv(sampler, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 HEAPF32[params >>> 2] = GLctx["getSamplerParameter"](GL.samplers[sampler], pname);
}

function _emscripten_glGetSamplerParameteriv(sampler, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 HEAP32[params >>> 2] = GLctx["getSamplerParameter"](GL.samplers[sampler], pname);
}

function _emscripten_glGetShaderInfoLog(shader, maxLength, length, infoLog) {
 var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
 if (log === null) log = "(unknown error)";
 var numBytesWrittenExclNull = maxLength > 0 && infoLog ? stringToUTF8(log, infoLog, maxLength) : 0;
 if (length) HEAP32[length >>> 2] = numBytesWrittenExclNull;
}

function _emscripten_glGetShaderPrecisionFormat(shaderType, precisionType, range, precision) {
 var result = GLctx.getShaderPrecisionFormat(shaderType, precisionType);
 HEAP32[range >>> 2] = result.rangeMin;
 HEAP32[range + 4 >>> 2] = result.rangeMax;
 HEAP32[precision >>> 2] = result.precision;
}

function _emscripten_glGetShaderSource(shader, bufSize, length, source) {
 var result = GLctx.getShaderSource(GL.shaders[shader]);
 if (!result) return;
 var numBytesWrittenExclNull = bufSize > 0 && source ? stringToUTF8(result, source, bufSize) : 0;
 if (length) HEAP32[length >>> 2] = numBytesWrittenExclNull;
}

function _emscripten_glGetShaderiv(shader, pname, p) {
 if (!p) {
  GL.recordError(1281);
  return;
 }
 if (pname == 35716) {
  var log = GLctx.getShaderInfoLog(GL.shaders[shader]);
  if (log === null) log = "(unknown error)";
  var logLength = log ? log.length + 1 : 0;
  HEAP32[p >>> 2] = logLength;
 } else if (pname == 35720) {
  var source = GLctx.getShaderSource(GL.shaders[shader]);
  var sourceLength = source ? source.length + 1 : 0;
  HEAP32[p >>> 2] = sourceLength;
 } else {
  HEAP32[p >>> 2] = GLctx.getShaderParameter(GL.shaders[shader], pname);
 }
}

function stringToNewUTF8(jsString) {
 var length = lengthBytesUTF8(jsString) + 1;
 var cString = _malloc(length);
 stringToUTF8(jsString, cString, length);
 return cString;
}

function _emscripten_glGetString(name_) {
 var ret = GL.stringCache[name_];
 if (!ret) {
  switch (name_) {
  case 7939:
   var exts = GLctx.getSupportedExtensions() || [];
   exts = exts.concat(exts.map(function(e) {
    return "GL_" + e;
   }));
   ret = stringToNewUTF8(exts.join(" "));
   break;

  case 7936:
  case 7937:
  case 37445:
  case 37446:
   var s = GLctx.getParameter(name_);
   if (!s) {
    GL.recordError(1280);
   }
   ret = s && stringToNewUTF8(s);
   break;

  case 7938:
   var glVersion = GLctx.getParameter(7938);
   if (true) glVersion = "OpenGL ES 3.0 (" + glVersion + ")"; else {
    glVersion = "OpenGL ES 2.0 (" + glVersion + ")";
   }
   ret = stringToNewUTF8(glVersion);
   break;

  case 35724:
   var glslVersion = GLctx.getParameter(35724);
   var ver_re = /^WebGL GLSL ES ([0-9]\.[0-9][0-9]?)(?:$| .*)/;
   var ver_num = glslVersion.match(ver_re);
   if (ver_num !== null) {
    if (ver_num[1].length == 3) ver_num[1] = ver_num[1] + "0";
    glslVersion = "OpenGL ES GLSL ES " + ver_num[1] + " (" + glslVersion + ")";
   }
   ret = stringToNewUTF8(glslVersion);
   break;

  default:
   GL.recordError(1280);
  }
  GL.stringCache[name_] = ret;
 }
 return ret;
}

function _emscripten_glGetStringi(name, index) {
 if (GL.currentContext.version < 2) {
  GL.recordError(1282);
  return 0;
 }
 var stringiCache = GL.stringiCache[name];
 if (stringiCache) {
  if (index < 0 || index >= stringiCache.length) {
   GL.recordError(1281);
   return 0;
  }
  return stringiCache[index];
 }
 switch (name) {
 case 7939:
  var exts = GLctx.getSupportedExtensions() || [];
  exts = exts.concat(exts.map(function(e) {
   return "GL_" + e;
  }));
  exts = exts.map(function(e) {
   return stringToNewUTF8(e);
  });
  stringiCache = GL.stringiCache[name] = exts;
  if (index < 0 || index >= stringiCache.length) {
   GL.recordError(1281);
   return 0;
  }
  return stringiCache[index];

 default:
  GL.recordError(1280);
  return 0;
 }
}

function _emscripten_glGetSynciv(sync, pname, bufSize, length, values) {
 if (bufSize < 0) {
  GL.recordError(1281);
  return;
 }
 if (!values) {
  GL.recordError(1281);
  return;
 }
 var ret = GLctx.getSyncParameter(GL.syncs[sync], pname);
 if (ret !== null) {
  HEAP32[values >>> 2] = ret;
  if (length) HEAP32[length >>> 2] = 1;
 }
}

function _emscripten_glGetTexParameterfv(target, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 HEAPF32[params >>> 2] = GLctx.getTexParameter(target, pname);
}

function _emscripten_glGetTexParameteriv(target, pname, params) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 HEAP32[params >>> 2] = GLctx.getTexParameter(target, pname);
}

function _emscripten_glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name) {
 program = GL.programs[program];
 var info = GLctx["getTransformFeedbackVarying"](program, index);
 if (!info) return;
 if (name && bufSize > 0) {
  var numBytesWrittenExclNull = stringToUTF8(info.name, name, bufSize);
  if (length) HEAP32[length >>> 2] = numBytesWrittenExclNull;
 } else {
  if (length) HEAP32[length >>> 2] = 0;
 }
 if (size) HEAP32[size >>> 2] = info.size;
 if (type) HEAP32[type >>> 2] = info.type;
}

function _emscripten_glGetUniformBlockIndex(program, uniformBlockName) {
 return GLctx["getUniformBlockIndex"](GL.programs[program], UTF8ToString(uniformBlockName));
}

function _emscripten_glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices) {
 if (!uniformIndices) {
  GL.recordError(1281);
  return;
 }
 if (uniformCount > 0 && (uniformNames == 0 || uniformIndices == 0)) {
  GL.recordError(1281);
  return;
 }
 program = GL.programs[program];
 var names = [];
 for (var i = 0; i < uniformCount; i++) names.push(UTF8ToString(HEAP32[uniformNames + i * 4 >>> 2]));
 var result = GLctx["getUniformIndices"](program, names);
 if (!result) return;
 var len = result.length;
 for (var i = 0; i < len; i++) {
  HEAP32[uniformIndices + i * 4 >>> 2] = result[i];
 }
}

function jstoi_q(str) {
 return parseInt(str);
}

function webglGetLeftBracePos(name) {
 return name.slice(-1) == "]" && name.lastIndexOf("[");
}

function webglPrepareUniformLocationsBeforeFirstUse(program) {
 var uniformLocsById = program.uniformLocsById, uniformSizeAndIdsByName = program.uniformSizeAndIdsByName, i, j;
 if (!uniformLocsById) {
  program.uniformLocsById = uniformLocsById = {};
  program.uniformArrayNamesById = {};
  for (i = 0; i < GLctx.getProgramParameter(program, 35718); ++i) {
   var u = GLctx.getActiveUniform(program, i);
   var nm = u.name;
   var sz = u.size;
   var lb = webglGetLeftBracePos(nm);
   var arrayName = lb > 0 ? nm.slice(0, lb) : nm;
   var id = program.uniformIdCounter;
   program.uniformIdCounter += sz;
   uniformSizeAndIdsByName[arrayName] = [ sz, id ];
   for (j = 0; j < sz; ++j) {
    uniformLocsById[id] = j;
    program.uniformArrayNamesById[id++] = arrayName;
   }
  }
 }
}

function _emscripten_glGetUniformLocation(program, name) {
 name = UTF8ToString(name);
 if (program = GL.programs[program]) {
  webglPrepareUniformLocationsBeforeFirstUse(program);
  var uniformLocsById = program.uniformLocsById;
  var arrayIndex = 0;
  var uniformBaseName = name;
  var leftBrace = webglGetLeftBracePos(name);
  if (leftBrace > 0) {
   arrayIndex = jstoi_q(name.slice(leftBrace + 1)) >>> 0;
   uniformBaseName = name.slice(0, leftBrace);
  }
  var sizeAndId = program.uniformSizeAndIdsByName[uniformBaseName];
  if (sizeAndId && arrayIndex < sizeAndId[0]) {
   arrayIndex += sizeAndId[1];
   if (uniformLocsById[arrayIndex] = uniformLocsById[arrayIndex] || GLctx.getUniformLocation(program, name)) {
    return arrayIndex;
   }
  }
 } else {
  GL.recordError(1281);
 }
 return -1;
}

function webglGetUniformLocation(location) {
 var p = GLctx.currentProgram;
 if (p) {
  var webglLoc = p.uniformLocsById[location];
  if (typeof webglLoc == "number") {
   p.uniformLocsById[location] = webglLoc = GLctx.getUniformLocation(p, p.uniformArrayNamesById[location] + (webglLoc > 0 ? "[" + webglLoc + "]" : ""));
  }
  return webglLoc;
 } else {
  GL.recordError(1282);
 }
}

function emscriptenWebGLGetUniform(program, location, params, type) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 program = GL.programs[program];
 webglPrepareUniformLocationsBeforeFirstUse(program);
 var data = GLctx.getUniform(program, webglGetUniformLocation(location));
 if (typeof data == "number" || typeof data == "boolean") {
  switch (type) {
  case 0:
   HEAP32[params >>> 2] = data;
   break;

  case 2:
   HEAPF32[params >>> 2] = data;
   break;
  }
 } else {
  for (var i = 0; i < data.length; i++) {
   switch (type) {
   case 0:
    HEAP32[params + i * 4 >>> 2] = data[i];
    break;

   case 2:
    HEAPF32[params + i * 4 >>> 2] = data[i];
    break;
   }
  }
 }
}

function _emscripten_glGetUniformfv(program, location, params) {
 emscriptenWebGLGetUniform(program, location, params, 2);
}

function _emscripten_glGetUniformiv(program, location, params) {
 emscriptenWebGLGetUniform(program, location, params, 0);
}

function _emscripten_glGetUniformuiv(program, location, params) {
 emscriptenWebGLGetUniform(program, location, params, 0);
}

function emscriptenWebGLGetVertexAttrib(index, pname, params, type) {
 if (!params) {
  GL.recordError(1281);
  return;
 }
 if (GL.currentContext.clientBuffers[index].enabled) {
  err("glGetVertexAttrib*v on client-side array: not supported, bad data returned");
 }
 var data = GLctx.getVertexAttrib(index, pname);
 if (pname == 34975) {
  HEAP32[params >>> 2] = data && data["name"];
 } else if (typeof data == "number" || typeof data == "boolean") {
  switch (type) {
  case 0:
   HEAP32[params >>> 2] = data;
   break;

  case 2:
   HEAPF32[params >>> 2] = data;
   break;

  case 5:
   HEAP32[params >>> 2] = Math.fround(data);
   break;
  }
 } else {
  for (var i = 0; i < data.length; i++) {
   switch (type) {
   case 0:
    HEAP32[params + i * 4 >>> 2] = data[i];
    break;

   case 2:
    HEAPF32[params + i * 4 >>> 2] = data[i];
    break;

   case 5:
    HEAP32[params + i * 4 >>> 2] = Math.fround(data[i]);
    break;
   }
  }
 }
}

function _emscripten_glGetVertexAttribIiv(index, pname, params) {
 emscriptenWebGLGetVertexAttrib(index, pname, params, 0);
}

function _emscripten_glGetVertexAttribIuiv(index, pname, params) {
 emscriptenWebGLGetVertexAttrib(index, pname, params, 0);
}

function _emscripten_glGetVertexAttribPointerv(index, pname, pointer) {
 if (!pointer) {
  GL.recordError(1281);
  return;
 }
 if (GL.currentContext.clientBuffers[index].enabled) {
  err("glGetVertexAttribPointer on client-side array: not supported, bad data returned");
 }
 HEAP32[pointer >>> 2] = GLctx.getVertexAttribOffset(index, pname);
}

function _emscripten_glGetVertexAttribfv(index, pname, params) {
 emscriptenWebGLGetVertexAttrib(index, pname, params, 2);
}

function _emscripten_glGetVertexAttribiv(index, pname, params) {
 emscriptenWebGLGetVertexAttrib(index, pname, params, 5);
}

function _emscripten_glHint(x0, x1) {
 GLctx["hint"](x0, x1);
}

function _emscripten_glInvalidateFramebuffer(target, numAttachments, attachments) {
 var list = tempFixedLengthArray[numAttachments];
 for (var i = 0; i < numAttachments; i++) {
  list[i] = HEAP32[attachments + i * 4 >>> 2];
 }
 GLctx["invalidateFramebuffer"](target, list);
}

function _emscripten_glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height) {
 var list = tempFixedLengthArray[numAttachments];
 for (var i = 0; i < numAttachments; i++) {
  list[i] = HEAP32[attachments + i * 4 >>> 2];
 }
 GLctx["invalidateSubFramebuffer"](target, list, x, y, width, height);
}

function _emscripten_glIsBuffer(buffer) {
 var b = GL.buffers[buffer];
 if (!b) return 0;
 return GLctx.isBuffer(b);
}

function _emscripten_glIsEnabled(x0) {
 return GLctx["isEnabled"](x0);
}

function _emscripten_glIsFramebuffer(framebuffer) {
 var fb = GL.framebuffers[framebuffer];
 if (!fb) return 0;
 return GLctx.isFramebuffer(fb);
}

function _emscripten_glIsProgram(program) {
 program = GL.programs[program];
 if (!program) return 0;
 return GLctx.isProgram(program);
}

function _emscripten_glIsQuery(id) {
 var query = GL.queries[id];
 if (!query) return 0;
 return GLctx["isQuery"](query);
}

function _emscripten_glIsQueryEXT(id) {
 var query = GL.queries[id];
 if (!query) return 0;
 return GLctx.disjointTimerQueryExt["isQueryEXT"](query);
}

function _emscripten_glIsRenderbuffer(renderbuffer) {
 var rb = GL.renderbuffers[renderbuffer];
 if (!rb) return 0;
 return GLctx.isRenderbuffer(rb);
}

function _emscripten_glIsSampler(id) {
 var sampler = GL.samplers[id];
 if (!sampler) return 0;
 return GLctx["isSampler"](sampler);
}

function _emscripten_glIsShader(shader) {
 var s = GL.shaders[shader];
 if (!s) return 0;
 return GLctx.isShader(s);
}

function _emscripten_glIsSync(sync) {
 return GLctx.isSync(GL.syncs[sync]);
}

function _emscripten_glIsTexture(id) {
 var texture = GL.textures[id];
 if (!texture) return 0;
 return GLctx.isTexture(texture);
}

function _emscripten_glIsTransformFeedback(id) {
 return GLctx["isTransformFeedback"](GL.transformFeedbacks[id]);
}

function _emscripten_glIsVertexArray(array) {
 var vao = GL.vaos[array];
 if (!vao) return 0;
 return GLctx["isVertexArray"](vao);
}

function _emscripten_glIsVertexArrayOES(array) {
 var vao = GL.vaos[array];
 if (!vao) return 0;
 return GLctx["isVertexArray"](vao);
}

function _emscripten_glLineWidth(x0) {
 GLctx["lineWidth"](x0);
}

function _emscripten_glLinkProgram(program) {
 program = GL.programs[program];
 GLctx.linkProgram(program);
 program.uniformLocsById = 0;
 program.uniformSizeAndIdsByName = {};
}

function _emscripten_glMapBufferRange(target, offset, length, access) {
 if ((access & (1 | 32)) != 0) {
  err("glMapBufferRange access does not support MAP_READ or MAP_UNSYNCHRONIZED");
  return 0;
 }
 if ((access & 2) == 0) {
  err("glMapBufferRange access must include MAP_WRITE");
  return 0;
 }
 if ((access & (4 | 8)) == 0) {
  err("glMapBufferRange access must include INVALIDATE_BUFFER or INVALIDATE_RANGE");
  return 0;
 }
 if (!emscriptenWebGLValidateMapBufferTarget(target)) {
  GL.recordError(1280);
  err("GL_INVALID_ENUM in glMapBufferRange");
  return 0;
 }
 var mem = _malloc(length);
 if (!mem) return 0;
 GL.mappedBuffers[emscriptenWebGLGetBufferBinding(target)] = {
  offset: offset,
  length: length,
  mem: mem,
  access: access
 };
 return mem;
}

function _emscripten_glPauseTransformFeedback() {
 GLctx["pauseTransformFeedback"]();
}

function _emscripten_glPixelStorei(pname, param) {
 if (pname == 3317) {
  GL.unpackAlignment = param;
 }
 GLctx.pixelStorei(pname, param);
}

function _emscripten_glPolygonOffset(x0, x1) {
 GLctx["polygonOffset"](x0, x1);
}

function _emscripten_glProgramBinary(program, binaryFormat, binary, length) {
 GL.recordError(1280);
}

function _emscripten_glProgramParameteri(program, pname, value) {
 GL.recordError(1280);
}

function _emscripten_glQueryCounterEXT(id, target) {
 GLctx.disjointTimerQueryExt["queryCounterEXT"](GL.queries[id], target);
}

function _emscripten_glReadBuffer(x0) {
 GLctx["readBuffer"](x0);
}

function computeUnpackAlignedImageSize(width, height, sizePerPixel, alignment) {
 function roundedToNextMultipleOf(x, y) {
  return x + y - 1 & -y;
 }
 var plainRowSize = width * sizePerPixel;
 var alignedRowSize = roundedToNextMultipleOf(plainRowSize, alignment);
 return height * alignedRowSize;
}

function __colorChannelsInGlTextureFormat(format) {
 var colorChannels = {
  5: 3,
  6: 4,
  8: 2,
  29502: 3,
  29504: 4,
  26917: 2,
  26918: 2,
  29846: 3,
  29847: 4
 };
 return colorChannels[format - 6402] || 1;
}

function heapObjectForWebGLType(type) {
 type -= 5120;
 if (type == 0) return HEAP8;
 if (type == 1) return HEAPU8;
 if (type == 2) return HEAP16;
 if (type == 4) return HEAP32;
 if (type == 6) return HEAPF32;
 if (type == 5 || type == 28922 || type == 28520 || type == 30779 || type == 30782) return HEAPU32;
 return HEAPU16;
}

function heapAccessShiftForWebGLHeap(heap) {
 return 31 - Math.clz32(heap.BYTES_PER_ELEMENT);
}

function emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) {
 var heap = heapObjectForWebGLType(type);
 var shift = heapAccessShiftForWebGLHeap(heap);
 var byteSize = 1 << shift;
 var sizePerPixel = __colorChannelsInGlTextureFormat(format) * byteSize;
 var bytes = computeUnpackAlignedImageSize(width, height, sizePerPixel, GL.unpackAlignment);
 return heap.subarray(pixels >>> shift, pixels + bytes >>> shift);
}

function _emscripten_glReadPixels(x, y, width, height, format, type, pixels) {
 if (true) {
  if (GLctx.currentPixelPackBufferBinding) {
   GLctx.readPixels(x, y, width, height, format, type, pixels);
  } else {
   var heap = heapObjectForWebGLType(type);
   GLctx.readPixels(x, y, width, height, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap));
  }
  return;
 }
 var pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, format);
 if (!pixelData) {
  GL.recordError(1280);
  return;
 }
 GLctx.readPixels(x, y, width, height, format, type, pixelData);
}

function _emscripten_glReleaseShaderCompiler() {}

function _emscripten_glRenderbufferStorage(x0, x1, x2, x3) {
 GLctx["renderbufferStorage"](x0, x1, x2, x3);
}

function _emscripten_glRenderbufferStorageMultisample(x0, x1, x2, x3, x4) {
 GLctx["renderbufferStorageMultisample"](x0, x1, x2, x3, x4);
}

function _emscripten_glResumeTransformFeedback() {
 GLctx["resumeTransformFeedback"]();
}

function _emscripten_glSampleCoverage(value, invert) {
 GLctx.sampleCoverage(value, !!invert);
}

function _emscripten_glSamplerParameterf(sampler, pname, param) {
 GLctx["samplerParameterf"](GL.samplers[sampler], pname, param);
}

function _emscripten_glSamplerParameterfv(sampler, pname, params) {
 var param = HEAPF32[params >>> 2];
 GLctx["samplerParameterf"](GL.samplers[sampler], pname, param);
}

function _emscripten_glSamplerParameteri(sampler, pname, param) {
 GLctx["samplerParameteri"](GL.samplers[sampler], pname, param);
}

function _emscripten_glSamplerParameteriv(sampler, pname, params) {
 var param = HEAP32[params >>> 2];
 GLctx["samplerParameteri"](GL.samplers[sampler], pname, param);
}

function _emscripten_glScissor(x0, x1, x2, x3) {
 GLctx["scissor"](x0, x1, x2, x3);
}

function _emscripten_glShaderBinary() {
 GL.recordError(1280);
}

function _emscripten_glShaderSource(shader, count, string, length) {
 var source = GL.getSource(shader, count, string, length);
 GLctx.shaderSource(GL.shaders[shader], source);
}

function _emscripten_glStencilFunc(x0, x1, x2) {
 GLctx["stencilFunc"](x0, x1, x2);
}

function _emscripten_glStencilFuncSeparate(x0, x1, x2, x3) {
 GLctx["stencilFuncSeparate"](x0, x1, x2, x3);
}

function _emscripten_glStencilMask(x0) {
 GLctx["stencilMask"](x0);
}

function _emscripten_glStencilMaskSeparate(x0, x1) {
 GLctx["stencilMaskSeparate"](x0, x1);
}

function _emscripten_glStencilOp(x0, x1, x2) {
 GLctx["stencilOp"](x0, x1, x2);
}

function _emscripten_glStencilOpSeparate(x0, x1, x2, x3) {
 GLctx["stencilOpSeparate"](x0, x1, x2, x3);
}

function _emscripten_glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels) {
 if (true) {
  if (GLctx.currentPixelUnpackBufferBinding) {
   GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
  } else if (pixels) {
   var heap = heapObjectForWebGLType(type);
   GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap));
  } else {
   GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, null);
  }
  return;
 }
 GLctx.texImage2D(target, level, internalFormat, width, height, border, format, type, pixels ? emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, internalFormat) : null);
}

function _emscripten_glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels) {
 if (GLctx.currentPixelUnpackBufferBinding) {
  GLctx["texImage3D"](target, level, internalFormat, width, height, depth, border, format, type, pixels);
 } else if (pixels) {
  var heap = heapObjectForWebGLType(type);
  GLctx["texImage3D"](target, level, internalFormat, width, height, depth, border, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap));
 } else {
  GLctx["texImage3D"](target, level, internalFormat, width, height, depth, border, format, type, null);
 }
}

function _emscripten_glTexParameterf(x0, x1, x2) {
 GLctx["texParameterf"](x0, x1, x2);
}

function _emscripten_glTexParameterfv(target, pname, params) {
 var param = HEAPF32[params >>> 2];
 GLctx.texParameterf(target, pname, param);
}

function _emscripten_glTexParameteri(x0, x1, x2) {
 GLctx["texParameteri"](x0, x1, x2);
}

function _emscripten_glTexParameteriv(target, pname, params) {
 var param = HEAP32[params >>> 2];
 GLctx.texParameteri(target, pname, param);
}

function _emscripten_glTexStorage2D(x0, x1, x2, x3, x4) {
 GLctx["texStorage2D"](x0, x1, x2, x3, x4);
}

function _emscripten_glTexStorage3D(x0, x1, x2, x3, x4, x5) {
 GLctx["texStorage3D"](x0, x1, x2, x3, x4, x5);
}

function _emscripten_glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels) {
 if (true) {
  if (GLctx.currentPixelUnpackBufferBinding) {
   GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
  } else if (pixels) {
   var heap = heapObjectForWebGLType(type);
   GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap));
  } else {
   GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, null);
  }
  return;
 }
 var pixelData = null;
 if (pixels) pixelData = emscriptenWebGLGetTexPixelData(type, format, width, height, pixels, 0);
 GLctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixelData);
}

function _emscripten_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels) {
 if (GLctx.currentPixelUnpackBufferBinding) {
  GLctx["texSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 } else if (pixels) {
  var heap = heapObjectForWebGLType(type);
  GLctx["texSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, heap, pixels >> heapAccessShiftForWebGLHeap(heap));
 } else {
  GLctx["texSubImage3D"](target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, null);
 }
}

function _emscripten_glTransformFeedbackVaryings(program, count, varyings, bufferMode) {
 program = GL.programs[program];
 var vars = [];
 for (var i = 0; i < count; i++) vars.push(UTF8ToString(HEAP32[varyings + i * 4 >>> 2]));
 GLctx["transformFeedbackVaryings"](program, vars, bufferMode);
}

function _emscripten_glUniform1f(location, v0) {
 GLctx.uniform1f(webglGetUniformLocation(location), v0);
}

function _emscripten_glUniform1fv(location, count, value) {
 count && GLctx.uniform1fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count);
}

function _emscripten_glUniform1i(location, v0) {
 GLctx.uniform1i(webglGetUniformLocation(location), v0);
}

function _emscripten_glUniform1iv(location, count, value) {
 count && GLctx.uniform1iv(webglGetUniformLocation(location), HEAP32, value >> 2, count);
}

function _emscripten_glUniform1ui(location, v0) {
 GLctx.uniform1ui(webglGetUniformLocation(location), v0);
}

function _emscripten_glUniform1uiv(location, count, value) {
 count && GLctx.uniform1uiv(webglGetUniformLocation(location), HEAPU32, value >> 2, count);
}

function _emscripten_glUniform2f(location, v0, v1) {
 GLctx.uniform2f(webglGetUniformLocation(location), v0, v1);
}

function _emscripten_glUniform2fv(location, count, value) {
 count && GLctx.uniform2fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 2);
}

function _emscripten_glUniform2i(location, v0, v1) {
 GLctx.uniform2i(webglGetUniformLocation(location), v0, v1);
}

function _emscripten_glUniform2iv(location, count, value) {
 count && GLctx.uniform2iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 2);
}

function _emscripten_glUniform2ui(location, v0, v1) {
 GLctx.uniform2ui(webglGetUniformLocation(location), v0, v1);
}

function _emscripten_glUniform2uiv(location, count, value) {
 count && GLctx.uniform2uiv(webglGetUniformLocation(location), HEAPU32, value >> 2, count * 2);
}

function _emscripten_glUniform3f(location, v0, v1, v2) {
 GLctx.uniform3f(webglGetUniformLocation(location), v0, v1, v2);
}

function _emscripten_glUniform3fv(location, count, value) {
 count && GLctx.uniform3fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 3);
}

function _emscripten_glUniform3i(location, v0, v1, v2) {
 GLctx.uniform3i(webglGetUniformLocation(location), v0, v1, v2);
}

function _emscripten_glUniform3iv(location, count, value) {
 count && GLctx.uniform3iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 3);
}

function _emscripten_glUniform3ui(location, v0, v1, v2) {
 GLctx.uniform3ui(webglGetUniformLocation(location), v0, v1, v2);
}

function _emscripten_glUniform3uiv(location, count, value) {
 count && GLctx.uniform3uiv(webglGetUniformLocation(location), HEAPU32, value >> 2, count * 3);
}

function _emscripten_glUniform4f(location, v0, v1, v2, v3) {
 GLctx.uniform4f(webglGetUniformLocation(location), v0, v1, v2, v3);
}

function _emscripten_glUniform4fv(location, count, value) {
 count && GLctx.uniform4fv(webglGetUniformLocation(location), HEAPF32, value >> 2, count * 4);
}

function _emscripten_glUniform4i(location, v0, v1, v2, v3) {
 GLctx.uniform4i(webglGetUniformLocation(location), v0, v1, v2, v3);
}

function _emscripten_glUniform4iv(location, count, value) {
 count && GLctx.uniform4iv(webglGetUniformLocation(location), HEAP32, value >> 2, count * 4);
}

function _emscripten_glUniform4ui(location, v0, v1, v2, v3) {
 GLctx.uniform4ui(webglGetUniformLocation(location), v0, v1, v2, v3);
}

function _emscripten_glUniform4uiv(location, count, value) {
 count && GLctx.uniform4uiv(webglGetUniformLocation(location), HEAPU32, value >> 2, count * 4);
}

function _emscripten_glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding) {
 program = GL.programs[program];
 GLctx["uniformBlockBinding"](program, uniformBlockIndex, uniformBlockBinding);
}

function _emscripten_glUniformMatrix2fv(location, count, transpose, value) {
 count && GLctx.uniformMatrix2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 4);
}

function _emscripten_glUniformMatrix2x3fv(location, count, transpose, value) {
 count && GLctx.uniformMatrix2x3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 6);
}

function _emscripten_glUniformMatrix2x4fv(location, count, transpose, value) {
 count && GLctx.uniformMatrix2x4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 8);
}

function _emscripten_glUniformMatrix3fv(location, count, transpose, value) {
 count && GLctx.uniformMatrix3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 9);
}

function _emscripten_glUniformMatrix3x2fv(location, count, transpose, value) {
 count && GLctx.uniformMatrix3x2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 6);
}

function _emscripten_glUniformMatrix3x4fv(location, count, transpose, value) {
 count && GLctx.uniformMatrix3x4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 12);
}

function _emscripten_glUniformMatrix4fv(location, count, transpose, value) {
 count && GLctx.uniformMatrix4fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 16);
}

function _emscripten_glUniformMatrix4x2fv(location, count, transpose, value) {
 count && GLctx.uniformMatrix4x2fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 8);
}

function _emscripten_glUniformMatrix4x3fv(location, count, transpose, value) {
 count && GLctx.uniformMatrix4x3fv(webglGetUniformLocation(location), !!transpose, HEAPF32, value >> 2, count * 12);
}

function _emscripten_glUnmapBuffer(target) {
 if (!emscriptenWebGLValidateMapBufferTarget(target)) {
  GL.recordError(1280);
  err("GL_INVALID_ENUM in glUnmapBuffer");
  return 0;
 }
 var buffer = emscriptenWebGLGetBufferBinding(target);
 var mapping = GL.mappedBuffers[buffer];
 if (!mapping) {
  GL.recordError(1282);
  err("buffer was never mapped in glUnmapBuffer");
  return 0;
 }
 GL.mappedBuffers[buffer] = null;
 if (!(mapping.access & 16)) if (true) {
  GLctx.bufferSubData(target, mapping.offset, HEAPU8, mapping.mem, mapping.length);
 } else {
  GLctx.bufferSubData(target, mapping.offset, HEAPU8.subarray(mapping.mem >>> 0, mapping.mem + mapping.length >>> 0));
 }
 _free(mapping.mem);
 return 1;
}

function _emscripten_glUseProgram(program) {
 program = GL.programs[program];
 GLctx.useProgram(program);
 GLctx.currentProgram = program;
}

function _emscripten_glValidateProgram(program) {
 GLctx.validateProgram(GL.programs[program]);
}

function _emscripten_glVertexAttrib1f(x0, x1) {
 GLctx["vertexAttrib1f"](x0, x1);
}

function _emscripten_glVertexAttrib1fv(index, v) {
 GLctx.vertexAttrib1f(index, HEAPF32[v >>> 2]);
}

function _emscripten_glVertexAttrib2f(x0, x1, x2) {
 GLctx["vertexAttrib2f"](x0, x1, x2);
}

function _emscripten_glVertexAttrib2fv(index, v) {
 GLctx.vertexAttrib2f(index, HEAPF32[v >>> 2], HEAPF32[v + 4 >>> 2]);
}

function _emscripten_glVertexAttrib3f(x0, x1, x2, x3) {
 GLctx["vertexAttrib3f"](x0, x1, x2, x3);
}

function _emscripten_glVertexAttrib3fv(index, v) {
 GLctx.vertexAttrib3f(index, HEAPF32[v >>> 2], HEAPF32[v + 4 >>> 2], HEAPF32[v + 8 >>> 2]);
}

function _emscripten_glVertexAttrib4f(x0, x1, x2, x3, x4) {
 GLctx["vertexAttrib4f"](x0, x1, x2, x3, x4);
}

function _emscripten_glVertexAttrib4fv(index, v) {
 GLctx.vertexAttrib4f(index, HEAPF32[v >>> 2], HEAPF32[v + 4 >>> 2], HEAPF32[v + 8 >>> 2], HEAPF32[v + 12 >>> 2]);
}

function _emscripten_glVertexAttribDivisor(index, divisor) {
 GLctx["vertexAttribDivisor"](index, divisor);
}

function _emscripten_glVertexAttribDivisorANGLE(index, divisor) {
 GLctx["vertexAttribDivisor"](index, divisor);
}

function _emscripten_glVertexAttribDivisorARB(index, divisor) {
 GLctx["vertexAttribDivisor"](index, divisor);
}

function _emscripten_glVertexAttribDivisorEXT(index, divisor) {
 GLctx["vertexAttribDivisor"](index, divisor);
}

function _emscripten_glVertexAttribDivisorNV(index, divisor) {
 GLctx["vertexAttribDivisor"](index, divisor);
}

function _emscripten_glVertexAttribI4i(x0, x1, x2, x3, x4) {
 GLctx["vertexAttribI4i"](x0, x1, x2, x3, x4);
}

function _emscripten_glVertexAttribI4iv(index, v) {
 GLctx.vertexAttribI4i(index, HEAP32[v >>> 2], HEAP32[v + 4 >>> 2], HEAP32[v + 8 >>> 2], HEAP32[v + 12 >>> 2]);
}

function _emscripten_glVertexAttribI4ui(x0, x1, x2, x3, x4) {
 GLctx["vertexAttribI4ui"](x0, x1, x2, x3, x4);
}

function _emscripten_glVertexAttribI4uiv(index, v) {
 GLctx.vertexAttribI4ui(index, HEAPU32[v >>> 2], HEAPU32[v + 4 >>> 2], HEAPU32[v + 8 >>> 2], HEAPU32[v + 12 >>> 2]);
}

function _emscripten_glVertexAttribIPointer(index, size, type, stride, ptr) {
 var cb = GL.currentContext.clientBuffers[index];
 if (!GLctx.currentArrayBufferBinding) {
  cb.size = size;
  cb.type = type;
  cb.normalized = false;
  cb.stride = stride;
  cb.ptr = ptr;
  cb.clientside = true;
  cb.vertexAttribPointerAdaptor = function(index, size, type, normalized, stride, ptr) {
   this.vertexAttribIPointer(index, size, type, stride, ptr);
  };
  return;
 }
 cb.clientside = false;
 GLctx["vertexAttribIPointer"](index, size, type, stride, ptr);
}

function _emscripten_glVertexAttribPointer(index, size, type, normalized, stride, ptr) {
 var cb = GL.currentContext.clientBuffers[index];
 if (!GLctx.currentArrayBufferBinding) {
  cb.size = size;
  cb.type = type;
  cb.normalized = normalized;
  cb.stride = stride;
  cb.ptr = ptr;
  cb.clientside = true;
  cb.vertexAttribPointerAdaptor = function(index, size, type, normalized, stride, ptr) {
   this.vertexAttribPointer(index, size, type, normalized, stride, ptr);
  };
  return;
 }
 cb.clientside = false;
 GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
}

function _emscripten_glViewport(x0, x1, x2, x3) {
 GLctx["viewport"](x0, x1, x2, x3);
}

function _emscripten_glWaitSync(sync, flags, timeoutLo, timeoutHi) {
 GLctx.waitSync(GL.syncs[sync], flags, convertI32PairToI53(timeoutLo, timeoutHi));
}

function _emscripten_has_asyncify() {
 return 0;
}

function _emscripten_memcpy_big(dest, src, num) {
 HEAPU8.copyWithin(dest >>> 0, src >>> 0, src + num >>> 0);
}

function doRequestFullscreen(target, strategy) {
 if (!JSEvents.fullscreenEnabled()) return -1;
 target = findEventTarget(target);
 if (!target) return -4;
 if (!target.requestFullscreen && !target.webkitRequestFullscreen) {
  return -3;
 }
 var canPerformRequests = JSEvents.canPerformEventHandlerRequests();
 if (!canPerformRequests) {
  if (strategy.deferUntilInEventHandler) {
   JSEvents.deferCall(JSEvents_requestFullscreen, 1, [ target, strategy ]);
   return 1;
  }
  return -2;
 }
 return JSEvents_requestFullscreen(target, strategy);
}

function _emscripten_request_fullscreen_strategy(target, deferUntilInEventHandler, fullscreenStrategy) {
 var strategy = {
  scaleMode: HEAP32[fullscreenStrategy >>> 2],
  canvasResolutionScaleMode: HEAP32[fullscreenStrategy + 4 >>> 2],
  filteringMode: HEAP32[fullscreenStrategy + 8 >>> 2],
  deferUntilInEventHandler: deferUntilInEventHandler,
  canvasResizedCallback: HEAP32[fullscreenStrategy + 12 >>> 2],
  canvasResizedCallbackUserData: HEAP32[fullscreenStrategy + 16 >>> 2]
 };
 return doRequestFullscreen(target, strategy);
}

function _emscripten_request_pointerlock(target, deferUntilInEventHandler) {
 target = findEventTarget(target);
 if (!target) return -4;
 if (!target.requestPointerLock) {
  return -1;
 }
 var canPerformRequests = JSEvents.canPerformEventHandlerRequests();
 if (!canPerformRequests) {
  if (deferUntilInEventHandler) {
   JSEvents.deferCall(requestPointerLock, 2, [ target ]);
   return 1;
  }
  return -2;
 }
 return requestPointerLock(target);
}

function getHeapMax() {
 return 4294901760;
}

function emscripten_realloc_buffer(size) {
 try {
  wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);
  updateGlobalBufferAndViews(wasmMemory.buffer);
  return 1;
 } catch (e) {
  err("emscripten_realloc_buffer: Attempted to grow heap from " + buffer.byteLength + " bytes to " + size + " bytes, but got error: " + e);
 }
}

function _emscripten_resize_heap(requestedSize) {
 var oldSize = HEAPU8.length;
 requestedSize = requestedSize >>> 0;
 assert(requestedSize > oldSize);
 var maxHeapSize = getHeapMax();
 if (requestedSize > maxHeapSize) {
  err("Cannot enlarge memory, asked to go up to " + requestedSize + " bytes, but the limit is " + maxHeapSize + " bytes!");
  return false;
 }
 let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
 for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
  var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
  overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
  var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
  var replacement = emscripten_realloc_buffer(newSize);
  if (replacement) {
   return true;
  }
 }
 err("Failed to grow the heap from " + oldSize + " bytes to " + newSize + " bytes, not enough memory!");
 return false;
}

function _emscripten_sample_gamepad_data() {
 return (JSEvents.lastGamepadState = navigator.getGamepads ? navigator.getGamepads() : navigator.webkitGetGamepads ? navigator.webkitGetGamepads() : null) ? 0 : -1;
}

function registerBeforeUnloadEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString) {
 var beforeUnloadEventHandlerFunc = function(ev) {
  var e = ev || event;
  var confirmationMessage = getWasmTableEntry(callbackfunc)(eventTypeId, 0, userData);
  if (confirmationMessage) {
   confirmationMessage = UTF8ToString(confirmationMessage);
  }
  if (confirmationMessage) {
   e.preventDefault();
   e.returnValue = confirmationMessage;
   return confirmationMessage;
  }
 };
 var eventHandler = {
  target: findEventTarget(target),
  eventTypeString: eventTypeString,
  callbackfunc: callbackfunc,
  handlerFunc: beforeUnloadEventHandlerFunc,
  useCapture: useCapture
 };
 JSEvents.registerOrRemoveHandler(eventHandler);
}

function _emscripten_set_beforeunload_callback_on_thread(userData, callbackfunc, targetThread) {
 if (typeof onbeforeunload == "undefined") return -1;
 if (targetThread !== 1) return -5;
 registerBeforeUnloadEventCallback(2, userData, true, callbackfunc, 28, "beforeunload");
 return 0;
}

function registerFocusEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 if (!JSEvents.focusEvent) JSEvents.focusEvent = _malloc(256);
 var focusEventHandlerFunc = function(ev) {
  var e = ev || event;
  var nodeName = JSEvents.getNodeNameForTarget(e.target);
  var id = e.target.id ? e.target.id : "";
  var focusEvent = JSEvents.focusEvent;
  stringToUTF8(nodeName, focusEvent + 0, 128);
  stringToUTF8(id, focusEvent + 128, 128);
  if (getWasmTableEntry(callbackfunc)(eventTypeId, focusEvent, userData)) e.preventDefault();
 };
 var eventHandler = {
  target: findEventTarget(target),
  eventTypeString: eventTypeString,
  callbackfunc: callbackfunc,
  handlerFunc: focusEventHandlerFunc,
  useCapture: useCapture
 };
 JSEvents.registerOrRemoveHandler(eventHandler);
}

function _emscripten_set_blur_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerFocusEventCallback(target, userData, useCapture, callbackfunc, 12, "blur", targetThread);
 return 0;
}

function fillMouseEventData(eventStruct, e, target) {
 assert(eventStruct % 4 == 0);
 HEAPF64[eventStruct >>> 3] = e.timeStamp;
 var idx = eventStruct >> 2;
 HEAP32[idx + 2 >>> 0] = e.screenX;
 HEAP32[idx + 3 >>> 0] = e.screenY;
 HEAP32[idx + 4 >>> 0] = e.clientX;
 HEAP32[idx + 5 >>> 0] = e.clientY;
 HEAP32[idx + 6 >>> 0] = e.ctrlKey;
 HEAP32[idx + 7 >>> 0] = e.shiftKey;
 HEAP32[idx + 8 >>> 0] = e.altKey;
 HEAP32[idx + 9 >>> 0] = e.metaKey;
 HEAP16[idx * 2 + 20 >>> 0] = e.button;
 HEAP16[idx * 2 + 21 >>> 0] = e.buttons;
 HEAP32[idx + 11 >>> 0] = e["movementX"];
 HEAP32[idx + 12 >>> 0] = e["movementY"];
 var rect = getBoundingClientRect(target);
 HEAP32[idx + 13 >>> 0] = e.clientX - rect.left;
 HEAP32[idx + 14 >>> 0] = e.clientY - rect.top;
}

function registerMouseEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 if (!JSEvents.mouseEvent) JSEvents.mouseEvent = _malloc(72);
 target = findEventTarget(target);
 var mouseEventHandlerFunc = function(ev) {
  var e = ev || event;
  fillMouseEventData(JSEvents.mouseEvent, e, target);
  if (getWasmTableEntry(callbackfunc)(eventTypeId, JSEvents.mouseEvent, userData)) e.preventDefault();
 };
 var eventHandler = {
  target: target,
  allowsDeferredCalls: eventTypeString != "mousemove" && eventTypeString != "mouseenter" && eventTypeString != "mouseleave",
  eventTypeString: eventTypeString,
  callbackfunc: callbackfunc,
  handlerFunc: mouseEventHandlerFunc,
  useCapture: useCapture
 };
 JSEvents.registerOrRemoveHandler(eventHandler);
}

function _emscripten_set_click_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerMouseEventCallback(target, userData, useCapture, callbackfunc, 4, "click", targetThread);
 return 0;
}

function _emscripten_set_element_css_size(target, width, height) {
 target = findEventTarget(target);
 if (!target) return -4;
 target.style.width = width + "px";
 target.style.height = height + "px";
 return 0;
}

function _emscripten_set_focus_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerFocusEventCallback(target, userData, useCapture, callbackfunc, 13, "focus", targetThread);
 return 0;
}

function fillFullscreenChangeEventData(eventStruct) {
 var fullscreenElement = document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.msFullscreenElement;
 var isFullscreen = !!fullscreenElement;
 HEAP32[eventStruct >>> 2] = isFullscreen;
 HEAP32[eventStruct + 4 >>> 2] = JSEvents.fullscreenEnabled();
 var reportedElement = isFullscreen ? fullscreenElement : JSEvents.previousFullscreenElement;
 var nodeName = JSEvents.getNodeNameForTarget(reportedElement);
 var id = reportedElement && reportedElement.id ? reportedElement.id : "";
 stringToUTF8(nodeName, eventStruct + 8, 128);
 stringToUTF8(id, eventStruct + 136, 128);
 HEAP32[eventStruct + 264 >>> 2] = reportedElement ? reportedElement.clientWidth : 0;
 HEAP32[eventStruct + 268 >>> 2] = reportedElement ? reportedElement.clientHeight : 0;
 HEAP32[eventStruct + 272 >>> 2] = screen.width;
 HEAP32[eventStruct + 276 >>> 2] = screen.height;
 if (isFullscreen) {
  JSEvents.previousFullscreenElement = fullscreenElement;
 }
}

function registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 if (!JSEvents.fullscreenChangeEvent) JSEvents.fullscreenChangeEvent = _malloc(280);
 var fullscreenChangeEventhandlerFunc = function(ev) {
  var e = ev || event;
  var fullscreenChangeEvent = JSEvents.fullscreenChangeEvent;
  fillFullscreenChangeEventData(fullscreenChangeEvent);
  if (getWasmTableEntry(callbackfunc)(eventTypeId, fullscreenChangeEvent, userData)) e.preventDefault();
 };
 var eventHandler = {
  target: target,
  eventTypeString: eventTypeString,
  callbackfunc: callbackfunc,
  handlerFunc: fullscreenChangeEventhandlerFunc,
  useCapture: useCapture
 };
 JSEvents.registerOrRemoveHandler(eventHandler);
}

function _emscripten_set_fullscreenchange_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 if (!JSEvents.fullscreenEnabled()) return -1;
 target = findEventTarget(target);
 if (!target) return -4;
 registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "fullscreenchange", targetThread);
 registerFullscreenChangeEventCallback(target, userData, useCapture, callbackfunc, 19, "webkitfullscreenchange", targetThread);
 return 0;
}

function registerGamepadEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 if (!JSEvents.gamepadEvent) JSEvents.gamepadEvent = _malloc(1432);
 var gamepadEventHandlerFunc = function(ev) {
  var e = ev || event;
  var gamepadEvent = JSEvents.gamepadEvent;
  fillGamepadEventData(gamepadEvent, e["gamepad"]);
  if (getWasmTableEntry(callbackfunc)(eventTypeId, gamepadEvent, userData)) e.preventDefault();
 };
 var eventHandler = {
  target: findEventTarget(target),
  allowsDeferredCalls: true,
  eventTypeString: eventTypeString,
  callbackfunc: callbackfunc,
  handlerFunc: gamepadEventHandlerFunc,
  useCapture: useCapture
 };
 JSEvents.registerOrRemoveHandler(eventHandler);
}

function _emscripten_set_gamepadconnected_callback_on_thread(userData, useCapture, callbackfunc, targetThread) {
 if (!navigator.getGamepads && !navigator.webkitGetGamepads) return -1;
 registerGamepadEventCallback(2, userData, useCapture, callbackfunc, 26, "gamepadconnected", targetThread);
 return 0;
}

function _emscripten_set_gamepaddisconnected_callback_on_thread(userData, useCapture, callbackfunc, targetThread) {
 if (!navigator.getGamepads && !navigator.webkitGetGamepads) return -1;
 registerGamepadEventCallback(2, userData, useCapture, callbackfunc, 27, "gamepaddisconnected", targetThread);
 return 0;
}

function registerKeyEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 if (!JSEvents.keyEvent) JSEvents.keyEvent = _malloc(176);
 var keyEventHandlerFunc = function(e) {
  assert(e);
  var keyEventData = JSEvents.keyEvent;
  HEAPF64[keyEventData >>> 3] = e.timeStamp;
  var idx = keyEventData >> 2;
  HEAP32[idx + 2 >>> 0] = e.location;
  HEAP32[idx + 3 >>> 0] = e.ctrlKey;
  HEAP32[idx + 4 >>> 0] = e.shiftKey;
  HEAP32[idx + 5 >>> 0] = e.altKey;
  HEAP32[idx + 6 >>> 0] = e.metaKey;
  HEAP32[idx + 7 >>> 0] = e.repeat;
  HEAP32[idx + 8 >>> 0] = e.charCode;
  HEAP32[idx + 9 >>> 0] = e.keyCode;
  HEAP32[idx + 10 >>> 0] = e.which;
  stringToUTF8(e.key || "", keyEventData + 44, 32);
  stringToUTF8(e.code || "", keyEventData + 76, 32);
  stringToUTF8(e.char || "", keyEventData + 108, 32);
  stringToUTF8(e.locale || "", keyEventData + 140, 32);
  if (getWasmTableEntry(callbackfunc)(eventTypeId, keyEventData, userData)) e.preventDefault();
 };
 var eventHandler = {
  target: findEventTarget(target),
  allowsDeferredCalls: true,
  eventTypeString: eventTypeString,
  callbackfunc: callbackfunc,
  handlerFunc: keyEventHandlerFunc,
  useCapture: useCapture
 };
 JSEvents.registerOrRemoveHandler(eventHandler);
}

function _emscripten_set_keydown_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerKeyEventCallback(target, userData, useCapture, callbackfunc, 2, "keydown", targetThread);
 return 0;
}

function _emscripten_set_keypress_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerKeyEventCallback(target, userData, useCapture, callbackfunc, 1, "keypress", targetThread);
 return 0;
}

function _emscripten_set_keyup_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerKeyEventCallback(target, userData, useCapture, callbackfunc, 3, "keyup", targetThread);
 return 0;
}

function _emscripten_set_main_loop(func, fps, simulateInfiniteLoop) {
 var browserIterationFunc = getWasmTableEntry(func);
 setMainLoop(browserIterationFunc, fps, simulateInfiniteLoop);
}

function _emscripten_set_mousedown_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerMouseEventCallback(target, userData, useCapture, callbackfunc, 5, "mousedown", targetThread);
 return 0;
}

function _emscripten_set_mouseenter_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerMouseEventCallback(target, userData, useCapture, callbackfunc, 33, "mouseenter", targetThread);
 return 0;
}

function _emscripten_set_mouseleave_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerMouseEventCallback(target, userData, useCapture, callbackfunc, 34, "mouseleave", targetThread);
 return 0;
}

function _emscripten_set_mousemove_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerMouseEventCallback(target, userData, useCapture, callbackfunc, 8, "mousemove", targetThread);
 return 0;
}

function _emscripten_set_mouseup_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerMouseEventCallback(target, userData, useCapture, callbackfunc, 6, "mouseup", targetThread);
 return 0;
}

function fillPointerlockChangeEventData(eventStruct) {
 var pointerLockElement = document.pointerLockElement || document.mozPointerLockElement || document.webkitPointerLockElement || document.msPointerLockElement;
 var isPointerlocked = !!pointerLockElement;
 HEAP32[eventStruct >>> 2] = isPointerlocked;
 var nodeName = JSEvents.getNodeNameForTarget(pointerLockElement);
 var id = pointerLockElement && pointerLockElement.id ? pointerLockElement.id : "";
 stringToUTF8(nodeName, eventStruct + 4, 128);
 stringToUTF8(id, eventStruct + 132, 128);
}

function registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 if (!JSEvents.pointerlockChangeEvent) JSEvents.pointerlockChangeEvent = _malloc(260);
 var pointerlockChangeEventHandlerFunc = function(ev) {
  var e = ev || event;
  var pointerlockChangeEvent = JSEvents.pointerlockChangeEvent;
  fillPointerlockChangeEventData(pointerlockChangeEvent);
  if (getWasmTableEntry(callbackfunc)(eventTypeId, pointerlockChangeEvent, userData)) e.preventDefault();
 };
 var eventHandler = {
  target: target,
  eventTypeString: eventTypeString,
  callbackfunc: callbackfunc,
  handlerFunc: pointerlockChangeEventHandlerFunc,
  useCapture: useCapture
 };
 JSEvents.registerOrRemoveHandler(eventHandler);
}

function _emscripten_set_pointerlockchange_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 if (!document || !document.body || !document.body.requestPointerLock && !document.body.mozRequestPointerLock && !document.body.webkitRequestPointerLock && !document.body.msRequestPointerLock) {
  return -1;
 }
 target = findEventTarget(target);
 if (!target) return -4;
 registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, 20, "pointerlockchange", targetThread);
 registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, 20, "mozpointerlockchange", targetThread);
 registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, 20, "webkitpointerlockchange", targetThread);
 registerPointerlockChangeEventCallback(target, userData, useCapture, callbackfunc, 20, "mspointerlockchange", targetThread);
 return 0;
}

function registerUiEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 if (!JSEvents.uiEvent) JSEvents.uiEvent = _malloc(36);
 target = findEventTarget(target);
 var uiEventHandlerFunc = function(ev) {
  var e = ev || event;
  if (e.target != target) {
   return;
  }
  var b = document.body;
  if (!b) {
   return;
  }
  var uiEvent = JSEvents.uiEvent;
  HEAP32[uiEvent >>> 2] = e.detail;
  HEAP32[uiEvent + 4 >>> 2] = b.clientWidth;
  HEAP32[uiEvent + 8 >>> 2] = b.clientHeight;
  HEAP32[uiEvent + 12 >>> 2] = innerWidth;
  HEAP32[uiEvent + 16 >>> 2] = innerHeight;
  HEAP32[uiEvent + 20 >>> 2] = outerWidth;
  HEAP32[uiEvent + 24 >>> 2] = outerHeight;
  HEAP32[uiEvent + 28 >>> 2] = pageXOffset;
  HEAP32[uiEvent + 32 >>> 2] = pageYOffset;
  if (getWasmTableEntry(callbackfunc)(eventTypeId, uiEvent, userData)) e.preventDefault();
 };
 var eventHandler = {
  target: target,
  eventTypeString: eventTypeString,
  callbackfunc: callbackfunc,
  handlerFunc: uiEventHandlerFunc,
  useCapture: useCapture
 };
 JSEvents.registerOrRemoveHandler(eventHandler);
}

function _emscripten_set_resize_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerUiEventCallback(target, userData, useCapture, callbackfunc, 10, "resize", targetThread);
 return 0;
}

function registerTouchEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 if (!JSEvents.touchEvent) JSEvents.touchEvent = _malloc(1696);
 target = findEventTarget(target);
 var touchEventHandlerFunc = function(e) {
  assert(e);
  var t, touches = {}, et = e.touches;
  for (var i = 0; i < et.length; ++i) {
   t = et[i];
   t.isChanged = t.onTarget = 0;
   touches[t.identifier] = t;
  }
  for (var i = 0; i < e.changedTouches.length; ++i) {
   t = e.changedTouches[i];
   t.isChanged = 1;
   touches[t.identifier] = t;
  }
  for (var i = 0; i < e.targetTouches.length; ++i) {
   touches[e.targetTouches[i].identifier].onTarget = 1;
  }
  var touchEvent = JSEvents.touchEvent;
  HEAPF64[touchEvent >>> 3] = e.timeStamp;
  var idx = touchEvent >> 2;
  HEAP32[idx + 3 >>> 0] = e.ctrlKey;
  HEAP32[idx + 4 >>> 0] = e.shiftKey;
  HEAP32[idx + 5 >>> 0] = e.altKey;
  HEAP32[idx + 6 >>> 0] = e.metaKey;
  idx += 7;
  var targetRect = getBoundingClientRect(target);
  var numTouches = 0;
  for (var i in touches) {
   t = touches[i];
   HEAP32[idx + 0 >>> 0] = t.identifier;
   HEAP32[idx + 1 >>> 0] = t.screenX;
   HEAP32[idx + 2 >>> 0] = t.screenY;
   HEAP32[idx + 3 >>> 0] = t.clientX;
   HEAP32[idx + 4 >>> 0] = t.clientY;
   HEAP32[idx + 5 >>> 0] = t.pageX;
   HEAP32[idx + 6 >>> 0] = t.pageY;
   HEAP32[idx + 7 >>> 0] = t.isChanged;
   HEAP32[idx + 8 >>> 0] = t.onTarget;
   HEAP32[idx + 9 >>> 0] = t.clientX - targetRect.left;
   HEAP32[idx + 10 >>> 0] = t.clientY - targetRect.top;
   idx += 13;
   if (++numTouches > 31) {
    break;
   }
  }
  HEAP32[touchEvent + 8 >>> 2] = numTouches;
  if (getWasmTableEntry(callbackfunc)(eventTypeId, touchEvent, userData)) e.preventDefault();
 };
 var eventHandler = {
  target: target,
  allowsDeferredCalls: eventTypeString == "touchstart" || eventTypeString == "touchend",
  eventTypeString: eventTypeString,
  callbackfunc: callbackfunc,
  handlerFunc: touchEventHandlerFunc,
  useCapture: useCapture
 };
 JSEvents.registerOrRemoveHandler(eventHandler);
}

function _emscripten_set_touchcancel_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerTouchEventCallback(target, userData, useCapture, callbackfunc, 25, "touchcancel", targetThread);
 return 0;
}

function _emscripten_set_touchend_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerTouchEventCallback(target, userData, useCapture, callbackfunc, 23, "touchend", targetThread);
 return 0;
}

function _emscripten_set_touchmove_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerTouchEventCallback(target, userData, useCapture, callbackfunc, 24, "touchmove", targetThread);
 return 0;
}

function _emscripten_set_touchstart_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 registerTouchEventCallback(target, userData, useCapture, callbackfunc, 22, "touchstart", targetThread);
 return 0;
}

function fillVisibilityChangeEventData(eventStruct) {
 var visibilityStates = [ "hidden", "visible", "prerender", "unloaded" ];
 var visibilityState = visibilityStates.indexOf(document.visibilityState);
 HEAP32[eventStruct >>> 2] = document.hidden;
 HEAP32[eventStruct + 4 >>> 2] = visibilityState;
}

function registerVisibilityChangeEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 if (!JSEvents.visibilityChangeEvent) JSEvents.visibilityChangeEvent = _malloc(8);
 var visibilityChangeEventHandlerFunc = function(ev) {
  var e = ev || event;
  var visibilityChangeEvent = JSEvents.visibilityChangeEvent;
  fillVisibilityChangeEventData(visibilityChangeEvent);
  if (getWasmTableEntry(callbackfunc)(eventTypeId, visibilityChangeEvent, userData)) e.preventDefault();
 };
 var eventHandler = {
  target: target,
  eventTypeString: eventTypeString,
  callbackfunc: callbackfunc,
  handlerFunc: visibilityChangeEventHandlerFunc,
  useCapture: useCapture
 };
 JSEvents.registerOrRemoveHandler(eventHandler);
}

function _emscripten_set_visibilitychange_callback_on_thread(userData, useCapture, callbackfunc, targetThread) {
 if (!specialHTMLTargets[1]) {
  return -4;
 }
 registerVisibilityChangeEventCallback(specialHTMLTargets[1], userData, useCapture, callbackfunc, 21, "visibilitychange", targetThread);
 return 0;
}

function registerWheelEventCallback(target, userData, useCapture, callbackfunc, eventTypeId, eventTypeString, targetThread) {
 if (!JSEvents.wheelEvent) JSEvents.wheelEvent = _malloc(104);
 var wheelHandlerFunc = function(ev) {
  var e = ev || event;
  var wheelEvent = JSEvents.wheelEvent;
  fillMouseEventData(wheelEvent, e, target);
  HEAPF64[wheelEvent + 72 >>> 3] = e["deltaX"];
  HEAPF64[wheelEvent + 80 >>> 3] = e["deltaY"];
  HEAPF64[wheelEvent + 88 >>> 3] = e["deltaZ"];
  HEAP32[wheelEvent + 96 >>> 2] = e["deltaMode"];
  if (getWasmTableEntry(callbackfunc)(eventTypeId, wheelEvent, userData)) e.preventDefault();
 };
 var eventHandler = {
  target: target,
  allowsDeferredCalls: true,
  eventTypeString: eventTypeString,
  callbackfunc: callbackfunc,
  handlerFunc: wheelHandlerFunc,
  useCapture: useCapture
 };
 JSEvents.registerOrRemoveHandler(eventHandler);
}

function _emscripten_set_wheel_callback_on_thread(target, userData, useCapture, callbackfunc, targetThread) {
 target = findEventTarget(target);
 if (typeof target.onwheel != "undefined") {
  registerWheelEventCallback(target, userData, useCapture, callbackfunc, 9, "wheel", targetThread);
  return 0;
 } else {
  return -1;
 }
}

function _emscripten_set_window_title(title) {
 setWindowTitle(UTF8ToString(title));
}

function _emscripten_sleep() {
 throw "Please compile your program with async support in order to use asynchronous operations like emscripten_sleep";
}

var __emscripten_webgl_power_preferences = [ "default", "low-power", "high-performance" ];

function _emscripten_webgl_do_create_context(target, attributes) {
 assert(attributes);
 var a = attributes >> 2;
 var powerPreference = HEAP32[a + (24 >> 2) >>> 0];
 var contextAttributes = {
  "alpha": !!HEAP32[a + (0 >> 2) >>> 0],
  "depth": !!HEAP32[a + (4 >> 2) >>> 0],
  "stencil": !!HEAP32[a + (8 >> 2) >>> 0],
  "antialias": !!HEAP32[a + (12 >> 2) >>> 0],
  "premultipliedAlpha": !!HEAP32[a + (16 >> 2) >>> 0],
  "preserveDrawingBuffer": !!HEAP32[a + (20 >> 2) >>> 0],
  "powerPreference": __emscripten_webgl_power_preferences[powerPreference],
  "failIfMajorPerformanceCaveat": !!HEAP32[a + (28 >> 2) >>> 0],
  majorVersion: HEAP32[a + (32 >> 2) >>> 0],
  minorVersion: HEAP32[a + (36 >> 2) >>> 0],
  enableExtensionsByDefault: HEAP32[a + (40 >> 2) >>> 0],
  explicitSwapControl: HEAP32[a + (44 >> 2) >>> 0],
  proxyContextToMainThread: HEAP32[a + (48 >> 2) >>> 0],
  renderViaOffscreenBackBuffer: HEAP32[a + (52 >> 2) >>> 0]
 };
 var canvas = findCanvasEventTarget(target);
 if (!canvas) {
  return 0;
 }
 if (contextAttributes.explicitSwapControl) {
  return 0;
 }
 var contextHandle = GL.createContext(canvas, contextAttributes);
 return contextHandle;
}

var _emscripten_webgl_create_context = _emscripten_webgl_do_create_context;

function _emscripten_webgl_enable_extension(contextHandle, extension) {
 var context = GL.getContext(contextHandle);
 var extString = UTF8ToString(extension);
 if (extString.startsWith("GL_")) extString = extString.substr(3);
 if (extString == "WEBGL_draw_instanced_base_vertex_base_instance") __webgl_enable_WEBGL_draw_instanced_base_vertex_base_instance(GLctx);
 if (extString == "WEBGL_multi_draw_instanced_base_vertex_base_instance") __webgl_enable_WEBGL_multi_draw_instanced_base_vertex_base_instance(GLctx);
 if (extString == "WEBGL_multi_draw") __webgl_enable_WEBGL_multi_draw(GLctx);
 var ext = context.GLctx.getExtension(extString);
 return !!ext;
}

function _emscripten_webgl_init_context_attributes(attributes) {
 assert(attributes);
 var a = attributes >> 2;
 for (var i = 0; i < 56 >> 2; ++i) {
  HEAP32[a + i >>> 0] = 0;
 }
 HEAP32[a + (0 >> 2) >>> 0] = HEAP32[a + (4 >> 2) >>> 0] = HEAP32[a + (12 >> 2) >>> 0] = HEAP32[a + (16 >> 2) >>> 0] = HEAP32[a + (32 >> 2) >>> 0] = HEAP32[a + (40 >> 2) >>> 0] = 1;
}

function _emscripten_webgl_make_context_current(contextHandle) {
 var success = GL.makeContextCurrent(contextHandle);
 return success ? 0 : -5;
}

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) {
   if (ENV[x] === undefined) delete env[x]; else env[x] = ENV[x];
  }
  var strings = [];
  for (var x in env) {
   strings.push(x + "=" + env[x]);
  }
  getEnvStrings.strings = strings;
 }
 return getEnvStrings.strings;
}

function writeAsciiToMemory(str, buffer, dontAddNull) {
 for (var i = 0; i < str.length; ++i) {
  assert(str.charCodeAt(i) === (str.charCodeAt(i) & 255));
  HEAP8[buffer++ >>> 0] = str.charCodeAt(i);
 }
 if (!dontAddNull) HEAP8[buffer >>> 0] = 0;
}

function _environ_get(__environ, environ_buf) {
 var bufSize = 0;
 getEnvStrings().forEach(function(string, i) {
  var ptr = environ_buf + bufSize;
  HEAPU32[__environ + i * 4 >>> 2] = ptr;
  writeAsciiToMemory(string, ptr);
  bufSize += string.length + 1;
 });
 return 0;
}

function _environ_sizes_get(penviron_count, penviron_buf_size) {
 var strings = getEnvStrings();
 HEAPU32[penviron_count >>> 2] = strings.length;
 var bufSize = 0;
 strings.forEach(function(string) {
  bufSize += string.length + 1;
 });
 HEAPU32[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)) throw e;
  return e.errno;
 }
}

function doReadv(stream, iov, iovcnt, offset) {
 var ret = 0;
 for (var i = 0; i < iovcnt; i++) {
  var ptr = HEAPU32[iov >>> 2];
  var len = HEAPU32[iov + 4 >>> 2];
  iov += 8;
  var curr = FS.read(stream, HEAP8, ptr, len, offset);
  if (curr < 0) return -1;
  ret += curr;
  if (curr < len) break;
 }
 return ret;
}

function _fd_read(fd, iov, iovcnt, pnum) {
 try {
  var stream = SYSCALLS.getStreamFromFD(fd);
  var num = doReadv(stream, iov, iovcnt);
  HEAPU32[pnum >>> 2] = num;
  return 0;
 } catch (e) {
  if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e;
  return e.errno;
 }
}

function convertI32PairToI53Checked(lo, hi) {
 assert(lo == lo >>> 0 || lo == (lo | 0));
 assert(hi === (hi | 0));
 return hi + 2097152 >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN;
}

function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
 try {
  var offset = convertI32PairToI53Checked(offset_low, offset_high);
  if (isNaN(offset)) return 61;
  var stream = SYSCALLS.getStreamFromFD(fd);
  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)) throw e;
  return e.errno;
 }
}

function doWritev(stream, iov, iovcnt, offset) {
 var ret = 0;
 for (var i = 0; i < iovcnt; i++) {
  var ptr = HEAPU32[iov >>> 2];
  var len = HEAPU32[iov + 4 >>> 2];
  iov += 8;
  var curr = FS.write(stream, HEAP8, ptr, len, offset);
  if (curr < 0) return -1;
  ret += curr;
 }
 return ret;
}

function _fd_write(fd, iov, iovcnt, pnum) {
 try {
  var stream = SYSCALLS.getStreamFromFD(fd);
  var num = doWritev(stream, iov, iovcnt);
  HEAPU32[pnum >>> 2] = num;
  return 0;
 } catch (e) {
  if (typeof FS == "undefined" || !(e instanceof FS.ErrnoError)) throw e;
  return e.errno;
 }
}

function _glAttachShader(program, shader) {
 GLctx.attachShader(GL.programs[program], GL.shaders[shader]);
}

function _glBindAttribLocation(program, index, name) {
 GLctx.bindAttribLocation(GL.programs[program], index, UTF8ToString(name));
}

function _glBindBuffer(target, buffer) {
 if (target == 34962) {
  GLctx.currentArrayBufferBinding = buffer;
 } else if (target == 34963) {
  GLctx.currentElementArrayBufferBinding = buffer;
 }
 if (target == 35051) {
  GLctx.currentPixelPackBufferBinding = buffer;
 } else if (target == 35052) {
  GLctx.currentPixelUnpackBufferBinding = buffer;
 }
 GLctx.bindBuffer(target, GL.buffers[buffer]);
}

function _glBindVertexArray(vao) {
 GLctx["bindVertexArray"](GL.vaos[vao]);
 var ibo = GLctx.getParameter(34965);
 GLctx.currentElementArrayBufferBinding = ibo ? ibo.name | 0 : 0;
}

function _glBlendFunc(x0, x1) {
 GLctx["blendFunc"](x0, x1);
}

function _glBlendFuncSeparate(x0, x1, x2, x3) {
 GLctx["blendFuncSeparate"](x0, x1, x2, x3);
}

function _glBufferData(target, size, data, usage) {
 if (true) {
  if (data && size) {
   GLctx.bufferData(target, HEAPU8, usage, data, size);
  } else {
   GLctx.bufferData(target, size, usage);
  }
 } else {
  GLctx.bufferData(target, data ? HEAPU8.subarray(data >>> 0, data + size >>> 0) : size, usage);
 }
}

function _glClear(x0) {
 GLctx["clear"](x0);
}

function _glClearColor(x0, x1, x2, x3) {
 GLctx["clearColor"](x0, x1, x2, x3);
}

function _glCompileShader(shader) {
 GLctx.compileShader(GL.shaders[shader]);
}

function _glCreateProgram() {
 var id = GL.getNewId(GL.programs);
 var program = GLctx.createProgram();
 program.name = id;
 program.maxUniformLength = program.maxAttributeLength = program.maxUniformBlockNameLength = 0;
 program.uniformIdCounter = 1;
 GL.programs[id] = program;
 return id;
}

function _glCreateShader(shaderType) {
 var id = GL.getNewId(GL.shaders);
 GL.shaders[id] = GLctx.createShader(shaderType);
 return id;
}

function _glDeleteProgram(id) {
 if (!id) return;
 var program = GL.programs[id];
 if (!program) {
  GL.recordError(1281);
  return;
 }
 GLctx.deleteProgram(program);
 program.name = 0;
 GL.programs[id] = null;
}

function _glDeleteShader(id) {
 if (!id) return;
 var shader = GL.shaders[id];
 if (!shader) {
  GL.recordError(1281);
  return;
 }
 GLctx.deleteShader(shader);
 GL.shaders[id] = null;
}

function _glDepthFunc(x0) {
 GLctx["depthFunc"](x0);
}

function _glDisable(x0) {
 GLctx["disable"](x0);
}

function _glEnable(x0) {
 GLctx["enable"](x0);
}

function _glEnableVertexAttribArray(index) {
 var cb = GL.currentContext.clientBuffers[index];
 cb.enabled = true;
 GLctx.enableVertexAttribArray(index);
}

function _glFinish() {
 GLctx["finish"]();
}

function _glFlush() {
 GLctx["flush"]();
}

function _glFrontFace(x0) {
 GLctx["frontFace"](x0);
}

function _glGenBuffers(n, buffers) {
 __glGenObject(n, buffers, "createBuffer", GL.buffers);
}

function _glGenVertexArrays(n, arrays) {
 __glGenObject(n, arrays, "createVertexArray", GL.vaos);
}

function _glGetAttribLocation(program, name) {
 return GLctx.getAttribLocation(GL.programs[program], UTF8ToString(name));
}

function _glGetUniformLocation(program, name) {
 name = UTF8ToString(name);
 if (program = GL.programs[program]) {
  webglPrepareUniformLocationsBeforeFirstUse(program);
  var uniformLocsById = program.uniformLocsById;
  var arrayIndex = 0;
  var uniformBaseName = name;
  var leftBrace = webglGetLeftBracePos(name);
  if (leftBrace > 0) {
   arrayIndex = jstoi_q(name.slice(leftBrace + 1)) >>> 0;
   uniformBaseName = name.slice(0, leftBrace);
  }
  var sizeAndId = program.uniformSizeAndIdsByName[uniformBaseName];
  if (sizeAndId && arrayIndex < sizeAndId[0]) {
   arrayIndex += sizeAndId[1];
   if (uniformLocsById[arrayIndex] = uniformLocsById[arrayIndex] || GLctx.getUniformLocation(program, name)) {
    return arrayIndex;
   }
  }
 } else {
  GL.recordError(1281);
 }
 return -1;
}

function _glHint(x0, x1) {
 GLctx["hint"](x0, x1);
}

function _glLinkProgram(program) {
 program = GL.programs[program];
 GLctx.linkProgram(program);
 program.uniformLocsById = 0;
 program.uniformSizeAndIdsByName = {};
}

function _glReleaseShaderCompiler() {}

function _glShaderSource(shader, count, string, length) {
 var source = GL.getSource(shader, count, string, length);
 GLctx.shaderSource(GL.shaders[shader], source);
}

function _glUniform1f(location, v0) {
 GLctx.uniform1f(webglGetUniformLocation(location), v0);
}

function _glUniform1i(location, v0) {
 GLctx.uniform1i(webglGetUniformLocation(location), v0);
}

function _glUniform3f(location, v0, v1, v2) {
 GLctx.uniform3f(webglGetUniformLocation(location), v0, v1, v2);
}

function _glUniform4f(location, v0, v1, v2, v3) {
 GLctx.uniform4f(webglGetUniformLocation(location), v0, v1, v2, v3);
}

function _glUseProgram(program) {
 program = GL.programs[program];
 GLctx.useProgram(program);
 GLctx.currentProgram = program;
}

function _glVertexAttribPointer(index, size, type, normalized, stride, ptr) {
 var cb = GL.currentContext.clientBuffers[index];
 if (!GLctx.currentArrayBufferBinding) {
  cb.size = size;
  cb.type = type;
  cb.normalized = normalized;
  cb.stride = stride;
  cb.ptr = ptr;
  cb.clientside = true;
  cb.vertexAttribPointerAdaptor = function(index, size, type, normalized, stride, ptr) {
   this.vertexAttribPointer(index, size, type, normalized, stride, ptr);
  };
  return;
 }
 cb.clientside = false;
 GLctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
}

function getCFunc(ident) {
 var func = Module["_" + ident];
 assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
 return func;
}

function writeArrayToMemory(array, buffer) {
 assert(array.length >= 0, "writeArrayToMemory array must have a length (should be an array or typed array)");
 HEAP8.set(array, buffer >>> 0);
}

function ccall(ident, returnType, argTypes, args, opts) {
 var toC = {
  "string": str => {
   var ret = 0;
   if (str !== null && str !== undefined && str !== 0) {
    var len = (str.length << 2) + 1;
    ret = stackAlloc(len);
    stringToUTF8(str, ret, len);
   }
   return ret;
  },
  "array": arr => {
   var ret = stackAlloc(arr.length);
   writeArrayToMemory(arr, ret);
   return ret;
  }
 };
 function convertReturnValue(ret) {
  if (returnType === "string") {
   return UTF8ToString(ret);
  }
  if (returnType === "boolean") return Boolean(ret);
  return ret;
 }
 var func = getCFunc(ident);
 var cArgs = [];
 var stack = 0;
 assert(returnType !== "array", 'Return type should not be "array".');
 if (args) {
  for (var i = 0; i < args.length; i++) {
   var converter = toC[argTypes[i]];
   if (converter) {
    if (stack === 0) stack = stackSave();
    cArgs[i] = converter(args[i]);
   } else {
    cArgs[i] = args[i];
   }
  }
 }
 var ret = func.apply(null, cArgs);
 function onDone(ret) {
  if (stack !== 0) stackRestore(stack);
  return convertReturnValue(ret);
 }
 ret = onDone(ret);
 return ret;
}

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

Module["FS_createPath"] = FS.createPath;

Module["FS_createDataFile"] = FS.createDataFile;

Module["FS_createPreloadedFile"] = FS.createPreloadedFile;

Module["FS_unlink"] = FS.unlink;

Module["FS_createLazyFile"] = FS.createLazyFile;

Module["FS_createDevice"] = FS.createDevice;

ERRNO_CODES = {
 "EPERM": 63,
 "ENOENT": 44,
 "ESRCH": 71,
 "EINTR": 27,
 "EIO": 29,
 "ENXIO": 60,
 "E2BIG": 1,
 "ENOEXEC": 45,
 "EBADF": 8,
 "ECHILD": 12,
 "EAGAIN": 6,
 "EWOULDBLOCK": 6,
 "ENOMEM": 48,
 "EACCES": 2,
 "EFAULT": 21,
 "ENOTBLK": 105,
 "EBUSY": 10,
 "EEXIST": 20,
 "EXDEV": 75,
 "ENODEV": 43,
 "ENOTDIR": 54,
 "EISDIR": 31,
 "EINVAL": 28,
 "ENFILE": 41,
 "EMFILE": 33,
 "ENOTTY": 59,
 "ETXTBSY": 74,
 "EFBIG": 22,
 "ENOSPC": 51,
 "ESPIPE": 70,
 "EROFS": 69,
 "EMLINK": 34,
 "EPIPE": 64,
 "EDOM": 18,
 "ERANGE": 68,
 "ENOMSG": 49,
 "EIDRM": 24,
 "ECHRNG": 106,
 "EL2NSYNC": 156,
 "EL3HLT": 107,
 "EL3RST": 108,
 "ELNRNG": 109,
 "EUNATCH": 110,
 "ENOCSI": 111,
 "EL2HLT": 112,
 "EDEADLK": 16,
 "ENOLCK": 46,
 "EBADE": 113,
 "EBADR": 114,
 "EXFULL": 115,
 "ENOANO": 104,
 "EBADRQC": 103,
 "EBADSLT": 102,
 "EDEADLOCK": 16,
 "EBFONT": 101,
 "ENOSTR": 100,
 "ENODATA": 116,
 "ETIME": 117,
 "ENOSR": 118,
 "ENONET": 119,
 "ENOPKG": 120,
 "EREMOTE": 121,
 "ENOLINK": 47,
 "EADV": 122,
 "ESRMNT": 123,
 "ECOMM": 124,
 "EPROTO": 65,
 "EMULTIHOP": 36,
 "EDOTDOT": 125,
 "EBADMSG": 9,
 "ENOTUNIQ": 126,
 "EBADFD": 127,
 "EREMCHG": 128,
 "ELIBACC": 129,
 "ELIBBAD": 130,
 "ELIBSCN": 131,
 "ELIBMAX": 132,
 "ELIBEXEC": 133,
 "ENOSYS": 52,
 "ENOTEMPTY": 55,
 "ENAMETOOLONG": 37,
 "ELOOP": 32,
 "EOPNOTSUPP": 138,
 "EPFNOSUPPORT": 139,
 "ECONNRESET": 15,
 "ENOBUFS": 42,
 "EAFNOSUPPORT": 5,
 "EPROTOTYPE": 67,
 "ENOTSOCK": 57,
 "ENOPROTOOPT": 50,
 "ESHUTDOWN": 140,
 "ECONNREFUSED": 14,
 "EADDRINUSE": 3,
 "ECONNABORTED": 13,
 "ENETUNREACH": 40,
 "ENETDOWN": 38,
 "ETIMEDOUT": 73,
 "EHOSTDOWN": 142,
 "EHOSTUNREACH": 23,
 "EINPROGRESS": 26,
 "EALREADY": 7,
 "EDESTADDRREQ": 17,
 "EMSGSIZE": 35,
 "EPROTONOSUPPORT": 66,
 "ESOCKTNOSUPPORT": 137,
 "EADDRNOTAVAIL": 4,
 "ENETRESET": 39,
 "EISCONN": 30,
 "ENOTCONN": 53,
 "ETOOMANYREFS": 141,
 "EUSERS": 136,
 "EDQUOT": 19,
 "ESTALE": 72,
 "ENOTSUP": 138,
 "ENOMEDIUM": 148,
 "EILSEQ": 25,
 "EOVERFLOW": 61,
 "ECANCELED": 11,
 "ENOTRECOVERABLE": 56,
 "EOWNERDEAD": 62,
 "ESTRPIPE": 135
};

Module["requestFullscreen"] = function Module_requestFullscreen(lockPointer, resizeCanvas) {
 Browser.requestFullscreen(lockPointer, resizeCanvas);
};

Module["requestFullScreen"] = function Module_requestFullScreen() {
 Browser.requestFullScreen();
};

Module["requestAnimationFrame"] = function Module_requestAnimationFrame(func) {
 Browser.requestAnimationFrame(func);
};

Module["setCanvasSize"] = function Module_setCanvasSize(width, height, noUpdates) {
 Browser.setCanvasSize(width, height, noUpdates);
};

Module["pauseMainLoop"] = function Module_pauseMainLoop() {
 Browser.mainLoop.pause();
};

Module["resumeMainLoop"] = function Module_resumeMainLoop() {
 Browser.mainLoop.resume();
};

Module["getUserMedia"] = function Module_getUserMedia() {
 Browser.getUserMedia();
};

Module["createContext"] = function Module_createContext(canvas, useWebGL, setInModule, webGLContextAttributes) {
 return Browser.createContext(canvas, useWebGL, setInModule, webGLContextAttributes);
};

var preloadedImages = {};

var preloadedAudios = {};

var GLctx;

for (var i = 0; i < 32; ++i) tempFixedLengthArray.push(new Array(i));

var ASSERTIONS = true;

var decodeBase64 = typeof atob == "function" ? atob : function(input) {
 var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 var output = "";
 var chr1, chr2, chr3;
 var enc1, enc2, enc3, enc4;
 var i = 0;
 input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
 do {
  enc1 = keyStr.indexOf(input.charAt(i++));
  enc2 = keyStr.indexOf(input.charAt(i++));
  enc3 = keyStr.indexOf(input.charAt(i++));
  enc4 = keyStr.indexOf(input.charAt(i++));
  chr1 = enc1 << 2 | enc2 >> 4;
  chr2 = (enc2 & 15) << 4 | enc3 >> 2;
  chr3 = (enc3 & 3) << 6 | enc4;
  output = output + String.fromCharCode(chr1);
  if (enc3 !== 64) {
   output = output + String.fromCharCode(chr2);
  }
  if (enc4 !== 64) {
   output = output + String.fromCharCode(chr3);
  }
 } while (i < input.length);
 return output;
};

function intArrayFromBase64(s) {
 if (typeof ENVIRONMENT_IS_NODE == "boolean" && ENVIRONMENT_IS_NODE) {
  var buf = Buffer.from(s, "base64");
  return new Uint8Array(buf["buffer"], buf["byteOffset"], buf["byteLength"]);
 }
 try {
  var decoded = decodeBase64(s);
  var bytes = new Uint8Array(decoded.length);
  for (var i = 0; i < decoded.length; ++i) {
   bytes[i] = decoded.charCodeAt(i);
  }
  return bytes;
 } catch (_) {
  throw new Error("Converting base64 string to bytes failed.");
 }
}

function tryParseAsDataURI(filename) {
 if (!isDataURI(filename)) {
  return;
 }
 return intArrayFromBase64(filename.slice(dataURIPrefix.length));
}

function checkIncomingModuleAPI() {
 ignoredModuleProp("fetchSettings");
}

var asmLibraryArg = {
 "__syscall_fcntl64": ___syscall_fcntl64,
 "__syscall_ioctl": ___syscall_ioctl,
 "__syscall_openat": ___syscall_openat,
 "_emscripten_get_now_is_monotonic": __emscripten_get_now_is_monotonic,
 "abort": _abort,
 "eglBindAPI": _eglBindAPI,
 "eglChooseConfig": _eglChooseConfig,
 "eglCreateContext": _eglCreateContext,
 "eglCreateWindowSurface": _eglCreateWindowSurface,
 "eglDestroyContext": _eglDestroyContext,
 "eglDestroySurface": _eglDestroySurface,
 "eglGetConfigAttrib": _eglGetConfigAttrib,
 "eglGetDisplay": _eglGetDisplay,
 "eglGetError": _eglGetError,
 "eglInitialize": _eglInitialize,
 "eglMakeCurrent": _eglMakeCurrent,
 "eglQueryString": _eglQueryString,
 "eglSwapBuffers": _eglSwapBuffers,
 "eglSwapInterval": _eglSwapInterval,
 "eglTerminate": _eglTerminate,
 "eglWaitGL": _eglWaitGL,
 "eglWaitNative": _eglWaitNative,
 "emscripten_asm_const_int": _emscripten_asm_const_int,
 "emscripten_asm_const_int_sync_on_main_thread": _emscripten_asm_const_int_sync_on_main_thread,
 "emscripten_cancel_main_loop": _emscripten_cancel_main_loop,
 "emscripten_date_now": _emscripten_date_now,
 "emscripten_exit_fullscreen": _emscripten_exit_fullscreen,
 "emscripten_exit_pointerlock": _emscripten_exit_pointerlock,
 "emscripten_get_device_pixel_ratio": _emscripten_get_device_pixel_ratio,
 "emscripten_get_element_css_size": _emscripten_get_element_css_size,
 "emscripten_get_gamepad_status": _emscripten_get_gamepad_status,
 "emscripten_get_now": _emscripten_get_now,
 "emscripten_get_num_gamepads": _emscripten_get_num_gamepads,
 "emscripten_get_screen_size": _emscripten_get_screen_size,
 "emscripten_glActiveTexture": _emscripten_glActiveTexture,
 "emscripten_glAttachShader": _emscripten_glAttachShader,
 "emscripten_glBeginQuery": _emscripten_glBeginQuery,
 "emscripten_glBeginQueryEXT": _emscripten_glBeginQueryEXT,
 "emscripten_glBeginTransformFeedback": _emscripten_glBeginTransformFeedback,
 "emscripten_glBindAttribLocation": _emscripten_glBindAttribLocation,
 "emscripten_glBindBuffer": _emscripten_glBindBuffer,
 "emscripten_glBindBufferBase": _emscripten_glBindBufferBase,
 "emscripten_glBindBufferRange": _emscripten_glBindBufferRange,
 "emscripten_glBindFramebuffer": _emscripten_glBindFramebuffer,
 "emscripten_glBindRenderbuffer": _emscripten_glBindRenderbuffer,
 "emscripten_glBindSampler": _emscripten_glBindSampler,
 "emscripten_glBindTexture": _emscripten_glBindTexture,
 "emscripten_glBindTransformFeedback": _emscripten_glBindTransformFeedback,
 "emscripten_glBindVertexArray": _emscripten_glBindVertexArray,
 "emscripten_glBindVertexArrayOES": _emscripten_glBindVertexArrayOES,
 "emscripten_glBlendColor": _emscripten_glBlendColor,
 "emscripten_glBlendEquation": _emscripten_glBlendEquation,
 "emscripten_glBlendEquationSeparate": _emscripten_glBlendEquationSeparate,
 "emscripten_glBlendFunc": _emscripten_glBlendFunc,
 "emscripten_glBlendFuncSeparate": _emscripten_glBlendFuncSeparate,
 "emscripten_glBlitFramebuffer": _emscripten_glBlitFramebuffer,
 "emscripten_glBufferData": _emscripten_glBufferData,
 "emscripten_glBufferSubData": _emscripten_glBufferSubData,
 "emscripten_glCheckFramebufferStatus": _emscripten_glCheckFramebufferStatus,
 "emscripten_glClear": _emscripten_glClear,
 "emscripten_glClearBufferfi": _emscripten_glClearBufferfi,
 "emscripten_glClearBufferfv": _emscripten_glClearBufferfv,
 "emscripten_glClearBufferiv": _emscripten_glClearBufferiv,
 "emscripten_glClearBufferuiv": _emscripten_glClearBufferuiv,
 "emscripten_glClearColor": _emscripten_glClearColor,
 "emscripten_glClearDepthf": _emscripten_glClearDepthf,
 "emscripten_glClearStencil": _emscripten_glClearStencil,
 "emscripten_glClientWaitSync": _emscripten_glClientWaitSync,
 "emscripten_glColorMask": _emscripten_glColorMask,
 "emscripten_glCompileShader": _emscripten_glCompileShader,
 "emscripten_glCompressedTexImage2D": _emscripten_glCompressedTexImage2D,
 "emscripten_glCompressedTexImage3D": _emscripten_glCompressedTexImage3D,
 "emscripten_glCompressedTexSubImage2D": _emscripten_glCompressedTexSubImage2D,
 "emscripten_glCompressedTexSubImage3D": _emscripten_glCompressedTexSubImage3D,
 "emscripten_glCopyBufferSubData": _emscripten_glCopyBufferSubData,
 "emscripten_glCopyTexImage2D": _emscripten_glCopyTexImage2D,
 "emscripten_glCopyTexSubImage2D": _emscripten_glCopyTexSubImage2D,
 "emscripten_glCopyTexSubImage3D": _emscripten_glCopyTexSubImage3D,
 "emscripten_glCreateProgram": _emscripten_glCreateProgram,
 "emscripten_glCreateShader": _emscripten_glCreateShader,
 "emscripten_glCullFace": _emscripten_glCullFace,
 "emscripten_glDeleteBuffers": _emscripten_glDeleteBuffers,
 "emscripten_glDeleteFramebuffers": _emscripten_glDeleteFramebuffers,
 "emscripten_glDeleteProgram": _emscripten_glDeleteProgram,
 "emscripten_glDeleteQueries": _emscripten_glDeleteQueries,
 "emscripten_glDeleteQueriesEXT": _emscripten_glDeleteQueriesEXT,
 "emscripten_glDeleteRenderbuffers": _emscripten_glDeleteRenderbuffers,
 "emscripten_glDeleteSamplers": _emscripten_glDeleteSamplers,
 "emscripten_glDeleteShader": _emscripten_glDeleteShader,
 "emscripten_glDeleteSync": _emscripten_glDeleteSync,
 "emscripten_glDeleteTextures": _emscripten_glDeleteTextures,
 "emscripten_glDeleteTransformFeedbacks": _emscripten_glDeleteTransformFeedbacks,
 "emscripten_glDeleteVertexArrays": _emscripten_glDeleteVertexArrays,
 "emscripten_glDeleteVertexArraysOES": _emscripten_glDeleteVertexArraysOES,
 "emscripten_glDepthFunc": _emscripten_glDepthFunc,
 "emscripten_glDepthMask": _emscripten_glDepthMask,
 "emscripten_glDepthRangef": _emscripten_glDepthRangef,
 "emscripten_glDetachShader": _emscripten_glDetachShader,
 "emscripten_glDisable": _emscripten_glDisable,
 "emscripten_glDisableVertexAttribArray": _emscripten_glDisableVertexAttribArray,
 "emscripten_glDrawArrays": _emscripten_glDrawArrays,
 "emscripten_glDrawArraysInstanced": _emscripten_glDrawArraysInstanced,
 "emscripten_glDrawArraysInstancedANGLE": _emscripten_glDrawArraysInstancedANGLE,
 "emscripten_glDrawArraysInstancedARB": _emscripten_glDrawArraysInstancedARB,
 "emscripten_glDrawArraysInstancedEXT": _emscripten_glDrawArraysInstancedEXT,
 "emscripten_glDrawArraysInstancedNV": _emscripten_glDrawArraysInstancedNV,
 "emscripten_glDrawBuffers": _emscripten_glDrawBuffers,
 "emscripten_glDrawBuffersEXT": _emscripten_glDrawBuffersEXT,
 "emscripten_glDrawBuffersWEBGL": _emscripten_glDrawBuffersWEBGL,
 "emscripten_glDrawElements": _emscripten_glDrawElements,
 "emscripten_glDrawElementsInstanced": _emscripten_glDrawElementsInstanced,
 "emscripten_glDrawElementsInstancedANGLE": _emscripten_glDrawElementsInstancedANGLE,
 "emscripten_glDrawElementsInstancedARB": _emscripten_glDrawElementsInstancedARB,
 "emscripten_glDrawElementsInstancedEXT": _emscripten_glDrawElementsInstancedEXT,
 "emscripten_glDrawElementsInstancedNV": _emscripten_glDrawElementsInstancedNV,
 "emscripten_glDrawRangeElements": _emscripten_glDrawRangeElements,
 "emscripten_glEnable": _emscripten_glEnable,
 "emscripten_glEnableVertexAttribArray": _emscripten_glEnableVertexAttribArray,
 "emscripten_glEndQuery": _emscripten_glEndQuery,
 "emscripten_glEndQueryEXT": _emscripten_glEndQueryEXT,
 "emscripten_glEndTransformFeedback": _emscripten_glEndTransformFeedback,
 "emscripten_glFenceSync": _emscripten_glFenceSync,
 "emscripten_glFinish": _emscripten_glFinish,
 "emscripten_glFlush": _emscripten_glFlush,
 "emscripten_glFlushMappedBufferRange": _emscripten_glFlushMappedBufferRange,
 "emscripten_glFramebufferRenderbuffer": _emscripten_glFramebufferRenderbuffer,
 "emscripten_glFramebufferTexture2D": _emscripten_glFramebufferTexture2D,
 "emscripten_glFramebufferTextureLayer": _emscripten_glFramebufferTextureLayer,
 "emscripten_glFrontFace": _emscripten_glFrontFace,
 "emscripten_glGenBuffers": _emscripten_glGenBuffers,
 "emscripten_glGenFramebuffers": _emscripten_glGenFramebuffers,
 "emscripten_glGenQueries": _emscripten_glGenQueries,
 "emscripten_glGenQueriesEXT": _emscripten_glGenQueriesEXT,
 "emscripten_glGenRenderbuffers": _emscripten_glGenRenderbuffers,
 "emscripten_glGenSamplers": _emscripten_glGenSamplers,
 "emscripten_glGenTextures": _emscripten_glGenTextures,
 "emscripten_glGenTransformFeedbacks": _emscripten_glGenTransformFeedbacks,
 "emscripten_glGenVertexArrays": _emscripten_glGenVertexArrays,
 "emscripten_glGenVertexArraysOES": _emscripten_glGenVertexArraysOES,
 "emscripten_glGenerateMipmap": _emscripten_glGenerateMipmap,
 "emscripten_glGetActiveAttrib": _emscripten_glGetActiveAttrib,
 "emscripten_glGetActiveUniform": _emscripten_glGetActiveUniform,
 "emscripten_glGetActiveUniformBlockName": _emscripten_glGetActiveUniformBlockName,
 "emscripten_glGetActiveUniformBlockiv": _emscripten_glGetActiveUniformBlockiv,
 "emscripten_glGetActiveUniformsiv": _emscripten_glGetActiveUniformsiv,
 "emscripten_glGetAttachedShaders": _emscripten_glGetAttachedShaders,
 "emscripten_glGetAttribLocation": _emscripten_glGetAttribLocation,
 "emscripten_glGetBooleanv": _emscripten_glGetBooleanv,
 "emscripten_glGetBufferParameteri64v": _emscripten_glGetBufferParameteri64v,
 "emscripten_glGetBufferParameteriv": _emscripten_glGetBufferParameteriv,
 "emscripten_glGetBufferPointerv": _emscripten_glGetBufferPointerv,
 "emscripten_glGetError": _emscripten_glGetError,
 "emscripten_glGetFloatv": _emscripten_glGetFloatv,
 "emscripten_glGetFragDataLocation": _emscripten_glGetFragDataLocation,
 "emscripten_glGetFramebufferAttachmentParameteriv": _emscripten_glGetFramebufferAttachmentParameteriv,
 "emscripten_glGetInteger64i_v": _emscripten_glGetInteger64i_v,
 "emscripten_glGetInteger64v": _emscripten_glGetInteger64v,
 "emscripten_glGetIntegeri_v": _emscripten_glGetIntegeri_v,
 "emscripten_glGetIntegerv": _emscripten_glGetIntegerv,
 "emscripten_glGetInternalformativ": _emscripten_glGetInternalformativ,
 "emscripten_glGetProgramBinary": _emscripten_glGetProgramBinary,
 "emscripten_glGetProgramInfoLog": _emscripten_glGetProgramInfoLog,
 "emscripten_glGetProgramiv": _emscripten_glGetProgramiv,
 "emscripten_glGetQueryObjecti64vEXT": _emscripten_glGetQueryObjecti64vEXT,
 "emscripten_glGetQueryObjectivEXT": _emscripten_glGetQueryObjectivEXT,
 "emscripten_glGetQueryObjectui64vEXT": _emscripten_glGetQueryObjectui64vEXT,
 "emscripten_glGetQueryObjectuiv": _emscripten_glGetQueryObjectuiv,
 "emscripten_glGetQueryObjectuivEXT": _emscripten_glGetQueryObjectuivEXT,
 "emscripten_glGetQueryiv": _emscripten_glGetQueryiv,
 "emscripten_glGetQueryivEXT": _emscripten_glGetQueryivEXT,
 "emscripten_glGetRenderbufferParameteriv": _emscripten_glGetRenderbufferParameteriv,
 "emscripten_glGetSamplerParameterfv": _emscripten_glGetSamplerParameterfv,
 "emscripten_glGetSamplerParameteriv": _emscripten_glGetSamplerParameteriv,
 "emscripten_glGetShaderInfoLog": _emscripten_glGetShaderInfoLog,
 "emscripten_glGetShaderPrecisionFormat": _emscripten_glGetShaderPrecisionFormat,
 "emscripten_glGetShaderSource": _emscripten_glGetShaderSource,
 "emscripten_glGetShaderiv": _emscripten_glGetShaderiv,
 "emscripten_glGetString": _emscripten_glGetString,
 "emscripten_glGetStringi": _emscripten_glGetStringi,
 "emscripten_glGetSynciv": _emscripten_glGetSynciv,
 "emscripten_glGetTexParameterfv": _emscripten_glGetTexParameterfv,
 "emscripten_glGetTexParameteriv": _emscripten_glGetTexParameteriv,
 "emscripten_glGetTransformFeedbackVarying": _emscripten_glGetTransformFeedbackVarying,
 "emscripten_glGetUniformBlockIndex": _emscripten_glGetUniformBlockIndex,
 "emscripten_glGetUniformIndices": _emscripten_glGetUniformIndices,
 "emscripten_glGetUniformLocation": _emscripten_glGetUniformLocation,
 "emscripten_glGetUniformfv": _emscripten_glGetUniformfv,
 "emscripten_glGetUniformiv": _emscripten_glGetUniformiv,
 "emscripten_glGetUniformuiv": _emscripten_glGetUniformuiv,
 "emscripten_glGetVertexAttribIiv": _emscripten_glGetVertexAttribIiv,
 "emscripten_glGetVertexAttribIuiv": _emscripten_glGetVertexAttribIuiv,
 "emscripten_glGetVertexAttribPointerv": _emscripten_glGetVertexAttribPointerv,
 "emscripten_glGetVertexAttribfv": _emscripten_glGetVertexAttribfv,
 "emscripten_glGetVertexAttribiv": _emscripten_glGetVertexAttribiv,
 "emscripten_glHint": _emscripten_glHint,
 "emscripten_glInvalidateFramebuffer": _emscripten_glInvalidateFramebuffer,
 "emscripten_glInvalidateSubFramebuffer": _emscripten_glInvalidateSubFramebuffer,
 "emscripten_glIsBuffer": _emscripten_glIsBuffer,
 "emscripten_glIsEnabled": _emscripten_glIsEnabled,
 "emscripten_glIsFramebuffer": _emscripten_glIsFramebuffer,
 "emscripten_glIsProgram": _emscripten_glIsProgram,
 "emscripten_glIsQuery": _emscripten_glIsQuery,
 "emscripten_glIsQueryEXT": _emscripten_glIsQueryEXT,
 "emscripten_glIsRenderbuffer": _emscripten_glIsRenderbuffer,
 "emscripten_glIsSampler": _emscripten_glIsSampler,
 "emscripten_glIsShader": _emscripten_glIsShader,
 "emscripten_glIsSync": _emscripten_glIsSync,
 "emscripten_glIsTexture": _emscripten_glIsTexture,
 "emscripten_glIsTransformFeedback": _emscripten_glIsTransformFeedback,
 "emscripten_glIsVertexArray": _emscripten_glIsVertexArray,
 "emscripten_glIsVertexArrayOES": _emscripten_glIsVertexArrayOES,
 "emscripten_glLineWidth": _emscripten_glLineWidth,
 "emscripten_glLinkProgram": _emscripten_glLinkProgram,
 "emscripten_glMapBufferRange": _emscripten_glMapBufferRange,
 "emscripten_glPauseTransformFeedback": _emscripten_glPauseTransformFeedback,
 "emscripten_glPixelStorei": _emscripten_glPixelStorei,
 "emscripten_glPolygonOffset": _emscripten_glPolygonOffset,
 "emscripten_glProgramBinary": _emscripten_glProgramBinary,
 "emscripten_glProgramParameteri": _emscripten_glProgramParameteri,
 "emscripten_glQueryCounterEXT": _emscripten_glQueryCounterEXT,
 "emscripten_glReadBuffer": _emscripten_glReadBuffer,
 "emscripten_glReadPixels": _emscripten_glReadPixels,
 "emscripten_glReleaseShaderCompiler": _emscripten_glReleaseShaderCompiler,
 "emscripten_glRenderbufferStorage": _emscripten_glRenderbufferStorage,
 "emscripten_glRenderbufferStorageMultisample": _emscripten_glRenderbufferStorageMultisample,
 "emscripten_glResumeTransformFeedback": _emscripten_glResumeTransformFeedback,
 "emscripten_glSampleCoverage": _emscripten_glSampleCoverage,
 "emscripten_glSamplerParameterf": _emscripten_glSamplerParameterf,
 "emscripten_glSamplerParameterfv": _emscripten_glSamplerParameterfv,
 "emscripten_glSamplerParameteri": _emscripten_glSamplerParameteri,
 "emscripten_glSamplerParameteriv": _emscripten_glSamplerParameteriv,
 "emscripten_glScissor": _emscripten_glScissor,
 "emscripten_glShaderBinary": _emscripten_glShaderBinary,
 "emscripten_glShaderSource": _emscripten_glShaderSource,
 "emscripten_glStencilFunc": _emscripten_glStencilFunc,
 "emscripten_glStencilFuncSeparate": _emscripten_glStencilFuncSeparate,
 "emscripten_glStencilMask": _emscripten_glStencilMask,
 "emscripten_glStencilMaskSeparate": _emscripten_glStencilMaskSeparate,
 "emscripten_glStencilOp": _emscripten_glStencilOp,
 "emscripten_glStencilOpSeparate": _emscripten_glStencilOpSeparate,
 "emscripten_glTexImage2D": _emscripten_glTexImage2D,
 "emscripten_glTexImage3D": _emscripten_glTexImage3D,
 "emscripten_glTexParameterf": _emscripten_glTexParameterf,
 "emscripten_glTexParameterfv": _emscripten_glTexParameterfv,
 "emscripten_glTexParameteri": _emscripten_glTexParameteri,
 "emscripten_glTexParameteriv": _emscripten_glTexParameteriv,
 "emscripten_glTexStorage2D": _emscripten_glTexStorage2D,
 "emscripten_glTexStorage3D": _emscripten_glTexStorage3D,
 "emscripten_glTexSubImage2D": _emscripten_glTexSubImage2D,
 "emscripten_glTexSubImage3D": _emscripten_glTexSubImage3D,
 "emscripten_glTransformFeedbackVaryings": _emscripten_glTransformFeedbackVaryings,
 "emscripten_glUniform1f": _emscripten_glUniform1f,
 "emscripten_glUniform1fv": _emscripten_glUniform1fv,
 "emscripten_glUniform1i": _emscripten_glUniform1i,
 "emscripten_glUniform1iv": _emscripten_glUniform1iv,
 "emscripten_glUniform1ui": _emscripten_glUniform1ui,
 "emscripten_glUniform1uiv": _emscripten_glUniform1uiv,
 "emscripten_glUniform2f": _emscripten_glUniform2f,
 "emscripten_glUniform2fv": _emscripten_glUniform2fv,
 "emscripten_glUniform2i": _emscripten_glUniform2i,
 "emscripten_glUniform2iv": _emscripten_glUniform2iv,
 "emscripten_glUniform2ui": _emscripten_glUniform2ui,
 "emscripten_glUniform2uiv": _emscripten_glUniform2uiv,
 "emscripten_glUniform3f": _emscripten_glUniform3f,
 "emscripten_glUniform3fv": _emscripten_glUniform3fv,
 "emscripten_glUniform3i": _emscripten_glUniform3i,
 "emscripten_glUniform3iv": _emscripten_glUniform3iv,
 "emscripten_glUniform3ui": _emscripten_glUniform3ui,
 "emscripten_glUniform3uiv": _emscripten_glUniform3uiv,
 "emscripten_glUniform4f": _emscripten_glUniform4f,
 "emscripten_glUniform4fv": _emscripten_glUniform4fv,
 "emscripten_glUniform4i": _emscripten_glUniform4i,
 "emscripten_glUniform4iv": _emscripten_glUniform4iv,
 "emscripten_glUniform4ui": _emscripten_glUniform4ui,
 "emscripten_glUniform4uiv": _emscripten_glUniform4uiv,
 "emscripten_glUniformBlockBinding": _emscripten_glUniformBlockBinding,
 "emscripten_glUniformMatrix2fv": _emscripten_glUniformMatrix2fv,
 "emscripten_glUniformMatrix2x3fv": _emscripten_glUniformMatrix2x3fv,
 "emscripten_glUniformMatrix2x4fv": _emscripten_glUniformMatrix2x4fv,
 "emscripten_glUniformMatrix3fv": _emscripten_glUniformMatrix3fv,
 "emscripten_glUniformMatrix3x2fv": _emscripten_glUniformMatrix3x2fv,
 "emscripten_glUniformMatrix3x4fv": _emscripten_glUniformMatrix3x4fv,
 "emscripten_glUniformMatrix4fv": _emscripten_glUniformMatrix4fv,
 "emscripten_glUniformMatrix4x2fv": _emscripten_glUniformMatrix4x2fv,
 "emscripten_glUniformMatrix4x3fv": _emscripten_glUniformMatrix4x3fv,
 "emscripten_glUnmapBuffer": _emscripten_glUnmapBuffer,
 "emscripten_glUseProgram": _emscripten_glUseProgram,
 "emscripten_glValidateProgram": _emscripten_glValidateProgram,
 "emscripten_glVertexAttrib1f": _emscripten_glVertexAttrib1f,
 "emscripten_glVertexAttrib1fv": _emscripten_glVertexAttrib1fv,
 "emscripten_glVertexAttrib2f": _emscripten_glVertexAttrib2f,
 "emscripten_glVertexAttrib2fv": _emscripten_glVertexAttrib2fv,
 "emscripten_glVertexAttrib3f": _emscripten_glVertexAttrib3f,
 "emscripten_glVertexAttrib3fv": _emscripten_glVertexAttrib3fv,
 "emscripten_glVertexAttrib4f": _emscripten_glVertexAttrib4f,
 "emscripten_glVertexAttrib4fv": _emscripten_glVertexAttrib4fv,
 "emscripten_glVertexAttribDivisor": _emscripten_glVertexAttribDivisor,
 "emscripten_glVertexAttribDivisorANGLE": _emscripten_glVertexAttribDivisorANGLE,
 "emscripten_glVertexAttribDivisorARB": _emscripten_glVertexAttribDivisorARB,
 "emscripten_glVertexAttribDivisorEXT": _emscripten_glVertexAttribDivisorEXT,
 "emscripten_glVertexAttribDivisorNV": _emscripten_glVertexAttribDivisorNV,
 "emscripten_glVertexAttribI4i": _emscripten_glVertexAttribI4i,
 "emscripten_glVertexAttribI4iv": _emscripten_glVertexAttribI4iv,
 "emscripten_glVertexAttribI4ui": _emscripten_glVertexAttribI4ui,
 "emscripten_glVertexAttribI4uiv": _emscripten_glVertexAttribI4uiv,
 "emscripten_glVertexAttribIPointer": _emscripten_glVertexAttribIPointer,
 "emscripten_glVertexAttribPointer": _emscripten_glVertexAttribPointer,
 "emscripten_glViewport": _emscripten_glViewport,
 "emscripten_glWaitSync": _emscripten_glWaitSync,
 "emscripten_has_asyncify": _emscripten_has_asyncify,
 "emscripten_memcpy_big": _emscripten_memcpy_big,
 "emscripten_request_fullscreen_strategy": _emscripten_request_fullscreen_strategy,
 "emscripten_request_pointerlock": _emscripten_request_pointerlock,
 "emscripten_resize_heap": _emscripten_resize_heap,
 "emscripten_sample_gamepad_data": _emscripten_sample_gamepad_data,
 "emscripten_set_beforeunload_callback_on_thread": _emscripten_set_beforeunload_callback_on_thread,
 "emscripten_set_blur_callback_on_thread": _emscripten_set_blur_callback_on_thread,
 "emscripten_set_canvas_element_size": _emscripten_set_canvas_element_size,
 "emscripten_set_click_callback_on_thread": _emscripten_set_click_callback_on_thread,
 "emscripten_set_element_css_size": _emscripten_set_element_css_size,
 "emscripten_set_focus_callback_on_thread": _emscripten_set_focus_callback_on_thread,
 "emscripten_set_fullscreenchange_callback_on_thread": _emscripten_set_fullscreenchange_callback_on_thread,
 "emscripten_set_gamepadconnected_callback_on_thread": _emscripten_set_gamepadconnected_callback_on_thread,
 "emscripten_set_gamepaddisconnected_callback_on_thread": _emscripten_set_gamepaddisconnected_callback_on_thread,
 "emscripten_set_keydown_callback_on_thread": _emscripten_set_keydown_callback_on_thread,
 "emscripten_set_keypress_callback_on_thread": _emscripten_set_keypress_callback_on_thread,
 "emscripten_set_keyup_callback_on_thread": _emscripten_set_keyup_callback_on_thread,
 "emscripten_set_main_loop": _emscripten_set_main_loop,
 "emscripten_set_mousedown_callback_on_thread": _emscripten_set_mousedown_callback_on_thread,
 "emscripten_set_mouseenter_callback_on_thread": _emscripten_set_mouseenter_callback_on_thread,
 "emscripten_set_mouseleave_callback_on_thread": _emscripten_set_mouseleave_callback_on_thread,
 "emscripten_set_mousemove_callback_on_thread": _emscripten_set_mousemove_callback_on_thread,
 "emscripten_set_mouseup_callback_on_thread": _emscripten_set_mouseup_callback_on_thread,
 "emscripten_set_pointerlockchange_callback_on_thread": _emscripten_set_pointerlockchange_callback_on_thread,
 "emscripten_set_resize_callback_on_thread": _emscripten_set_resize_callback_on_thread,
 "emscripten_set_touchcancel_callback_on_thread": _emscripten_set_touchcancel_callback_on_thread,
 "emscripten_set_touchend_callback_on_thread": _emscripten_set_touchend_callback_on_thread,
 "emscripten_set_touchmove_callback_on_thread": _emscripten_set_touchmove_callback_on_thread,
 "emscripten_set_touchstart_callback_on_thread": _emscripten_set_touchstart_callback_on_thread,
 "emscripten_set_visibilitychange_callback_on_thread": _emscripten_set_visibilitychange_callback_on_thread,
 "emscripten_set_wheel_callback_on_thread": _emscripten_set_wheel_callback_on_thread,
 "emscripten_set_window_title": _emscripten_set_window_title,
 "emscripten_sleep": _emscripten_sleep,
 "emscripten_webgl_create_context": _emscripten_webgl_create_context,
 "emscripten_webgl_enable_extension": _emscripten_webgl_enable_extension,
 "emscripten_webgl_init_context_attributes": _emscripten_webgl_init_context_attributes,
 "emscripten_webgl_make_context_current": _emscripten_webgl_make_context_current,
 "environ_get": _environ_get,
 "environ_sizes_get": _environ_sizes_get,
 "fd_close": _fd_close,
 "fd_read": _fd_read,
 "fd_seek": _fd_seek,
 "fd_write": _fd_write,
 "glAttachShader": _glAttachShader,
 "glBindAttribLocation": _glBindAttribLocation,
 "glBindBuffer": _glBindBuffer,
 "glBindVertexArray": _glBindVertexArray,
 "glBlendFunc": _glBlendFunc,
 "glBlendFuncSeparate": _glBlendFuncSeparate,
 "glBufferData": _glBufferData,
 "glClear": _glClear,
 "glClearColor": _glClearColor,
 "glCompileShader": _glCompileShader,
 "glCreateProgram": _glCreateProgram,
 "glCreateShader": _glCreateShader,
 "glDeleteProgram": _glDeleteProgram,
 "glDeleteShader": _glDeleteShader,
 "glDepthFunc": _glDepthFunc,
 "glDisable": _glDisable,
 "glDrawElements": _glDrawElements,
 "glEnable": _glEnable,
 "glEnableVertexAttribArray": _glEnableVertexAttribArray,
 "glFinish": _glFinish,
 "glFlush": _glFlush,
 "glFrontFace": _glFrontFace,
 "glGenBuffers": _glGenBuffers,
 "glGenVertexArrays": _glGenVertexArrays,
 "glGetAttribLocation": _glGetAttribLocation,
 "glGetUniformLocation": _glGetUniformLocation,
 "glHint": _glHint,
 "glLinkProgram": _glLinkProgram,
 "glReleaseShaderCompiler": _glReleaseShaderCompiler,
 "glShaderSource": _glShaderSource,
 "glUniform1f": _glUniform1f,
 "glUniform1i": _glUniform1i,
 "glUniform3f": _glUniform3f,
 "glUniform4f": _glUniform4f,
 "glUseProgram": _glUseProgram,
 "glVertexAttribPointer": _glVertexAttribPointer,
 "ma": ma
};

var asm = createWasm();

var ___wasm_call_ctors = Module["___wasm_call_ctors"] = createExportWrapper("__wasm_call_ctors");

var _nano = Module["_nano"] = createExportWrapper("nano");

var _memcpy = Module["_memcpy"] = createExportWrapper("memcpy");

var _malloc = Module["_malloc"] = createExportWrapper("malloc");

var _str = Module["_str"] = createExportWrapper("str");

var _pl = Module["_pl"] = createExportWrapper("pl");

var _b3 = Module["_b3"] = createExportWrapper("b3");

var _ldd = Module["_ldd"] = createExportWrapper("ldd");

var _main = Module["_main"] = createExportWrapper("main");

var _free = Module["_free"] = createExportWrapper("free");

var ___errno_location = Module["___errno_location"] = createExportWrapper("__errno_location");

var ___dl_seterr = Module["___dl_seterr"] = createExportWrapper("__dl_seterr");

var _fflush = Module["_fflush"] = createExportWrapper("fflush");

var _emscripten_stack_init = Module["_emscripten_stack_init"] = function() {
 return (_emscripten_stack_init = Module["_emscripten_stack_init"] = Module["asm"]["emscripten_stack_init"]).apply(null, arguments);
};

var _emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = function() {
 return (_emscripten_stack_get_free = Module["_emscripten_stack_get_free"] = Module["asm"]["emscripten_stack_get_free"]).apply(null, arguments);
};

var _emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = function() {
 return (_emscripten_stack_get_base = Module["_emscripten_stack_get_base"] = Module["asm"]["emscripten_stack_get_base"]).apply(null, arguments);
};

var _emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = function() {
 return (_emscripten_stack_get_end = Module["_emscripten_stack_get_end"] = Module["asm"]["emscripten_stack_get_end"]).apply(null, arguments);
};

var stackSave = Module["stackSave"] = createExportWrapper("stackSave");

var stackRestore = Module["stackRestore"] = createExportWrapper("stackRestore");

var stackAlloc = Module["stackAlloc"] = createExportWrapper("stackAlloc");

var _emscripten_stack_get_current = Module["_emscripten_stack_get_current"] = function() {
 return (_emscripten_stack_get_current = Module["_emscripten_stack_get_current"] = Module["asm"]["emscripten_stack_get_current"]).apply(null, arguments);
};

var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji");

var dynCall_ji = Module["dynCall_ji"] = createExportWrapper("dynCall_ji");

var ___start_em_js = Module["___start_em_js"] = 5313176;

var ___stop_em_js = Module["___stop_em_js"] = 5318210;

Module["addRunDependency"] = addRunDependency;

Module["removeRunDependency"] = removeRunDependency;

Module["FS_createPath"] = FS.createPath;

Module["FS_createDataFile"] = FS.createDataFile;

Module["FS_createPreloadedFile"] = FS.createPreloadedFile;

Module["FS_createLazyFile"] = FS.createLazyFile;

Module["FS_createDevice"] = FS.createDevice;

Module["FS_unlink"] = FS.unlink;

Module["ccall"] = ccall;

var unexportedRuntimeSymbols = [ "run", "UTF8ArrayToString", "UTF8ToString", "stringToUTF8Array", "stringToUTF8", "lengthBytesUTF8", "addOnPreRun", "addOnInit", "addOnPreMain", "addOnExit", "addOnPostRun", "FS_createFolder", "FS_createLink", "getLEB", "getFunctionTables", "alignFunctionTables", "registerFunctions", "prettyPrint", "getCompilerSetting", "out", "err", "callMain", "abort", "keepRuntimeAlive", "wasmMemory", "stackAlloc", "stackSave", "stackRestore", "getTempRet0", "setTempRet0", "writeStackCookie", "checkStackCookie", "ptrToString", "zeroMemory", "stringToNewUTF8", "exitJS", "getHeapMax", "emscripten_realloc_buffer", "ENV", "ERRNO_CODES", "ERRNO_MESSAGES", "setErrNo", "inetPton4", "inetNtop4", "inetPton6", "inetNtop6", "readSockaddr", "writeSockaddr", "DNS", "getHostByName", "Protocols", "Sockets", "getRandomDevice", "warnOnce", "traverseStack", "UNWIND_CACHE", "convertPCtoSourceLocation", "readEmAsmArgsArray", "readEmAsmArgs", "runEmAsmFunction", "runMainThreadEmAsm", "jstoi_q", "jstoi_s", "getExecutableName", "listenOnce", "autoResumeAudioContext", "dynCallLegacy", "getDynCaller", "dynCall", "handleException", "runtimeKeepalivePush", "runtimeKeepalivePop", "callUserCallback", "maybeExit", "safeSetTimeout", "asmjsMangle", "asyncLoad", "alignMemory", "mmapAlloc", "writeI53ToI64", "writeI53ToI64Clamped", "writeI53ToI64Signaling", "writeI53ToU64Clamped", "writeI53ToU64Signaling", "readI53FromI64", "readI53FromU64", "convertI32PairToI53", "convertI32PairToI53Checked", "convertU32PairToI53", "getCFunc", "cwrap", "uleb128Encode", "sigToWasmTypes", "generateFuncType", "convertJsFunctionToWasm", "freeTableIndexes", "functionsInTableMap", "getEmptyTableSlot", "updateTableMap", "addFunction", "removeFunction", "reallyNegative", "unSign", "strLen", "reSign", "formatString", "setValue", "getValue", "PATH", "PATH_FS", "intArrayFromString", "intArrayToString", "AsciiToString", "stringToAscii", "UTF16Decoder", "UTF16ToString", "stringToUTF16", "lengthBytesUTF16", "UTF32ToString", "stringToUTF32", "lengthBytesUTF32", "allocateUTF8", "allocateUTF8OnStack", "writeStringToMemory", "writeArrayToMemory", "writeAsciiToMemory", "SYSCALLS", "getSocketFromFD", "getSocketAddress", "JSEvents", "registerKeyEventCallback", "specialHTMLTargets", "maybeCStringToJsString", "findEventTarget", "findCanvasEventTarget", "getBoundingClientRect", "fillMouseEventData", "registerMouseEventCallback", "registerWheelEventCallback", "registerUiEventCallback", "registerFocusEventCallback", "fillDeviceOrientationEventData", "registerDeviceOrientationEventCallback", "fillDeviceMotionEventData", "registerDeviceMotionEventCallback", "screenOrientation", "fillOrientationChangeEventData", "registerOrientationChangeEventCallback", "fillFullscreenChangeEventData", "registerFullscreenChangeEventCallback", "JSEvents_requestFullscreen", "JSEvents_resizeCanvasForFullscreen", "registerRestoreOldStyle", "hideEverythingExceptGivenElement", "restoreHiddenElements", "setLetterbox", "currentFullscreenStrategy", "restoreOldWindowedStyle", "softFullscreenResizeWebGLRenderTarget", "doRequestFullscreen", "fillPointerlockChangeEventData", "registerPointerlockChangeEventCallback", "registerPointerlockErrorEventCallback", "requestPointerLock", "fillVisibilityChangeEventData", "registerVisibilityChangeEventCallback", "registerTouchEventCallback", "fillGamepadEventData", "registerGamepadEventCallback", "registerBeforeUnloadEventCallback", "fillBatteryEventData", "battery", "registerBatteryEventCallback", "setCanvasElementSize", "getCanvasElementSize", "demangle", "demangleAll", "jsStackTrace", "stackTrace", "ExitStatus", "getEnvStrings", "checkWasiClock", "doReadv", "doWritev", "dlopenMissingError", "createDyncallWrapper", "setImmediateWrapped", "clearImmediateWrapped", "polyfillSetImmediate", "uncaughtExceptionCount", "exceptionLast", "exceptionCaught", "ExceptionInfo", "exception_addRef", "exception_decRef", "Browser", "setMainLoop", "wget", "FS", "MEMFS", "TTY", "PIPEFS", "SOCKFS", "_setNetworkCallback", "tempFixedLengthArray", "miniTempWebGLFloatBuffers", "heapObjectForWebGLType", "heapAccessShiftForWebGLHeap", "GL", "emscriptenWebGLGet", "computeUnpackAlignedImageSize", "emscriptenWebGLGetTexPixelData", "emscriptenWebGLGetUniform", "webglGetUniformLocation", "webglPrepareUniformLocationsBeforeFirstUse", "webglGetLeftBracePos", "emscriptenWebGLGetVertexAttrib", "emscriptenWebGLGetBufferBinding", "emscriptenWebGLValidateMapBufferTarget", "writeGLArray", "AL", "SDL_unicode", "SDL_ttfContext", "SDL_audio", "SDL", "SDL_gfx", "GLUT", "EGL", "GLFW_Window", "GLFW", "GLEW", "IDBStore", "runAndAbortIfError", "emscriptenWebGLGetIndexed", "ALLOC_NORMAL", "ALLOC_STACK", "allocate" ];

unexportedRuntimeSymbols.forEach(unexportedRuntimeSymbol);

var missingLibrarySymbols = [ "inetPton4", "inetNtop4", "inetPton6", "inetNtop6", "readSockaddr", "writeSockaddr", "getHostByName", "traverseStack", "convertPCtoSourceLocation", "jstoi_s", "getDynCaller", "runtimeKeepalivePush", "runtimeKeepalivePop", "asmjsMangle", "writeI53ToI64Clamped", "writeI53ToI64Signaling", "writeI53ToU64Clamped", "writeI53ToU64Signaling", "convertU32PairToI53", "cwrap", "uleb128Encode", "sigToWasmTypes", "generateFuncType", "convertJsFunctionToWasm", "getEmptyTableSlot", "updateTableMap", "addFunction", "removeFunction", "reallyNegative", "unSign", "strLen", "reSign", "formatString", "intArrayToString", "AsciiToString", "stringToAscii", "UTF16ToString", "stringToUTF16", "lengthBytesUTF16", "UTF32ToString", "stringToUTF32", "lengthBytesUTF32", "allocateUTF8OnStack", "writeStringToMemory", "getSocketFromFD", "getSocketAddress", "fillDeviceOrientationEventData", "registerDeviceOrientationEventCallback", "fillDeviceMotionEventData", "registerDeviceMotionEventCallback", "screenOrientation", "fillOrientationChangeEventData", "registerOrientationChangeEventCallback", "hideEverythingExceptGivenElement", "restoreHiddenElements", "softFullscreenResizeWebGLRenderTarget", "registerPointerlockErrorEventCallback", "fillBatteryEventData", "battery", "registerBatteryEventCallback", "jsStackTrace", "stackTrace", "checkWasiClock", "createDyncallWrapper", "setImmediateWrapped", "clearImmediateWrapped", "polyfillSetImmediate", "ExceptionInfo", "exception_addRef", "exception_decRef", "_setNetworkCallback", "writeGLArray", "SDL_unicode", "SDL_ttfContext", "SDL_audio", "GLFW_Window", "runAndAbortIfError", "ALLOC_NORMAL", "ALLOC_STACK", "allocate" ];

missingLibrarySymbols.forEach(missingLibrarySymbol);

var calledRun;

dependenciesFulfilled = function runCaller() {
 if (!calledRun) run();
 if (!calledRun) dependenciesFulfilled = runCaller;
};

function callMain(args) {
 assert(runDependencies == 0, 'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])');
 assert(__ATPRERUN__.length == 0, "cannot call main when preRun functions remain to be called");
 var entryFunction = Module["_main"];
 var argc = 0;
 var argv = 0;
 try {
  var ret = entryFunction(argc, argv);
  exitJS(ret, true);
  return ret;
 } catch (e) {
  return handleException(e);
 }
}

function stackCheckInit() {
 _emscripten_stack_init();
 writeStackCookie();
}

function run(args) {
 args = args || arguments_;
 if (runDependencies > 0) {
  return;
 }
 stackCheckInit();
 preRun();
 if (runDependencies > 0) {
  return;
 }
 function doRun() {
  if (calledRun) return;
  calledRun = true;
  Module["calledRun"] = true;
  if (ABORT) return;
  initRuntime();
  preMain();
  if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
  if (shouldRunNow) callMain(args);
  postRun();
 }
 if (Module["setStatus"]) {
  Module["setStatus"]("Running...");
  setTimeout(function() {
   setTimeout(function() {
    Module["setStatus"]("");
   }, 1);
   doRun();
  }, 1);
 } else {
  doRun();
 }
 checkStackCookie();
}

function checkUnflushedContent() {
 var oldOut = out;
 var oldErr = err;
 var has = false;
 out = err = x => {
  has = true;
 };
 try {
  _fflush(0);
  [ "stdout", "stderr" ].forEach(function(name) {
   var info = FS.analyzePath("/dev/" + name);
   if (!info) return;
   var stream = info.object;
   var rdev = stream.rdev;
   var tty = TTY.ttys[rdev];
   if (tty && tty.output && tty.output.length) {
    has = true;
   }
  });
 } catch (e) {}
 out = oldOut;
 err = oldErr;
 if (has) {
  warnOnce("stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the FAQ), or make sure to emit a newline when you printf etc.");
 }
}

if (Module["preInit"]) {
 if (typeof Module["preInit"] == "function") Module["preInit"] = [ Module["preInit"] ];
 while (Module["preInit"].length > 0) {
  Module["preInit"].pop()();
 }
}

var shouldRunNow = true;

if (Module["noInitialRun"]) shouldRunNow = false;

run();
let bz=new BroadcastChannel('bez');

function pll(){
Module.ccall("pl");
}

let fll=new BroadcastChannel('file');
fll.addEventListener('message',ea=> {
let fill=new Uint8Array(ea.data.data);
FS.writeFile('/snd/sample.wav',fill);
setTimeout(function(){
pll();
},1000);
let shutDown=new BroadcastChannel('shutDown');
shutDown.postMessage({
data:222
});
});
let tsl,slt,$ll,$h,r$,$w,$r,$hi,$lt,$hg,rnum,$sc,$ls,lo,mv,he,wi,$pt,mil,randSong,randShade;
let $iwid=document.getElementById("iwid");
let mV=document.getElementById("mv");
let loadV=document.getElementById("ldv");
let $sngs=[];
let $vids=[];
let $shds=[];

function sngs(xml){
var nparser=new DOMParser();
var htmlDoc=nparser.parseFromString(xml.responseText,"text/html");
var preList=htmlDoc.getElementsByTagName("pre")[0].getElementsByTagName("a");
$sngs[0]=preList.length;
for (var i=1;i<preList.length;i++){
var txxt=preList[i].href;
var Self=location.href;
Self=Self.replace(/1ink.1ink/,"");
txxt=txxt.replace(Self,"");
$sngs[i]=Self+"songs/"+txxt;
}}

function vids(xml){
var vparser=new DOMParser();
var htmlDoc=vparser.parseFromString(xml.responseText,"text/html");
var preList=htmlDoc.getElementsByTagName("pre")[0].getElementsByTagName("a");
$vids[0]=preList.length;
for (var i=1;i<preList.length;i++){
var txxt=preList[i].href;
var Self=location.href;
Self=Self.replace(/1ink.1ink/,"");
txxt=txxt.replace(Self,"");
$vids[i]=Self+"video/"+txxt;
}}

function shds(xml){
var sparser=new DOMParser();
var htmlDoc=sparser.parseFromString(xml.responseText,"text/html");
var preList=htmlDoc.getElementsByTagName("pre")[0].getElementsByTagName("a");
$shds[0]=preList.length;
for (var i=1;i<preList.length;i++){
var txxt=preList[i].href;
var Self=location.href;
Self=Self.replace(/1ink.1ink/,"");
txxt=txxt.replace(Self,"");
$shds[i+1]="https://glsl.1ink.us/shaders/"+txxt;
}
randShade=Math.random();
randShade=Math.floor($shds[0]*randShade)+5;
document.getElementById("path").innerHTML=$shds[randShade];
let pth=document.getElementById("path").innerHTML;
let ff=new XMLHttpRequest();
ff.open("GET",pth,true);
ff.responseType="arraybuffer";
ff.onload=function(oEvent){
let sarrayBuffer=ff.response;
if(sarrayBuffer){
let sfil=new Uint8ClampedArray(sarrayBuffer);
FS.writeFile("/shader/shader1.toy",sfil);
}}
ff.send(null);
setTimeout(function(){
Module.ccall("str");
},850);
}

function scanSongs(){
var nxhttp=new XMLHttpRequest();
nxhttp.onreadystatechange=function(){
if(this.readyState==4&&this.status==200){
sngs(this);
}};
nxhttp.open("GET","songs/",true);
nxhttp.send();
}

function scanVideos(){
var fxhttp=new XMLHttpRequest();
fxhttp.onreadystatechange=function(){
if(this.readyState==4&&this.status==200){
vids(this);
}};
fxhttp.open("GET","video/",true);
fxhttp.send();
}

function scanShaders(){
var dxhttp=new XMLHttpRequest();
dxhttp.onreadystatechange=function(){
if(this.readyState==4&&this.status==200){
shds(this);
}};
dxhttp.open("GET","https://glsl.1ink.us/shaders/",true);
dxhttp.send();
}

scanVideos();
scanShaders();
scanSongs();


function reshds(xml){
var sparser=new DOMParser();
var htmlDoc=sparser.parseFromString(xml.responseText,"text/html");
var preList=htmlDoc.getElementsByTagName("pre")[0].getElementsByTagName("a");
$shds[0]=preList.length;
for (var i=1;i<preList.length;i++){
var txxt=preList[i].href;
var Self=location.href;
Self=Self.replace(/1ink.1ink/,"");
txxt=txxt.replace(Self,"");
$shds[i+1]="https://glsl.1ink.us/shaders/"+txxt;
}
randShade=Math.random();
randShade=Math.floor($shds[0]*randShade)+5;
document.getElementById("path").innerHTML=$shds[randShade];
let pth=document.getElementById("path").innerHTML;
let ff=new XMLHttpRequest();
ff.open("GET",pth,true);
ff.responseType="arraybuffer";
ff.onload=function(oEvent){
let sarrayBuffer=ff.response;
if(sarrayBuffer){
let sfil=new Uint8ClampedArray(sarrayBuffer);
FS.unlink("/shader/shader1.toy");
FS.writeFile("/shader/shader1.toy",sfil);
}}
ff.send(null);
setTimeout(function(){
Module.ccall("ldd");
},850);
}

function reScanShaders(){
var dxhttp=new XMLHttpRequest();
dxhttp.onreadystatechange=function(){
if(this.readyState==4&&this.status==200){
reshds(this);
}};
dxhttp.open("GET","https://glsl.1ink.us/shaders/",true);
dxhttp.send();
}


document.getElementById("btn12").addEventListener("click",function(){
reScanShaders();
});

document.getElementById("pmhig").innerHTML=parseInt(window.innerHeight,10);
document.getElementById("ihig").innerHTML=parseInt(window.innerHeight,10);
document.getElementById("scanvas").height=parseInt(window.innerHeight,10);
document.getElementById("scanvas").width=parseInt(window.innerHeight,10);
document.getElementById("mv").load();
document.getElementById("ldv").load();

function snd(){
randSong=Math.floor(($sngs[0]-5)*Math.random());
let songSrc=$sngs[randSong+5];
document.getElementById("track").src=songSrc;
let sng=new BroadcastChannel("sng");
sng.postMessage({data:songSrc});}

document.getElementById("btn8").addEventListener("click",function(){
setTimeout(function(){window.open('./flac');},250);
setTimeout(function(){snd();},1200);
});
let tem=document.getElementById("tim");
ban=document.getElementById("btn1");
let sfr=document.getElementById("slideframe");
function grab$lt(){
$lt=Math.round($lt);}
$lt=tem.innerHTML;
grab$lt();
let slo=new Slideout({"panel":document.getElementById("panel"),"menu":document.getElementById("menu"),"padding":384,"tolerance":70,"easing":"cubic-bezier(.32,2,.55,.27)"});
ban.addEventListener("click",function(){slo.toggle();sfr.innerHTML="";
setTimeout(function(){
grab$lt();slt=$lt/1000;slt=Math.round(slt);
sfr.innerHTML='<input type='+'"te'+'xt" id'+'="time'+'slider"/'+'>';
tsl=new rSlider({target:"#timeslider",values:{min:1.00,max:45.00},
step:[0.50],labels:false,tooltip:true,scale:false,});
grab$lt();slt=($lt/1000);slt=slt*100;slt=Math.round(slt);
slt=slt/100;tsl.setValues(slt);
document.getElementById("menu").addEventListener("click",function(){
$ll=tsl.getValue();$ll=$ll*100;$ll=Math.round($ll);$ll=$ll/100;$ll=($ll*1000);tem.innerHTML=$ll;
});
setTimeout(function(){
slt=tem.innerHTML;
},8);},16);});
let adr="./intro.mp4";
wi=1920;
he=1080;
hii=window.innerHeight;
document.getElementById("ihid").innerHTML=hii;
r$=hii/he;
$w=wi*r$;
let $ihigB=document.getElementById("ihid");
let $ihig=document.getElementById("ihig");
$hg=hii+"px";
$ihig.innerHTML=parseInt(window.innerHeight,10);
$iwid.innerHTML=parseInt($w,10);
document.getElementById("wrap").style.lineheight=$hg;
document.getElementById("wrap").style.pointerEvents="auto";
document.getElementById("isrc").innerHTML=adr;
mV.play();
setTimeout(function(){Module.ccall("b3");},700);
// setTimeout(function(){document.getElementById("btn").click();},2700);
setTimeout(function(){
bz.postMessage({
data:222
});},600);
// setTimeout(function(){document.getElementById("btn10").click();},2200);
// setTimeout(function(){document.getElementById("btn3").click();},700);
setTimeout(function(){window.open('./flac');},330);
setTimeout(function(){snd();},1500);

function loada(){
loadV.addEventListener("canplay",function(){
loadV.width=this.videoWidth;
loadV.height=this.videoHeight;
document.getElementById("wid").innerHTML=this.videoWidth;
document.getElementById("hig").innerHTML=this.videoHeight;
$sc=this.duration;
mil=Math.round($sc*1000);
$pt=Math.random()*mil;
$pt=$pt*1000;
$pt=$pt/1000;
$pt=Math.round($pt);
$pt=$pt/1000;
document.getElementById("idur").innerHTML=mil/1000;
document.getElementById("itim").innerHTML=$pt;
});
vide=document.querySelectorAll("video");
document.getElementById("pmhig").innerHTML=parseInt(window.innerHeight,10);
hii=window.innerHeight;
document.getElementById("ihid").innerHTML=hii;
$lt=Math.round(tem.innerHTML);
$ldt=document.getElementById("tim").innerHTML;
$ls=$lt/1000;
$ls=$ls*1000;
$ls=Math.round($ls);
$ls=$ls/1000;
rnum=Math.floor((Math.random()*($vids[0]-5))+5);
document.getElementById("isrc").innerHTML=$vids[rnum];
$h=window.innerHeight;
he=document.getElementById("hig").innerHTML;
wi=document.getElementById("wid").innerHTML;
r$=he/$h;
$w=wi/r$;
hii=$ihigB.innerHTML;
$hi=$h-hii;
if($hi>1){$h=$ihigB.innerHTML;$ihig.innerHTML=$h;$r=$h/he;$r=$r*1000;$r=$r/1000;$w=wi*$r;}
$hg=$h+"px";
window.scroll(0,0);
mv=vide[0].id;
lo=vide[1].id;
vide[0].id=lo;
vide[1].id=mv;
document.getElementById("mv").play();
document.getElementById("ldv").src=document.getElementById("isrc").innerHTML;
document.getElementById("ldv").currentTime=document.getElementById("itim").innerHTML;
document.getElementById("ldv").load();
$iwid.innerHTML=parseInt($w,10);
$ihig.innerHTML=parseInt(window.innerHeight,10);
document.getElementById("pmhig").innerHTML=parseInt(window.innerHeight,10);
document.getElementById("circle").height=parseInt(window.innerHeight,10);
document.getElementById("circle").width=parseInt(window.innerWidth,10);
document.getElementById("di").click();
setTimeout(function(){
loada();
},$ldt);
}

loada();