@genai-fi/nanogpt 0.20.0 → 0.20.2

package/dist/gpgpu_math-DvLcCH6u.js

@@ -0,0 +1,1612 @@
+import { Ln as e, Ms as t, Ns as n, Ps as r, Rs as i, cc as a, ic as o, oc as s, sc as c, tc as l } from "./dist-BewPQWjc.js";
+import { t as u } from "./backend_util-Cg-roD1p.js";
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/canvas_util.js
+var d = {}, f = {
+	alpha: !1,
+	antialias: !1,
+	premultipliedAlpha: !1,
+	preserveDrawingBuffer: !1,
+	depth: !1,
+	stencil: !1,
+	failIfMajorPerformanceCaveat: !0
+};
+function p(e, t) {
+	d[e] = t;
+}
+function m(e, t) {
+	if (!(e in d) || t != null) {
+		let n = g(e, t);
+		if (n !== null) d[e] = n;
+		else return console.log("Could not get context for WebGL version", e), null;
+	}
+	let n = d[e];
+	return n == null || n.isContextLost() ? (delete d[e], m(e)) : (n.disable(n.DEPTH_TEST), n.disable(n.STENCIL_TEST), n.disable(n.BLEND), n.disable(n.DITHER), n.disable(n.POLYGON_OFFSET_FILL), n.disable(n.SAMPLE_COVERAGE), n.enable(n.SCISSOR_TEST), n.enable(n.CULL_FACE), n.cullFace(n.BACK), d[e]);
+}
+function h(e) {
+	if (!t().getBool("IS_SAFARI") && typeof OffscreenCanvas < "u" && e === 2) return new OffscreenCanvas(300, 150);
+	if (typeof document < "u") return document.createElement("canvas");
+	throw Error("Cannot create a canvas in this context");
+}
+function g(e, n) {
+	if (e !== 1 && e !== 2) throw Error("Cannot get WebGL rendering context, WebGL is disabled.");
+	let r = n ?? h(e);
+	return r.addEventListener("webglcontextlost", (t) => {
+		t.preventDefault(), delete d[e];
+	}, !1), t().getBool("SOFTWARE_WEBGL_ENABLED") && (f.failIfMajorPerformanceCaveat = !1), e === 1 ? r.getContext("webgl", f) || r.getContext("experimental-webgl", f) : r.getContext("webgl2", f);
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/tex_util.js
+var _;
+(function(e) {
+	e[e.DENSE = 0] = "DENSE", e[e.SHARED_BATCH = 1] = "SHARED_BATCH";
+})(_ ||= {});
+var v;
+(function(e) {
+	e[e.RENDER = 0] = "RENDER", e[e.UPLOAD = 1] = "UPLOAD", e[e.PIXELS = 2] = "PIXELS", e[e.DOWNLOAD = 3] = "DOWNLOAD";
+})(v ||= {});
+var y;
+(function(e) {
+	e[e.UNPACKED_FLOAT16 = 0] = "UNPACKED_FLOAT16", e[e.UNPACKED_FLOAT32 = 1] = "UNPACKED_FLOAT32", e[e.PACKED_4X1_UNSIGNED_BYTE = 2] = "PACKED_4X1_UNSIGNED_BYTE", e[e.PACKED_2X2_FLOAT32 = 3] = "PACKED_2X2_FLOAT32", e[e.PACKED_2X2_FLOAT16 = 4] = "PACKED_2X2_FLOAT16";
+})(y ||= {});
+function b(e, t) {
+	return [t, e];
+}
+function x(e, t) {
+	return e * t;
+}
+function ee(e) {
+	let t = s(e);
+	return c(Math.ceil(t / 4));
+}
+function S(e, t) {
+	return [Math.max(1, Math.ceil(t / 2)), Math.max(1, Math.ceil(e / 2))];
+}
+function C(e, t) {
+	let [n, r] = S(e, t);
+	return n * r * 4;
+}
+function w(e, n) {
+	let r = e, i, a, o, s, c, l, u, d, f, p;
+	return t().getNumber("WEBGL_VERSION") === 2 ? (i = r.R32F, a = r.R16F, o = r.RGBA16F, s = r.RGBA32F, c = r.RED, u = 4, d = 1, f = r.HALF_FLOAT, p = r.FLOAT, l = r.RGBA8) : (i = e.RGBA, a = e.RGBA, o = e.RGBA, s = r.RGBA, c = e.RGBA, u = 4, d = 4, f = n == null ? null : n.HALF_FLOAT_OES, p = e.FLOAT, l = e.RGBA), {
+		internalFormatFloat: i,
+		internalFormatHalfFloat: a,
+		internalFormatPackedHalfFloat: o,
+		internalFormatPackedFloat: s,
+		textureFormatFloat: c,
+		downloadTextureFormat: l,
+		downloadUnpackNumChannels: u,
+		defaultNumChannels: d,
+		textureTypeHalfFloat: f,
+		textureTypeFloat: p
+	};
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/webgl_util.js
+function T(e, n) {
+	let r = n();
+	return t().getBool("DEBUG") && te(e), r;
+}
+function te(e) {
+	let t = e.getError();
+	if (t !== e.NO_ERROR) throw Error("WebGL Error: " + ae(e, t));
+}
+var ne = 5.96e-8, re = 65504;
+function ie(e) {
+	return !!(t().getBool("WEBGL_RENDER_FLOAT32_ENABLED") || e === 0 || ne < Math.abs(e) && Math.abs(e) < re);
+}
+function ae(e, t) {
+	switch (t) {
+		case e.NO_ERROR: return "NO_ERROR";
+		case e.INVALID_ENUM: return "INVALID_ENUM";
+		case e.INVALID_VALUE: return "INVALID_VALUE";
+		case e.INVALID_OPERATION: return "INVALID_OPERATION";
+		case e.INVALID_FRAMEBUFFER_OPERATION: return "INVALID_FRAMEBUFFER_OPERATION";
+		case e.OUT_OF_MEMORY: return "OUT_OF_MEMORY";
+		case e.CONTEXT_LOST_WEBGL: return "CONTEXT_LOST_WEBGL";
+		default: return `Unknown error code ${t}`;
+	}
+}
+function oe(e, t) {
+	return A(e, () => e.getExtension(t), "Extension \"" + t + "\" not supported on this browser.");
+}
+function se(e, t) {
+	let n = A(e, () => e.createShader(e.VERTEX_SHADER), "Unable to create vertex WebGLShader.");
+	if (T(e, () => e.shaderSource(n, t)), T(e, () => e.compileShader(n)), e.getShaderParameter(n, e.COMPILE_STATUS) === !1) throw console.log(e.getShaderInfoLog(n)), Error("Failed to compile vertex shader.");
+	return n;
+}
+function ce(e, n) {
+	let r = A(e, () => e.createShader(e.FRAGMENT_SHADER), "Unable to create fragment WebGLShader.");
+	if (T(e, () => e.shaderSource(r, n)), T(e, () => e.compileShader(r)), t().get("ENGINE_COMPILE_ONLY")) return r;
+	if (e.getShaderParameter(r, e.COMPILE_STATUS) === !1) throw E(n, e.getShaderInfoLog(r)), Error("Failed to compile fragment shader.");
+	return r;
+}
+var le = /ERROR: [0-9]+:([0-9]+):/g;
+function E(e, t) {
+	let n = le.exec(t);
+	if (n == null) {
+		console.log(`Couldn't parse line number in error: ${t}`), console.log(e);
+		return;
+	}
+	let r = +n[1], i = e.split("\n"), a = i.length.toString().length + 2, s = i.map((e, t) => o((t + 1).toString(), a) + e), c = 0;
+	for (let e = 0; e < s.length; e++) c = Math.max(s[e].length, c);
+	let l = s.slice(0, r - 1), u = s.slice(r - 1, r), d = s.slice(r);
+	console.log(l.join("\n")), console.log(t.split("\n")[0]), console.log(`%c ${o(u[0], c)}`, "border:1px solid red; background-color:#e3d2d2; color:#a61717"), console.log(d.join("\n"));
+}
+function ue(e) {
+	return A(e, () => e.createProgram(), "Unable to create WebGLProgram.");
+}
+function de(e, n) {
+	if (T(e, () => e.linkProgram(n)), !t().get("ENGINE_COMPILE_ONLY") && e.getProgramParameter(n, e.LINK_STATUS) === !1) throw console.log(e.getProgramInfoLog(n)), Error("Failed to link vertex and fragment shaders.");
+}
+function fe(e, t) {
+	if (T(e, () => e.validateProgram(t)), e.getProgramParameter(t, e.VALIDATE_STATUS) === !1) throw console.log(e.getProgramInfoLog(t)), Error("Shader program validation failed.");
+}
+function pe(e, t) {
+	let n = A(e, () => e.createBuffer(), "Unable to create WebGLBuffer");
+	return T(e, () => e.bindBuffer(e.ARRAY_BUFFER, n)), T(e, () => e.bufferData(e.ARRAY_BUFFER, t, e.STATIC_DRAW)), n;
+}
+function me(e, t) {
+	let n = A(e, () => e.createBuffer(), "Unable to create WebGLBuffer");
+	return T(e, () => e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, n)), T(e, () => e.bufferData(e.ELEMENT_ARRAY_BUFFER, t, e.STATIC_DRAW)), n;
+}
+function he(e) {
+	return A(e, () => e.createTexture(), "Unable to create WebGLTexture.");
+}
+function ge(e, n) {
+	let r = t().getNumber("WEBGL_MAX_TEXTURE_SIZE");
+	if (e <= 0 || n <= 0) {
+		let t = `[${e}x${n}]`;
+		throw Error("Requested texture size " + t + " is invalid.");
+	}
+	if (e > r || n > r) {
+		let t = `[${e}x${n}]`, i = `[${r}x${r}]`;
+		throw Error("Requested texture size " + t + " greater than WebGL maximum on this browser / GPU " + i + ".");
+	}
+}
+function _e(e) {
+	return A(e, () => e.createFramebuffer(), "Unable to create WebGLFramebuffer.");
+}
+function ve(e, t, n, r, i, a, o) {
+	let s = e.getAttribLocation(t, n);
+	return s === -1 ? !1 : (T(e, () => e.bindBuffer(e.ARRAY_BUFFER, r)), T(e, () => e.vertexAttribPointer(s, i, e.FLOAT, !1, a, o)), T(e, () => e.enableVertexAttribArray(s)), !0);
+}
+function ye(e, t, n) {
+	we(e, n), T(e, () => e.activeTexture(e.TEXTURE0 + n)), T(e, () => e.bindTexture(e.TEXTURE_2D, t));
+}
+function be(e, t, n) {
+	return A(e, () => e.getUniformLocation(t, n), "uniform \"" + n + "\" not present in program.");
+}
+function xe(e, t, n) {
+	return e.getUniformLocation(t, n);
+}
+function Se(e, t, n, r) {
+	T(e, () => ye(e, t, r)), T(e, () => e.uniform1i(n, r));
+}
+function Ce(e, t, n) {
+	T(e, () => e.bindFramebuffer(e.FRAMEBUFFER, n)), T(e, () => e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, t, 0));
+}
+function D(e, t) {
+	T(e, () => e.bindFramebuffer(e.FRAMEBUFFER, t)), T(e, () => e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, null, 0));
+}
+function O(e) {
+	let t = e.checkFramebufferStatus(e.FRAMEBUFFER);
+	if (t !== e.FRAMEBUFFER_COMPLETE) throw Error("Error binding framebuffer: " + k(e, t));
+}
+function k(e, t) {
+	switch (t) {
+		case e.FRAMEBUFFER_INCOMPLETE_ATTACHMENT: return "FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
+		case e.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: return "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
+		case e.FRAMEBUFFER_INCOMPLETE_DIMENSIONS: return "FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
+		case e.FRAMEBUFFER_UNSUPPORTED: return "FRAMEBUFFER_UNSUPPORTED";
+		default: return `unknown error ${t}`;
+	}
+}
+function A(e, t, n) {
+	let r = T(e, () => t());
+	if (r == null) throw Error(n);
+	return r;
+}
+function we(e, t) {
+	let n = e.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1, r = t + e.TEXTURE0;
+	if (r < e.TEXTURE0 || r > n) {
+		let e = `[gl.TEXTURE0, gl.TEXTURE${n}]`;
+		throw Error(`textureUnit must be in ${e}.`);
+	}
+}
+function j(e, t = 2) {
+	return s(e.slice(0, e.length - t));
+}
+function M(e) {
+	if (e.length === 0) throw Error("Cannot get rows and columns of an empty shape array.");
+	return [e.length > 1 ? e[e.length - 2] : 1, e[e.length - 1]];
+}
+function Te(e) {
+	let t = [
+		1,
+		1,
+		1
+	];
+	return e.length === 0 || e.length === 1 && e[0] === 1 || (t = [j(e), ...M(e)]), t;
+}
+function Ee(e, n = !1) {
+	let r = t().getNumber("WEBGL_MAX_TEXTURE_SIZE"), i = t().getNumber("WEBGL_MAX_SIZE_FOR_NARROW_TEXTURE");
+	i === Infinity && t().getBool("WEBGL_AUTO_SQUARIFY_NARROW_TEXTURE_SHAPE") && (i = r / 2), n && (r *= 2, i *= 2, e = e.map((t, n) => n >= e.length - 2 ? l(e[n]) : e[n]), e.length === 1 && (e = [2, e[0]])), e.length !== 2 && (e = a(e).newShape);
+	let o = s(e), u = null;
+	e.length <= 1 && o <= r ? u = [1, o] : e.length === 2 && e[0] <= r && e[1] <= r ? u = e : e.length === 3 && e[0] * e[1] <= r && e[2] <= r ? u = [e[0] * e[1], e[2]] : e.length === 3 && e[0] <= r && e[1] * e[2] <= r ? u = [e[0], e[1] * e[2]] : e.length === 4 && e[0] * e[1] * e[2] <= r && e[3] <= r ? u = [e[0] * e[1] * e[2], e[3]] : e.length === 4 && e[0] <= r && e[1] * e[2] * e[3] <= r && (u = [e[0], e[1] * e[2] * e[3]]);
+	let d = u != null && Math.max(...u) > i && Math.min(...u) <= (n ? 2 : 1) && Math.min(...u) > 0;
+	if (u == null || d) if (n) {
+		let t = j(e), n = 2, r = 2;
+		e.length && ([n, r] = M(e)), o = n / 2 * t * (r / 2), u = c(o).map((e) => e * 2);
+	} else u = c(o);
+	return u;
+}
+function N(e) {
+	return e % 2 == 0;
+}
+function De(e, t) {
+	if (e = e.slice(-2), t = t.slice(-2), n(e, t) || !e.length || !t.length || e[0] === 0 || e[1] === 0 || t[0] === 0 || t[1] === 0) return !0;
+	if (e.length !== t.length) {
+		let n = e[e.length - 1], r = t[t.length - 1];
+		if (n === r || N(n) && N(r) && (e[0] === 1 || t[0] === 1)) return !0;
+	}
+	return e[1] === t[1] && N(e[0]) && N(t[0]);
+}
+var P, F;
+function Oe(e) {
+	if (P == null) {
+		let t = m(e);
+		P = t.getParameter(t.MAX_TEXTURE_SIZE);
+	}
+	return P;
+}
+function ke(e) {
+	if (F == null) {
+		let t = m(e);
+		F = t.getParameter(t.MAX_TEXTURE_IMAGE_UNITS);
+	}
+	return Math.min(16, F);
+}
+function Ae(e) {
+	if (e === 0) return 0;
+	let t, n = m(e);
+	return t = I(n, "EXT_disjoint_timer_query_webgl2") && e === 2 ? 2 : +!!I(n, "EXT_disjoint_timer_query"), t;
+}
+function I(e, t) {
+	return e.getExtension(t) != null;
+}
+function je(e) {
+	try {
+		if (m(e) != null) return !0;
+	} catch (e) {
+		return console.log("Error when getting WebGL context: ", e), !1;
+	}
+	return !1;
+}
+function Me(e) {
+	if (e === 0) return !1;
+	let t = m(e);
+	if (e === 1) {
+		if (!I(t, "OES_texture_float")) return !1;
+	} else if (!I(t, "EXT_color_buffer_float")) return !1;
+	return L(t);
+}
+function Ne(e) {
+	if (e === 0) return !1;
+	let t = m(e);
+	if (e === 1) {
+		if (!I(t, "OES_texture_float") || !I(t, "WEBGL_color_buffer_float")) return !1;
+	} else {
+		if (I(t, "EXT_color_buffer_float")) return L(t);
+		let e = "EXT_color_buffer_half_float";
+		return I(t, e) ? Pe(t, t.getExtension(e)) : !1;
+	}
+	return L(t);
+}
+function L(e) {
+	let t = w(e), n = e.createTexture();
+	e.bindTexture(e.TEXTURE_2D, n), e.texImage2D(e.TEXTURE_2D, 0, t.internalFormatFloat, 1, 1, 0, t.textureFormatFloat, t.textureTypeFloat, null);
+	let r = e.createFramebuffer();
+	e.bindFramebuffer(e.FRAMEBUFFER, r), e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, n, 0);
+	let i = e.checkFramebufferStatus(e.FRAMEBUFFER) === e.FRAMEBUFFER_COMPLETE;
+	return e.bindTexture(e.TEXTURE_2D, null), e.bindFramebuffer(e.FRAMEBUFFER, null), e.deleteTexture(n), e.deleteFramebuffer(r), i;
+}
+function Pe(e, t) {
+	let n = w(e, t), r = e.createTexture();
+	e.bindTexture(e.TEXTURE_2D, r), e.texImage2D(e.TEXTURE_2D, 0, n.internalFormatHalfFloat, 1, 1, 0, n.textureFormatFloat, n.textureTypeHalfFloat, null);
+	let i = e.createFramebuffer();
+	e.bindFramebuffer(e.FRAMEBUFFER, i), e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, r, 0);
+	let a = e.checkFramebufferStatus(e.FRAMEBUFFER) === e.FRAMEBUFFER_COMPLETE;
+	return e.bindTexture(e.TEXTURE_2D, null), e.bindFramebuffer(e.FRAMEBUFFER, null), e.deleteTexture(r), e.deleteFramebuffer(i), a;
+}
+function Fe(e) {
+	return e === 2 ? m(e).fenceSync != null : !1;
+}
+function Ie(e, t) {
+	Array.isArray(e) || (e = [e]), e.forEach((e) => {
+		e != null && r(e.dtype !== "complex64", () => `${t} does not support complex64 tensors in the WebGL backend.`);
+	});
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/glsl_version.js
+function R() {
+	let e, n, r, i, a, o, s, c, l, u;
+	return t().getNumber("WEBGL_VERSION") === 2 ? (e = "#version 300 es", n = "in", r = "out", i = "in", a = "texture", o = "outputColor", s = "out vec4 outputColor;", c = t().getBool("WEBGL2_ISNAN_CUSTOM") ? "\n      bool isnan_custom(float val) {\n        uint floatToUint = floatBitsToUint(val);\n        return (floatToUint & 0x7fffffffu) > 0x7f800000u;\n      }\n\n      bvec4 isnan_custom(vec4 val) {\n        return bvec4(isnan_custom(val.x),\n          isnan_custom(val.y), isnan_custom(val.z), isnan_custom(val.w));\n      }\n\n      #define isnan(value) isnan_custom(value)\n    " : "", l = "", u = "\n      #define round(value) newRound(value)\n      int newRound(float value) {\n        return int(floor(value + 0.5));\n      }\n\n      ivec4 newRound(vec4 value) {\n        return ivec4(floor(value + vec4(0.5)));\n      }\n    ") : (e = "", n = "attribute", r = "varying", i = "varying", a = "texture2D", o = "gl_FragColor", s = "", c = "\n      #define isnan(value) isnan_custom(value)\n      bool isnan_custom(float val) {\n        return (val > 0. || val < 1. || val == 0.) ? false : true;\n      }\n      bvec4 isnan_custom(vec4 val) {\n        return bvec4(isnan(val.x), isnan(val.y), isnan(val.z), isnan(val.w));\n      }\n    ", l = "\n      uniform float INFINITY;\n\n      bool isinf(float val) {\n        return abs(val) == INFINITY;\n      }\n      bvec4 isinf(vec4 val) {\n        return equal(abs(val), vec4(INFINITY));\n      }\n    ", u = "\n      int round(float value) {\n        return int(floor(value + 0.5));\n      }\n\n      ivec4 round(vec4 value) {\n        return ivec4(floor(value + vec4(0.5)));\n      }\n    "), {
+		version: e,
+		attribute: n,
+		varyingVs: r,
+		varyingFs: i,
+		texture2D: a,
+		output: o,
+		defineOutput: s,
+		defineSpecialNaN: c,
+		defineSpecialInf: l,
+		defineRound: u
+	};
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/shader_compiler_util.js
+function z(e, t, n = "index") {
+	let r = i(t);
+	return r.map((t, i) => `${`int ${e[i]} = ${n} / ${t}`}; ${i === r.length - 1 ? `int ${e[i + 1]} = ${n} - ${e[i]} * ${t}` : `index -= ${e[i]} * ${t}`};`).join("");
+}
+function B(e, t, n = "index") {
+	let r = i(t);
+	return r.map((t, i) => `${`int ${e[i]} = ${n} / outShapeStrides[${i}]`}; ${i === r.length - 1 ? `int ${e[i + 1]} = ${n} - ${e[i]} * outShapeStrides[${i}]` : `index -= ${e[i]} * outShapeStrides[${i}]`};`).join("");
+}
+function Le(e, t) {
+	let n = e.length, r = e.map((e) => `${t}[${e}]`), i = Array(n - 1);
+	i[n - 2] = r[n - 1];
+	for (let e = n - 3; e >= 0; --e) i[e] = `(${i[e + 1]} * ${r[e + 1]})`;
+	return i;
+}
+function Re(e, t, n = "index") {
+	let r = Le(e.map((e, t) => t), t);
+	return r.map((t, i) => `${`int ${e[i]} = ${n} / ${r[i]}`}; ${i === r.length - 1 ? `int ${e[i + 1]} = ${n} - ${e[i]} * ${r[i]}` : `index -= ${e[i]} * ${r[i]}`};`).join("");
+}
+function ze(e) {
+	let t = i(e).map((e) => e.toString());
+	return `
+  int getFlatIndex(ivec3 coords) {
+    return coords.x * ${t[0]} + coords.y * ${t[1]} + coords.z;
+  }
+`;
+}
+function Be() {
+	return "\n  int getFlatIndex(ivec3 coords) {\n    return coords.x * outShapeStrides[0] + coords.y * outShapeStrides[1] + coords.z;\n  }\n";
+}
+var Ve = "\n  const float FLOAT_MAX = 1.70141184e38;\n  const float FLOAT_MIN = 1.17549435e-38;\n\n  lowp vec4 encode_float(highp float v) {\n    if (isnan(v)) {\n      return vec4(255, 255, 255, 255);\n    }\n\n    highp float av = abs(v);\n\n    if(av < FLOAT_MIN) {\n      return vec4(0.0, 0.0, 0.0, 0.0);\n    } else if(v > FLOAT_MAX) {\n      return vec4(0.0, 0.0, 128.0, 127.0) / 255.0;\n    } else if(v < -FLOAT_MAX) {\n      return vec4(0.0, 0.0,  128.0, 255.0) / 255.0;\n    }\n\n    highp vec4 c = vec4(0,0,0,0);\n\n    highp float e = floor(log2(av));\n    highp float m = exp2(fract(log2(av))) - 1.0;\n\n    c[2] = floor(128.0 * m);\n    m -= c[2] / 128.0;\n    c[1] = floor(32768.0 * m);\n    m -= c[1] / 32768.0;\n    c[0] = floor(8388608.0 * m);\n\n    highp float ebias = e + 127.0;\n    c[3] = floor(ebias / 2.0);\n    ebias -= c[3] * 2.0;\n    c[2] += floor(ebias) * 128.0;\n\n    c[3] += 128.0 * step(0.0, -v);\n\n    return c / 255.0;\n  }\n", { getBroadcastDims: V } = u;
+function He(e, t, n) {
+	let r = [];
+	if (e.forEach((e) => {
+		let t = s(e.shapeInfo.logicalShape);
+		if (e.shapeInfo.isUniform ? r.push(`uniform float ${e.name}${t > 1 ? `[${t}]` : ""};`) : (r.push(`uniform sampler2D ${e.name};`), r.push(`uniform int offset${e.name};`)), n.enableShapeUniforms) {
+			let { uniformShape: t } = Y(n.packedInputs, e.shapeInfo.logicalShape, e.shapeInfo.texShape);
+			switch (t.length) {
+				case 1:
+					r.push(`uniform int ${e.name}Shape;`);
+					break;
+				case 2:
+					r.push(`uniform ivec2 ${e.name}Shape;`);
+					break;
+				case 3:
+					r.push(`uniform ivec3 ${e.name}Shape;`);
+					break;
+				case 4:
+					r.push(`uniform ivec4 ${e.name}Shape;`);
+					break;
+				default: break;
+			}
+			r.push(`uniform ivec2 ${e.name}TexShape;`);
+		}
+	}), n.enableShapeUniforms) {
+		switch (t.logicalShape.length) {
+			case 1:
+				r.push("uniform int outShape;");
+				break;
+			case 2:
+				r.push("uniform ivec2 outShape;"), r.push("uniform int outShapeStrides;");
+				break;
+			case 3:
+				r.push("uniform ivec3 outShape;"), r.push("uniform ivec2 outShapeStrides;");
+				break;
+			case 4:
+				r.push("uniform ivec4 outShape;"), r.push("uniform ivec3 outShapeStrides;");
+				break;
+			default: break;
+		}
+		r.push("uniform ivec2 outTexShape;");
+	}
+	n.customUniforms && n.customUniforms.forEach((e) => {
+		r.push(`uniform ${e.type} ${e.name}${e.arrayIndex ? `[${e.arrayIndex}]` : ""};`);
+	});
+	let i = r.join("\n"), a = e.map((e) => Ue(e, t, n.packedInputs, n.enableShapeUniforms)).join("\n"), o = t.texShape, c = R(), l = Ke(c), u, d, f = Ye(c);
+	return t.isPacked ? (u = We(t.logicalShape, o, n.enableShapeUniforms), d = Je(c)) : (u = Ge(t.logicalShape, o, n.enableShapeUniforms), d = qe(c)), n.packedInputs && (f += $e), [
+		f,
+		l,
+		d,
+		i,
+		u,
+		a,
+		n.userCode
+	].join("\n");
+}
+function H(e, t = !1) {
+	let n = e.shapeInfo.logicalShape;
+	switch (n.length) {
+		case 0: return dt(e, t);
+		case 1: return pt(e, t);
+		case 2: return ht(e, t);
+		case 3: return _t(e, t);
+		case 4: return yt(e, t);
+		case 5: return K(e);
+		case 6: return bt(e);
+		default: throw Error(`${n.length}-D input sampling is not yet supported`);
+	}
+}
+function U(e, t) {
+	switch (e.shapeInfo.logicalShape.length) {
+		case 0: return ut(e);
+		case 1: return ft(e, t);
+		case 2: return mt(e, t);
+		case 3: return gt(e, t);
+		default: return vt(e, t);
+	}
+}
+function Ue(e, t, n = !1, r) {
+	let i = "";
+	n ? i += U(e, r) : i += H(e, r);
+	let a = e.shapeInfo.logicalShape, o = t.logicalShape;
+	return a.length <= o.length && (n ? i += xt(e, t) : i += St(e, t)), i;
+}
+function We(e, t, n) {
+	switch (e.length) {
+		case 0: return W();
+		case 1: return et(e, t, n);
+		case 2: return ct(e, t, n);
+		case 3: return nt(e, t, n);
+		default: return it(e, t, n);
+	}
+}
+function Ge(e, t, n) {
+	switch (e.length) {
+		case 0: return W();
+		case 1: return tt(e, t, n);
+		case 2: return lt(e, t, n);
+		case 3: return rt(e, t, n);
+		case 4: return at(e, t, n);
+		case 5: return ot(e, t);
+		case 6: return st(e, t);
+		default: throw Error(`${e.length}-D output sampling is not yet supported`);
+	}
+}
+function Ke(e) {
+	return `
+    float sampleTexture(sampler2D textureSampler, vec2 uv) {
+      return ${e.texture2D}(textureSampler, uv).r;
+    }
+  `;
+}
+function qe(e) {
+	return `
+    void setOutput(float val) {
+      ${e.output} = vec4(val, 0, 0, 0);
+    }
+  `;
+}
+function Je(e) {
+	return `
+    void setOutput(vec4 val) {
+      ${e.output} = val;
+    }
+  `;
+}
+function Ye(e) {
+	return `${e.version}
+    precision highp float;
+    precision highp int;
+    precision highp sampler2D;
+    ${e.varyingFs} vec2 resultUV;
+    ${e.defineOutput}
+    const vec2 halfCR = vec2(0.5, 0.5);
+
+    struct ivec5
+    {
+      int x;
+      int y;
+      int z;
+      int w;
+      int u;
+    };
+
+    struct ivec6
+    {
+      int x;
+      int y;
+      int z;
+      int w;
+      int u;
+      int v;
+    };
+
+    uniform float NAN;
+    ${e.defineSpecialNaN}
+    ${e.defineSpecialInf}
+    ${e.defineRound}
+
+    int imod(int x, int y) {
+      return x - y * (x / y);
+    }
+
+    int idiv(int a, int b, float sign) {
+      int res = a / b;
+      int mod = imod(a, b);
+      if (sign < 0. && mod != 0) {
+        res -= 1;
+      }
+      return res;
+    }
+
+    //Based on the work of Dave Hoskins
+    //https://www.shadertoy.com/view/4djSRW
+    #define HASHSCALE1 443.8975
+    float random(float seed){
+      vec2 p = resultUV * seed;
+      vec3 p3  = fract(vec3(p.xyx) * HASHSCALE1);
+      p3 += dot(p3, p3.yzx + 19.19);
+      return fract((p3.x + p3.y) * p3.z);
+    }
+
+    ${Xe}
+    ${Ze}
+    ${Qe}
+  `;
+}
+var Xe = "\nvec2 uvFromFlat(int texNumR, int texNumC, int index) {\n  int texR = index / texNumC;\n  int texC = index - texR * texNumC;\n  return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n}\nvec2 packedUVfrom1D(int texNumR, int texNumC, int index) {\n  int texelIndex = index / 2;\n  int texR = texelIndex / texNumC;\n  int texC = texelIndex - texR * texNumC;\n  return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n}\n", Ze = "\nvec2 packedUVfrom2D(int texelsInLogicalRow, int texNumR,\n  int texNumC, int row, int col) {\n  int texelIndex = (row / 2) * texelsInLogicalRow + (col / 2);\n  int texR = texelIndex / texNumC;\n  int texC = texelIndex - texR * texNumC;\n  return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n}\n", Qe = "\nvec2 packedUVfrom3D(int texNumR, int texNumC,\n    int texelsInBatch, int texelsInLogicalRow, int b,\n    int row, int col) {\n  int index = b * texelsInBatch + (row / 2) * texelsInLogicalRow + (col / 2);\n  int texR = index / texNumC;\n  int texC = index - texR * texNumC;\n  return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);\n}\n", $e = "\n  float getChannel(vec4 frag, vec2 innerDims) {\n    vec2 modCoord = mod(innerDims, 2.);\n    return modCoord.x == 0. ?\n      (modCoord.y == 0. ? frag.r : frag.g) :\n      (modCoord.y == 0. ? frag.b : frag.a);\n  }\n  float getChannel(vec4 frag, int dim) {\n    float modCoord = mod(float(dim), 2.);\n    return modCoord == 0. ? frag.r : frag.g;\n  }\n";
+function W() {
+	return "\n    int getOutputCoords() {\n      return 0;\n    }\n  ";
+}
+function et(e, t, n) {
+	let r = [Math.ceil(t[0] / 2), Math.ceil(t[1] / 2)];
+	return r[0] === 1 ? n ? "\n      int getOutputCoords() {\n        return 2 * int(resultUV.x * ceil(float(outTexShape[1]) / 2.0));\n      }\n    " : `
+      int getOutputCoords() {
+        return 2 * int(resultUV.x * ${r[1]}.0);
+      }
+    ` : r[1] === 1 ? n ? "\n      int getOutputCoords() {\n        return 2 * int(resultUV.y * ceil(float(outTexShape[0]) / 2.0));\n      }\n    " : `
+      int getOutputCoords() {
+        return 2 * int(resultUV.y * ${r[0]}.0);
+      }
+    ` : n ? "\n    int getOutputCoords() {\n      ivec2 packedTexShape = ivec2(ceil(float(outTexShape[0]) / 2.0), ceil(float(outTexShape[1]) / 2.0));\n      ivec2 resTexRC = ivec2(resultUV.yx *\n                             vec2(packedTexShape[0], packedTexShape[1]));\n      return 2 * (resTexRC.x * packedTexShape[1] + resTexRC.y);\n    }\n  " : `
+    int getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${r[0]}, ${r[1]}));
+      return 2 * (resTexRC.x * ${r[1]} + resTexRC.y);
+    }
+  `;
+}
+function tt(e, t, n) {
+	return t[0] === 1 ? n ? "\n      int getOutputCoords() {\n        return int(resultUV.x * float(outTexShape[1]));\n      }\n    " : `
+      int getOutputCoords() {
+        return int(resultUV.x * ${t[1]}.0);
+      }
+    ` : t[1] === 1 ? n ? "\n      int getOutputCoords() {\n        return int(resultUV.y * float(outTexShape[0]));\n      }\n    " : `
+      int getOutputCoords() {
+        return int(resultUV.y * ${t[0]}.0);
+      }
+    ` : n ? "\n    int getOutputCoords() {\n      ivec2 resTexRC = ivec2(resultUV.yx *\n                             vec2(outTexShape[0], outTexShape[1]));\n      return resTexRC.x * outTexShape[1] + resTexRC.y;\n    }\n  " : `
+    int getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${t[0]}, ${t[1]}));
+      return resTexRC.x * ${t[1]} + resTexRC.y;
+    }
+  `;
+}
+function nt(e, t, n) {
+	if (n) return "\n    ivec3 getOutputCoords() {\n      ivec2 packedTexShape = ivec2(ceil(float(outTexShape[0]) / 2.0), ceil(float(outTexShape[1]) / 2.0));\n      int texelsInLogicalRow = int(ceil(float(outShape[2]) / 2.0));\n      int texelsInBatch = texelsInLogicalRow * int(ceil(float(outShape[1]) / 2.0));\n      ivec2 resTexRC = ivec2(resultUV.yx *\n                             vec2(packedTexShape[0], packedTexShape[1]));\n      int index = resTexRC.x * packedTexShape[1] + resTexRC.y;\n\n      int b = index / texelsInBatch;\n      index -= b * texelsInBatch;\n\n      int r = 2 * (index / texelsInLogicalRow);\n      int c = imod(index, texelsInLogicalRow) * 2;\n\n      return ivec3(b, r, c);\n    }\n  ";
+	let r = [Math.ceil(t[0] / 2), Math.ceil(t[1] / 2)], i = Math.ceil(e[2] / 2), a = i * Math.ceil(e[1] / 2);
+	return `
+    ivec3 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${r[0]}, ${r[1]}));
+      int index = resTexRC.x * ${r[1]} + resTexRC.y;
+
+      int b = index / ${a};
+      index -= b * ${a};
+
+      int r = 2 * (index / ${i});
+      int c = imod(index, ${i}) * 2;
+
+      return ivec3(b, r, c);
+    }
+  `;
+}
+function rt(e, t, n) {
+	if (n) return `
+  ivec3 getOutputCoords() {
+    ivec2 resTexRC = ivec2(resultUV.yx *
+                           vec2(outTexShape[0], outTexShape[1]));
+    int index = resTexRC.x * outTexShape[1] + resTexRC.y;
+    ${B([
+		"r",
+		"c",
+		"d"
+	], e)}
+    return ivec3(r, c, d);
+  }
+`;
+	let r = z([
+		"r",
+		"c",
+		"d"
+	], e);
+	return `
+    ivec3 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${t[0]}, ${t[1]}));
+      int index = resTexRC.x * ${t[1]} + resTexRC.y;
+      ${r}
+      return ivec3(r, c, d);
+    }
+  `;
+}
+function it(e, t, n) {
+	if (n) return "\n    ivec4 getOutputCoords() {\n      ivec2 packedTexShape = ivec2(ceil(float(outTexShape[0]) / 2.0), ceil(float(outTexShape[1]) / 2.0));\n      ivec2 resTexRC = ivec2(resultUV.yx *\n                             vec2(packedTexShape[0], packedTexShape[1]));\n      int index = resTexRC.x * packedTexShape[1] + resTexRC.y;\n\n      int texelsInLogicalRow = int(ceil(float(outShape[3]) / 2.0));\n      int texelsInBatch = texelsInLogicalRow * int(ceil(float(outShape[2]) / 2.0));\n      int texelsInBatchN = texelsInBatch * outShape[1];\n\n      int b2 = index / texelsInBatchN;\n      index -= b2 * texelsInBatchN;\n\n      int b = index / texelsInBatch;\n      index -= b * texelsInBatch;\n\n      int r = 2 * (index / texelsInLogicalRow);\n      int c = imod(index, texelsInLogicalRow) * 2;\n\n      return ivec4(b2, b, r, c);\n    }\n  ";
+	let r = [Math.ceil(t[0] / 2), Math.ceil(t[1] / 2)], i = Math.ceil(e[e.length - 1] / 2), a = i * Math.ceil(e[e.length - 2] / 2), o = a, s = "", c = "b, r, c";
+	for (let t = 2; t < e.length - 1; t++) o *= e[e.length - t - 1], s = `
+      int b${t} = index / ${o};
+      index -= b${t} * ${o};
+    ` + s, c = `b${t}, ` + c;
+	return `
+    ivec${e.length} getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${r[0]}, ${r[1]}));
+      int index = resTexRC.x * ${r[1]} + resTexRC.y;
+
+      ${s}
+
+      int b = index / ${a};
+      index -= b * ${a};
+
+      int r = 2 * (index / ${i});
+      int c = imod(index, ${i}) * 2;
+
+      return ivec${e.length}(${c});
+    }
+  `;
+}
+function at(e, t, n) {
+	if (n) return `
+    ivec4 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+        vec2(outTexShape[0], outTexShape[1]));
+      int index = resTexRC.x * outTexShape[1] + resTexRC.y;
+      ${B([
+		"r",
+		"c",
+		"d",
+		"d2"
+	], e)}
+      return ivec4(r, c, d, d2);
+    }
+  `;
+	let r = z([
+		"r",
+		"c",
+		"d",
+		"d2"
+	], e);
+	return `
+    ivec4 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+        vec2(${t[0]}, ${t[1]}));
+      int index = resTexRC.x * ${t[1]} + resTexRC.y;
+      ${r}
+      return ivec4(r, c, d, d2);
+    }
+  `;
+}
+function ot(e, t) {
+	let n = z([
+		"r",
+		"c",
+		"d",
+		"d2",
+		"d3"
+	], e);
+	return `
+    ivec5 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx * vec2(${t[0]},
+                             ${t[1]}));
+
+      int index = resTexRC.x * ${t[1]} + resTexRC.y;
+
+      ${n}
+
+      ivec5 outShape = ivec5(r, c, d, d2, d3);
+      return outShape;
+    }
+  `;
+}
+function st(e, t) {
+	let n = z([
+		"r",
+		"c",
+		"d",
+		"d2",
+		"d3",
+		"d4"
+	], e);
+	return `
+    ivec6 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+        vec2(${t[0]}, ${t[1]}));
+      int index = resTexRC.x * ${t[1]} + resTexRC.y;
+
+      ${n}
+
+      ivec6 result = ivec6(r, c, d, d2, d3, d4);
+      return result;
+    }
+  `;
+}
+function ct(e, t, r) {
+	let i = [Math.ceil(t[0] / 2), Math.ceil(t[1] / 2)];
+	if (n(e, t)) return r ? "\n      ivec2 getOutputCoords() {\n        ivec2 packedTexShape = ivec2(ceil(float(outTexShape[0]) / 2.0), ceil(float(outTexShape[1]) / 2.0));\n        return 2 * ivec2(resultUV.yx * vec2(packedTexShape[0], packedTexShape[1]));\n      }\n    " : `
+      ivec2 getOutputCoords() {
+        return 2 * ivec2(resultUV.yx * vec2(${i[0]}, ${i[1]}));
+      }
+    `;
+	let a = Math.ceil(e[1] / 2);
+	return r ? "\n    ivec2 getOutputCoords() {\n      ivec2 packedTexShape = ivec2(ceil(float(outTexShape[0]) / 2.0), ceil(float(outTexShape[1]) / 2.0));\n      int texelsInLogicalRow = int(ceil(float(outShape[1]) / 2.0));\n      ivec2 resTexRC = ivec2(resultUV.yx *\n                             vec2(packedTexShape[0], packedTexShape[1]));\n\n      int index = resTexRC.x * packedTexShape[1] + resTexRC.y;\n      int r = 2 * (index / texelsInLogicalRow);\n      int c = imod(index, texelsInLogicalRow) * 2;\n\n      return ivec2(r, c);\n    }\n  " : `
+    ivec2 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${i[0]}, ${i[1]}));
+
+      int index = resTexRC.x * ${i[1]} + resTexRC.y;
+      int r = 2 * (index / ${a});
+      int c = imod(index, ${a}) * 2;
+
+      return ivec2(r, c);
+    }
+  `;
+}
+function lt(e, t, r) {
+	return n(e, t) ? r ? "\n      ivec2 getOutputCoords() {\n        return ivec2(resultUV.yx * vec2(outTexShape[0], outTexShape[1]));\n      }\n    " : `
+      ivec2 getOutputCoords() {
+        return ivec2(resultUV.yx * vec2(${t[0]}, ${t[1]}));
+      }
+    ` : e[1] === 1 ? r ? "\n      ivec2 getOutputCoords() {\n        ivec2 resTexRC = ivec2(resultUV.yx *\n                               vec2(outTexShape[0], outTexShape[1]));\n        int index = resTexRC.x * outTexShape[1] + resTexRC.y;\n        return ivec2(index, 0);\n      }\n    " : `
+      ivec2 getOutputCoords() {
+        ivec2 resTexRC = ivec2(resultUV.yx *
+                               vec2(${t[0]}, ${t[1]}));
+        int index = resTexRC.x * ${t[1]} + resTexRC.y;
+        return ivec2(index, 0);
+      }
+    ` : e[0] === 1 ? r ? "\n      ivec2 getOutputCoords() {\n        ivec2 resTexRC = ivec2(resultUV.yx *\n                               vec2(outTexShape[0], outTexShape[1]));\n        int index = resTexRC.x * outTexShape[1] + resTexRC.y;\n        return ivec2(0, index);\n      }\n    " : `
+      ivec2 getOutputCoords() {
+        ivec2 resTexRC = ivec2(resultUV.yx *
+                               vec2(${t[0]}, ${t[1]}));
+        int index = resTexRC.x * ${t[1]} + resTexRC.y;
+        return ivec2(0, index);
+      }
+    ` : r ? "\n    ivec2 getOutputCoords() {\n      ivec2 resTexRC = ivec2(resultUV.yx *\n                             vec2(outTexShape[0], outTexShape[1]));\n      int index = resTexRC.x * outTexShape[1] + resTexRC.y;\n      int r = index / outShape[1];\n      int c = index - r * outShape[1];\n      return ivec2(r, c);\n    }\n  " : `
+    ivec2 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${t[0]}, ${t[1]}));
+      int index = resTexRC.x * ${t[1]} + resTexRC.y;
+      int r = index / ${e[1]};
+      int c = index - r * ${e[1]};
+      return ivec2(r, c);
+    }
+  `;
+}
+function G(e) {
+	return `offset${e}`;
+}
+function ut(e) {
+	let t = e.name;
+	return `
+    vec4 ${"get" + t.charAt(0).toUpperCase() + t.slice(1)}() {
+      return ${R().texture2D}(${t}, halfCR);
+    }
+  `;
+}
+function dt(e, t) {
+	let n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1);
+	if (e.shapeInfo.isUniform) return `float ${r}() {return ${n};}`;
+	let [i, a] = e.shapeInfo.texShape;
+	if (i === 1 && a === 1) return `
+      float ${r}() {
+        return sampleTexture(${n}, halfCR);
+      }
+    `;
+	let o = G(n);
+	if (t) return `
+    float ${r}() {
+      vec2 uv = uvFromFlat(${n}TexShape[0], ${n}TexShape[1], ${o});
+      return sampleTexture(${n}, uv);
+    }
+  `;
+	let [s, c] = e.shapeInfo.texShape;
+	return `
+    float ${r}() {
+      vec2 uv = uvFromFlat(${s}, ${c}, ${o});
+      return sampleTexture(${n}, uv);
+    }
+  `;
+}
+function ft(e, t) {
+	let n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1), i = e.shapeInfo.texShape, a = R();
+	if (t) return `
+    vec4 ${r}(int index) {
+      ivec2 packedTexShape = ivec2(ceil(float(${n}TexShape[0]) / 2.0), ceil(float(${n}TexShape[1]) / 2.0));
+      vec2 uv = packedUVfrom1D(
+        packedTexShape[0], packedTexShape[1], index);
+      return ${a.texture2D}(${n}, uv);
+    }
+  `;
+	let o = [Math.ceil(i[0] / 2), Math.ceil(i[1] / 2)];
+	return `
+    vec4 ${r}(int index) {
+      vec2 uv = packedUVfrom1D(
+        ${o[0]}, ${o[1]}, index);
+      return ${a.texture2D}(${n}, uv);
+    }
+  `;
+}
+function pt(e, t) {
+	let n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1);
+	if (e.shapeInfo.isUniform) return `
+      float ${r}(int index) {
+        ${q(e)}
+      }
+    `;
+	let i = e.shapeInfo.texShape, a = i[0], o = i[1];
+	if (o === 1 && a === 1) return `
+      float ${r}(int index) {
+        return sampleTexture(${n}, halfCR);
+      }
+    `;
+	let s = G(n);
+	return o === 1 ? t ? `
+      float ${r}(int index) {
+        vec2 uv = vec2(0.5, (float(index + ${s}) + 0.5) / float(${n}TexShape[0]));
+        return sampleTexture(${n}, uv);
+      }
+    ` : `
+      float ${r}(int index) {
+        vec2 uv = vec2(0.5, (float(index + ${s}) + 0.5) / ${a}.0);
+        return sampleTexture(${n}, uv);
+      }
+    ` : a === 1 ? t ? `
+      float ${r}(int index) {
+        vec2 uv = vec2((float(index + ${s}) + 0.5) / float(${n}TexShape[1]), 0.5);
+        return sampleTexture(${n}, uv);
+      }
+    ` : `
+      float ${r}(int index) {
+        vec2 uv = vec2((float(index + ${s}) + 0.5) / ${o}.0, 0.5);
+        return sampleTexture(${n}, uv);
+      }
+    ` : t ? `
+    float ${r}(int index) {
+      vec2 uv = uvFromFlat(${n}TexShape[0], ${n}TexShape[1], index + ${s});
+      return sampleTexture(${n}, uv);
+    }
+  ` : `
+    float ${r}(int index) {
+      vec2 uv = uvFromFlat(${a}, ${o}, index + ${s});
+      return sampleTexture(${n}, uv);
+    }
+  `;
+}
+function mt(e, t) {
+	let r = e.shapeInfo.logicalShape, i = e.name, a = "get" + i.charAt(0).toUpperCase() + i.slice(1), o = e.shapeInfo.texShape, s = o[0], c = o[1], l = R();
+	if (o != null && n(r, o)) return t ? `
+      vec4 ${a}(int row, int col) {
+        vec2 uv = (vec2(col, row) + halfCR) / vec2(${i}TexShape[1], ${i}TexShape[0]);
+
+        return ${l.texture2D}(${i}, uv);
+      }
+    ` : `
+      vec4 ${a}(int row, int col) {
+        vec2 uv = (vec2(col, row) + halfCR) / vec2(${c}.0, ${s}.0);
+
+        return ${l.texture2D}(${i}, uv);
+      }
+    `;
+	if (t) return `
+    vec4 ${a}(int row, int col) {
+      ivec2 packedTexShape = ivec2(ceil(float(${i}TexShape[0]) / 2.0), ceil(float(${i}TexShape[1]) / 2.0));
+      int valuesPerRow = int(ceil(float(${i}Shape[1]) / 2.0));
+      vec2 uv = packedUVfrom2D(valuesPerRow, packedTexShape[0], packedTexShape[1], row, col);
+      return ${l.texture2D}(${i}, uv);
+    }
+  `;
+	let u = [Math.ceil(o[0] / 2), Math.ceil(o[1] / 2)];
+	return `
+    vec4 ${a}(int row, int col) {
+      vec2 uv = packedUVfrom2D(${Math.ceil(r[1] / 2)}, ${u[0]}, ${u[1]}, row, col);
+      return ${l.texture2D}(${i}, uv);
+    }
+  `;
+}
+function ht(e, t) {
+	let r = e.shapeInfo.logicalShape, i = e.name, o = "get" + i.charAt(0).toUpperCase() + i.slice(1), s = e.shapeInfo.texShape;
+	if (s != null && n(r, s)) {
+		if (t) return `
+      float ${o}(int row, int col) {
+        vec2 uv = (vec2(col, row) + halfCR) / vec2(${i}TexShape[1], ${i}TexShape[0]);
+        return sampleTexture(${i}, uv);
+      }
+    `;
+		let e = s[0];
+		return `
+    float ${o}(int row, int col) {
+      vec2 uv = (vec2(col, row) + halfCR) / vec2(${s[1]}.0, ${e}.0);
+      return sampleTexture(${i}, uv);
+    }
+  `;
+	}
+	let { newShape: c, keptDims: l } = a(r), u = c;
+	if (u.length < r.length) return `
+      ${H(X(e, u), t)}
+      float ${o}(int row, int col) {
+        return ${o}(${Z(["row", "col"], l)});
+      }
+    `;
+	if (e.shapeInfo.isUniform) return `
+      float ${o}(int row, int col) {
+        int index = round(dot(vec2(row, col), vec2(${r[1]}, 1)));
+        ${q(e)}
+      }
+    `;
+	let d = s[0], f = s[1], p = G(i);
+	return f === 1 ? t ? `
+      float ${o}(int row, int col) {
+        float index = dot(vec3(row, col, ${p}), vec3(${i}Shape[1], 1, 1));
+        vec2 uv = vec2(0.5, (index + 0.5) / float(${i}TexShape[0]));
+        return sampleTexture(${i}, uv);
+      }
+    ` : `
+    float ${o}(int row, int col) {
+      float index = dot(vec3(row, col, ${p}), vec3(${r[1]}, 1, 1));
+      vec2 uv = vec2(0.5, (index + 0.5) / ${d}.0);
+      return sampleTexture(${i}, uv);
+    }
+  ` : d === 1 ? t ? `
+      float ${o}(int row, int col) {
+        float index = dot(vec3(row, col, ${p}), vec3(${i}Shape[1], 1, 1));
+        vec2 uv = vec2((index + 0.5) / float(${i}TexShape[1]), 0.5);
+        return sampleTexture(${i}, uv);
+      }
+    ` : `
+    float ${o}(int row, int col) {
+      float index = dot(vec3(row, col, ${p}), vec3(${r[1]}, 1, 1));
+      vec2 uv = vec2((index + 0.5) / ${f}.0, 0.5);
+      return sampleTexture(${i}, uv);
+    }
+  ` : t ? `
+      float ${o}(int row, int col) {
+        // Explicitly use integer operations as dot() only works on floats.
+        int index = row * ${i}Shape[1] + col + ${p};
+        vec2 uv = uvFromFlat(${i}TexShape[0], ${i}TexShape[1], index);
+        return sampleTexture(${i}, uv);
+      }
+    ` : `
+  float ${o}(int row, int col) {
+    // Explicitly use integer operations as dot() only works on floats.
+    int index = row * ${r[1]} + col + ${p};
+    vec2 uv = uvFromFlat(${d}, ${f}, index);
+    return sampleTexture(${i}, uv);
+  }
+`;
+}
+function gt(e, t) {
+	let n = e.shapeInfo.logicalShape, r = e.name, i = "get" + r.charAt(0).toUpperCase() + r.slice(1), a = e.shapeInfo.texShape, o = [Math.ceil(a[0] / 2), Math.ceil(a[1] / 2)];
+	if (n[0] === 1) return `
+        ${U(X(e, n.slice(1)), t)}
+        vec4 ${i}(int b, int row, int col) {
+          return ${i}(${Z([
+		"b",
+		"row",
+		"col"
+	], [1, 2])});
+        }
+      `;
+	let s = R();
+	if (t) return `
+    vec4 ${i}(int b, int row, int col) {
+      ivec2 packedTexShape = ivec2(ceil(float(${r}TexShape[0]) / 2.0), ceil(float(${r}TexShape[1]) / 2.0));
+      int valuesPerRow = int(ceil(float(${r}Shape[2]) / 2.0));
+      int texelsInBatch = valuesPerRow * int(ceil(float(${r}Shape[1]) / 2.0));
+      vec2 uv = packedUVfrom3D(
+        packedTexShape[0], packedTexShape[1], texelsInBatch, valuesPerRow, b, row, col);
+      return ${s.texture2D}(${r}, uv);
+    }
+  `;
+	let c = o[0], l = o[1], u = Math.ceil(n[2] / 2);
+	return `
+    vec4 ${i}(int b, int row, int col) {
+      vec2 uv = packedUVfrom3D(
+        ${c}, ${l}, ${u * Math.ceil(n[1] / 2)}, ${u}, b, row, col);
+      return ${s.texture2D}(${r}, uv);
+    }
+  `;
+}
+function _t(e, t) {
+	let n = e.shapeInfo.logicalShape, r = e.name, i = "get" + r.charAt(0).toUpperCase() + r.slice(1), o = n[1] * n[2], s = n[2], { newShape: c, keptDims: l } = a(n), u = c;
+	if (u.length < n.length) return `
+        ${H(X(e, u), t)}
+        float ${i}(int row, int col, int depth) {
+          return ${i}(${Z([
+		"row",
+		"col",
+		"depth"
+	], l)});
+        }
+      `;
+	if (e.shapeInfo.isUniform) return `
+      float ${i}(int row, int col, int depth) {
+        int index = round(dot(vec3(row, col, depth),
+                          vec3(${o}, ${s}, 1)));
+        ${q(e)}
+      }
+    `;
+	let d = e.shapeInfo.texShape, f = d[0], p = d[1], m = e.shapeInfo.flatOffset;
+	if (p === o && m == null) return t ? `
+      float ${i}(int row, int col, int depth) {
+        int stride1 = ${r}Shape[2];
+        float texR = float(row);
+        float texC = dot(vec2(col, depth), vec2(stride1, 1));
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${r}TexShape[1], ${r}TexShape[0]);
+        return sampleTexture(${r}, uv);
+      }
+    ` : `
+        float ${i}(int row, int col, int depth) {
+          float texR = float(row);
+          float texC = dot(vec2(col, depth), vec2(${s}, 1));
+          vec2 uv = (vec2(texC, texR) + halfCR) /
+                     vec2(${p}.0, ${f}.0);
+          return sampleTexture(${r}, uv);
+        }
+      `;
+	if (p === s && m == null) return t ? `
+      float ${i}(int row, int col, int depth) {
+        float texR = dot(vec2(row, col), vec2(${r}Shape[1], 1));
+        float texC = float(depth);
+        vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${r}TexShape[1], ${r}TexShape[0]);
+        return sampleTexture(${r}, uv);
+      }
+    ` : `
+    float ${i}(int row, int col, int depth) {
+      float texR = dot(vec2(row, col), vec2(${n[1]}, 1));
+      float texC = float(depth);
+      vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${p}.0, ${f}.0);
+      return sampleTexture(${r}, uv);
+    }
+  `;
+	let h = G(r);
+	return t ? `
+    float ${i}(int row, int col, int depth) {
+      // Explicitly use integer operations as dot() only works on floats.
+      int stride0 = ${r}Shape[1] * ${r}Shape[2];
+      int stride1 = ${r}Shape[2];
+      int index = row * stride0 + col * stride1 + depth + ${h};
+      vec2 uv = uvFromFlat(${r}TexShape[0], ${r}TexShape[1], index);
+      return sampleTexture(${r}, uv);
+    }
+    ` : `
+      float ${i}(int row, int col, int depth) {
+        // Explicitly use integer operations as dot() only works on floats.
+        int index = row * ${o} + col * ${s} + depth + ${h};
+        vec2 uv = uvFromFlat(${f}, ${p}, index);
+        return sampleTexture(${r}, uv);
+      }
+  `;
+}
+function vt(e, t) {
+	let n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1), i = R();
+	if (t) return `
+    vec4 ${r}(int b2, int b, int row, int col) {
+      int valuesPerRow = int(ceil(float(${n}Shape[3]) / 2.0));
+      int texelsInBatch = valuesPerRow * int(ceil(float(${n}Shape[2]) / 2.0));
+      int index = b * texelsInBatch + (row / 2) * valuesPerRow + (col / 2);
+      texelsInBatch *= ${n}Shape[1];
+      index = b2 * texelsInBatch + index;
+      ivec2 packedTexShape = ivec2(ceil(float(${n}TexShape[0]) / 2.0), ceil(float(${n}TexShape[1]) / 2.0));
+      int texR = index / packedTexShape[1];
+      int texC = index - texR * packedTexShape[1];
+      vec2 uv = (vec2(texC, texR) + halfCR) / vec2(packedTexShape[1], packedTexShape[0]); return ${i.texture2D}(${n}, uv);
+    }
+  `;
+	let a = e.shapeInfo.logicalShape, o = a.length, s = e.shapeInfo.texShape, c = [Math.ceil(s[0] / 2), Math.ceil(s[1] / 2)], l = c[0], u = c[1], d = Math.ceil(a[o - 1] / 2), f = d * Math.ceil(a[o - 2] / 2), p = "int b, int row, int col", m = `b * ${f} + (row / 2) * ${d} + (col / 2)`;
+	for (let e = 2; e < o - 1; e++) p = `int b${e}, ` + p, f *= a[o - e - 1], m = `b${e} * ${f} + ` + m;
+	return `
+    vec4 ${r}(${p}) {
+      int index = ${m};
+      int texR = index / ${u};
+      int texC = index - texR * ${u};
+      vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${u}, ${l});
+      return ${i.texture2D}(${n}, uv);
+    }
+  `;
+}
+function yt(e, t) {
+	let n = e.shapeInfo.logicalShape, r = e.name, i = "get" + r.charAt(0).toUpperCase() + r.slice(1), o = n[3], s = n[2] * o, c = n[1] * s, { newShape: l, keptDims: u } = a(n);
+	if (l.length < n.length) return `
+      ${H(X(e, l), t)}
+      float ${i}(int row, int col, int depth, int depth2) {
+        return ${i}(${Z([
+		"row",
+		"col",
+		"depth",
+		"depth2"
+	], u)});
+      }
+    `;
+	if (e.shapeInfo.isUniform) return `
+      float ${i}(int row, int col, int depth, int depth2) {
+        int index = round(dot(vec4(row, col, depth, depth2),
+                          vec4(${c}, ${s}, ${o}, 1)));
+        ${q(e)}
+      }
+    `;
+	let d = e.shapeInfo.flatOffset, f = e.shapeInfo.texShape, p = f[0], m = f[1], h = `int stride2 = ${r}Shape[3];`, g = `int stride1 = ${r}Shape[2] * stride2;`, _ = `int stride0 = ${r}Shape[1] * stride1;`;
+	if (m === c && d == null) return t ? `
+      float ${i}(int row, int col, int depth, int depth2) {
+        ${h}
+        ${g}
+        float texR = float(row);
+        float texC =
+            dot(vec3(col, depth, depth2),
+                vec3(stride1, stride2, 1));
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${r}TexShape[1], ${r}TexShape[0]);
+        return sampleTexture(${r}, uv);
+      }
+    ` : `
+      float ${i}(int row, int col, int depth, int depth2) {
+        float texR = float(row);
+        float texC =
+            dot(vec3(col, depth, depth2),
+                vec3(${s}, ${o}, 1));
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${m}.0, ${p}.0);
+        return sampleTexture(${r}, uv);
+      }
+    `;
+	if (m === o && d == null) return t ? `
+      float ${i}(int row, int col, int depth, int depth2) {
+        float texR = dot(vec3(row, col, depth),
+                         vec3(${r}Shape[1] * ${r}Shape[2], ${r}Shape[2], 1));
+        float texC = float(depth2);
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                  vec2(${r}TexShape[1], ${r}TexShape[0]);
+        return sampleTexture(${r}, uv);
+      }
+    ` : `
+      float ${i}(int row, int col, int depth, int depth2) {
+        float texR = dot(vec3(row, col, depth),
+                         vec3(${n[1] * n[2]}, ${n[2]}, 1));
+        float texC = float(depth2);
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                  vec2(${m}.0, ${p}.0);
+        return sampleTexture(${r}, uv);
+      }
+    `;
+	let v = G(r);
+	return t ? `
+    float ${i}(int row, int col, int depth, int depth2) {
+      // Explicitly use integer operations as dot() only works on floats.
+      ${h}
+      ${g}
+      ${_}
+      int index = row * stride0 + col * stride1 +
+          depth * stride2 + depth2;
+      vec2 uv = uvFromFlat(${r}TexShape[0], ${r}TexShape[1], index + ${v});
+      return sampleTexture(${r}, uv);
+    }
+  ` : `
+    float ${i}(int row, int col, int depth, int depth2) {
+      // Explicitly use integer operations as dot() only works on floats.
+      int index = row * ${c} + col * ${s} +
+          depth * ${o} + depth2;
+      vec2 uv = uvFromFlat(${p}, ${m}, index + ${v});
+      return sampleTexture(${r}, uv);
+    }
+  `;
+}
+function K(e) {
+	let t = e.shapeInfo.logicalShape, n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1), i = t[4], o = t[3] * i, s = t[2] * o, c = t[1] * s, { newShape: l, keptDims: u } = a(t);
+	if (l.length < t.length) return `
+      ${H(X(e, l))}
+      float ${r}(int row, int col, int depth, int depth2, int depth3) {
+        return ${r}(${Z([
+		"row",
+		"col",
+		"depth",
+		"depth2",
+		"depth3"
+	], u)});
+      }
+    `;
+	if (e.shapeInfo.isUniform) return `
+      float ${r}(int row, int col, int depth, int depth2, int depth3) {
+        float index = dot(
+          vec4(row, col, depth, depth2),
+          vec4(${c}, ${s}, ${o}, ${i})) +
+          depth3;
+        ${q(e)}
+      }
+    `;
+	let d = e.shapeInfo.flatOffset, f = e.shapeInfo.texShape, p = f[0], m = f[1];
+	return m === c && d == null ? `
+      float ${r}(int row, int col, int depth, int depth2, int depth3) {
+        int texR = row;
+        float texC = dot(vec4(col, depth, depth2, depth3),
+                         vec4(${s}, ${o}, ${i}, 1));
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${m}.0, ${p}.0);
+        return sampleTexture(${n}, uv);
+      }
+    ` : m === i && d == null ? `
+      float ${r}(int row, int col, int depth, int depth2, int depth3) {
+        float texR = dot(
+          vec4(row, col, depth, depth2),
+          vec4(${t[1] * t[2] * t[3]},
+               ${t[2] * t[3]}, ${t[3]}, 1));
+        int texC = depth3;
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                  vec2(${m}.0, ${p}.0);
+        return sampleTexture(${n}, uv);
+      }
+    ` : `
+    float ${r}(int row, int col, int depth, int depth2, int depth3) {
+      // Explicitly use integer operations as dot() only works on floats.
+      int index = row * ${c} + col * ${s} + depth * ${o} +
+          depth2 * ${i} + depth3 + ${G(n)};
+      vec2 uv = uvFromFlat(${p}, ${m}, index);
+      return sampleTexture(${n}, uv);
+    }
+  `;
+}
+function bt(e) {
+	let t = e.shapeInfo.logicalShape, n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1), { newShape: i, keptDims: o } = a(t);
+	if (i.length < t.length) return `
+      ${H(X(e, i))}
+      float ${r}(int row, int col, int depth,
+                    int depth2, int depth3, int depth4) {
+        return ${r}(${Z([
+		"row",
+		"col",
+		"depth",
+		"depth2",
+		"depth3",
+		"depth4"
+	], o)});
+      }
+    `;
+	let s = t[5], c = t[4] * s, l = t[3] * c, u = t[2] * l, d = t[1] * u;
+	if (e.shapeInfo.isUniform) return `
+      float ${r}(int row, int col, int depth,
+                  int depth2, int depth3, int depth4) {
+        int index = round(dot(
+          vec4(row, col, depth, depth2),
+          vec4(${d}, ${u}, ${l}, ${c})) +
+          dot(
+            vec2(depth3, depth4),
+            vec2(${s}, 1)));
+        ${q(e)}
+      }
+    `;
+	let f = e.shapeInfo.flatOffset, p = e.shapeInfo.texShape, m = p[0], h = p[1];
+	return h === d && f == null ? `
+      float ${r}(int row, int col, int depth,
+                    int depth2, int depth3, int depth4) {
+        int texR = row;
+        float texC = dot(vec4(col, depth, depth2, depth3),
+          vec4(${u}, ${l}, ${c}, ${s})) +
+               float(depth4);
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${h}.0, ${m}.0);
+        return sampleTexture(${n}, uv);
+      }
+    ` : h === s && f == null ? `
+      float ${r}(int row, int col, int depth,
+                    int depth2, int depth3, int depth4) {
+        float texR = dot(vec4(row, col, depth, depth2),
+          vec4(${t[1] * t[2] * t[3] * t[4]},
+               ${t[2] * t[3] * t[4]},
+               ${t[3] * t[4]},
+               ${t[4]})) + float(depth3);
+        int texC = depth4;
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                  vec2(${h}.0, ${m}.0);
+        return sampleTexture(${n}, uv);
+      }
+    ` : `
+    float ${r}(int row, int col, int depth,
+                  int depth2, int depth3, int depth4) {
+      // Explicitly use integer operations as dot() only works on floats.
+      int index = row * ${d} + col * ${u} + depth * ${l} +
+          depth2 * ${c} + depth3 * ${s} + depth4 + ${G(n)};
+      vec2 uv = uvFromFlat(${m}, ${h}, index);
+      return sampleTexture(${n}, uv);
+    }
+  `;
+}
+function q(e) {
+	let t = e.name, n = s(e.shapeInfo.logicalShape);
+	return n < 2 ? `return ${t};` : `
+    for (int i = 0; i < ${n}; i++) {
+      if (i == index) {
+        return ${t}[i];
+      }
+    }
+  `;
+}
+function xt(e, t) {
+	let n = e.name, r = n.charAt(0).toUpperCase() + n.slice(1), i = "get" + r + "AtOutCoords", a = e.shapeInfo.logicalShape.length, o = t.logicalShape.length, c = V(e.shapeInfo.logicalShape, t.logicalShape), l = J(o), u = o - a, d, f = [
+		"x",
+		"y",
+		"z",
+		"w",
+		"u",
+		"v"
+	];
+	d = a === 0 ? "" : o < 2 && c.length >= 1 ? "coords = 0;" : c.map((e) => `coords.${f[e + u]} = 0;`).join("\n");
+	let p = "";
+	p = o < 2 && a > 0 ? "coords" : e.shapeInfo.logicalShape.map((e, t) => `coords.${f[t + u]}`).join(", ");
+	let m = "return outputValue;", h = s(e.shapeInfo.logicalShape) === 1, g = s(t.logicalShape) === 1;
+	if (a === 1 && !h && !g) m = "\n      return vec4(outputValue.xy, outputValue.xy);\n    ";
+	else if (h && !g) m = o === 1 ? "\n        return vec4(outputValue.x, outputValue.x, 0., 0.);\n      " : "\n        return vec4(outputValue.x);\n      ";
+	else if (c.length) {
+		let e = a - 2, t = a - 1;
+		c.indexOf(e) > -1 && c.indexOf(t) > -1 ? m = "return vec4(outputValue.x);" : c.indexOf(e) > -1 ? m = "return vec4(outputValue.x, outputValue.y, outputValue.x, outputValue.y);" : c.indexOf(t) > -1 && (m = "return vec4(outputValue.xx, outputValue.zz);");
+	}
+	return `
+    vec4 ${i}() {
+      ${l} coords = getOutputCoords();
+      ${d}
+      vec4 outputValue = get${r}(${p});
+      ${m}
+    }
+  `;
+}
+function St(e, t) {
+	let r = e.name, i = r.charAt(0).toUpperCase() + r.slice(1), a = "get" + i + "AtOutCoords", o = t.texShape, s = e.shapeInfo.texShape, c = e.shapeInfo.logicalShape.length, l = t.logicalShape.length;
+	if (!e.shapeInfo.isUniform && c === l && e.shapeInfo.flatOffset == null && n(s, o)) return `
+      float ${a}() {
+        return sampleTexture(${r}, resultUV);
+      }
+    `;
+	let u = J(l), d = V(e.shapeInfo.logicalShape, t.logicalShape), f = l - c, p, m = [
+		"x",
+		"y",
+		"z",
+		"w",
+		"u",
+		"v"
+	];
+	p = c === 0 ? "" : l < 2 && d.length >= 1 ? "coords = 0;" : d.map((e) => `coords.${m[e + f]} = 0;`).join("\n");
+	let h = "";
+	return h = l < 2 && c > 0 ? "coords" : e.shapeInfo.logicalShape.map((e, t) => `coords.${m[t + f]}`).join(", "), `
+    float ${a}() {
+      ${u} coords = getOutputCoords();
+      ${p}
+      return get${i}(${h});
+    }
+  `;
+}
+function J(e) {
+	if (e <= 1) return "int";
+	if (e === 2) return "ivec2";
+	if (e === 3) return "ivec3";
+	if (e === 4) return "ivec4";
+	if (e === 5) return "ivec5";
+	if (e === 6) return "ivec6";
+	throw Error(`GPU for rank ${e} is not yet supported`);
+}
+function Y(e, t, r) {
+	let { newShape: i, keptDims: o } = a(t), s = t.length, c = e && s === 3 && t[0] === 1, l = c ? t.slice(1) : i, u = !e && s > 1 && !n(t, r) && i.length < s || c;
+	return {
+		useSqueezeShape: u,
+		uniformShape: u ? l : t,
+		keptDims: o
+	};
+}
+function X(e, t) {
+	let n = JSON.parse(JSON.stringify(e));
+	return n.shapeInfo.logicalShape = t, n;
+}
+function Z(e, t) {
+	return t.map((t) => e[t]).join(", ");
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/gpgpu_math.js
+function Ct(e, n, r, i) {
+	let a = r.map((e, t) => {
+		let r = {
+			logicalShape: e.shape,
+			texShape: e.isUniform ? null : e.texData.texShape,
+			isUniform: e.isUniform,
+			isPacked: e.isUniform ? !1 : e.texData.isPacked,
+			flatOffset: null
+		};
+		return e.texData != null && e.texData.slice != null && e.texData.slice.flatOffset > 0 && (r.flatOffset = e.texData.slice.flatOffset), {
+			name: n.variableNames[t],
+			shapeInfo: r
+		};
+	}), o = a.map((e) => e.shapeInfo), s = {
+		logicalShape: i.shape,
+		texShape: i.texData.texShape,
+		isUniform: !1,
+		isPacked: i.texData.isPacked,
+		flatOffset: null
+	}, c = He(a, s, n), l = ce(e.gl, c), u = e.createProgram(l);
+	return t().get("ENGINE_COMPILE_ONLY") ? {
+		program: n,
+		fragmentShader: l,
+		source: c,
+		webGLProgram: u,
+		inShapeInfos: o,
+		outShapeInfo: s,
+		variablesLocations: null,
+		customUniformLocations: null,
+		infLoc: null,
+		nanLoc: null,
+		outShapeLocation: null,
+		outShapeStridesLocation: null,
+		outTexShapeLocation: null
+	} : (e.buildVao(u), Object.assign({
+		program: n,
+		fragmentShader: l,
+		source: c,
+		webGLProgram: u,
+		inShapeInfos: o,
+		outShapeInfo: s
+	}, Q(e, n, u)));
+}
+function Q(e, n, r) {
+	let i = [], a = [], o, s, c, l = null, u = null;
+	u = e.getUniformLocation(r, "NAN", !1), t().getNumber("WEBGL_VERSION") === 1 && (l = e.getUniformLocation(r, "INFINITY", !1));
+	for (let t of n.variableNames) {
+		let a = {
+			name: t,
+			uniform: e.getUniformLocation(r, t, !1),
+			offset: e.getUniformLocation(r, `offset${t}`, !1)
+		};
+		n.enableShapeUniforms && (a.shape = e.getUniformLocation(r, `${t}Shape`, !1), a.texShape = e.getUniformLocation(r, `${t}TexShape`, !1)), i.push(a);
+	}
+	if (n.enableShapeUniforms && (o = e.getUniformLocation(r, "outShape", !1), c = e.getUniformLocation(r, "outShapeStrides", !1), s = e.getUniformLocation(r, "outTexShape", !1)), n.customUniforms) for (let t of n.customUniforms) a.push(e.getUniformLocation(r, t.name, !1));
+	return {
+		variablesLocations: i,
+		customUniformLocations: a,
+		infLoc: l,
+		nanLoc: u,
+		outShapeLocation: o,
+		outShapeStridesLocation: c,
+		outTexShapeLocation: s
+	};
+}
+function $(e, t) {
+	if (e.length !== t.length) throw Error(`Binary was compiled with ${e.length} inputs, but was executed with ${t.length} inputs`);
+	e.forEach((e, r) => {
+		let i = e.logicalShape, a = t[r], o = a.shape;
+		if (!n(i, o)) throw Error(`Binary was compiled with different shapes than the current args. Shapes ${i} and ${o} must match`);
+		if (e.isUniform && a.isUniform) return;
+		let s = e.texShape, c = a.isUniform ? null : a.texData.texShape;
+		if (!n(s, c)) throw Error(`Binary was compiled with different texture shapes than the current args. Shape ${s} and ${c} must match`);
+	});
+}
+function wt(e, n, r, a, o) {
+	n.program.enableShapeUniforms || ($(n.inShapeInfos, r), $([n.outShapeInfo], [a]));
+	let c = a.texData.texture, l = a.texData.texShape;
+	a.texData.isPacked ? e.setOutputPackedMatrixTexture(c.texture, l[0], l[1]) : e.setOutputMatrixTexture(c.texture, l[0], l[1]), e.setProgram(n.webGLProgram), e.bindVertexArray(n.webGLProgram.vao), t().getNumber("WEBGL_VERSION") === 1 && n.infLoc !== null && e.gl.uniform1f(n.infLoc, Infinity), n.nanLoc !== null && e.gl.uniform1f(n.nanLoc, NaN);
+	for (let t = 0; t < r.length; ++t) {
+		let i = r[t], { uniform: a, offset: o, shape: c, texShape: l } = n.variablesLocations[t];
+		if (c) {
+			let { uniformShape: t } = Y(n.program.packedInputs, i.shape, i.texData.texShape);
+			switch (t.length) {
+				case 1:
+					e.gl.uniform1iv(c, new Int32Array(t));
+					break;
+				case 2:
+					e.gl.uniform2iv(c, new Int32Array(t));
+					break;
+				case 3:
+					e.gl.uniform3iv(c, new Int32Array(t));
+					break;
+				case 4:
+					e.gl.uniform4iv(c, new Int32Array(t));
+					break;
+				default: break;
+			}
+		}
+		if (l && e.gl.uniform2i(l, i.texData.texShape[0], i.texData.texShape[1]), a != null) {
+			if (i.isUniform) {
+				if (s(i.shape) < 2) e.gl.uniform1f(a, i.uniformValues[0]);
+				else {
+					let t = i.uniformValues;
+					t instanceof Float32Array || (t = new Float32Array(t)), e.gl.uniform1fv(a, t);
+				}
+				continue;
+			}
+			i.texData.slice != null && o != null && e.gl.uniform1i(o, i.texData.slice.flatOffset), e.setInputMatrixTexture(i.texData.texture.texture, a, t);
+		}
+	}
+	let u = n.outShapeLocation;
+	if (u) switch (a.shape.length) {
+		case 1:
+			e.gl.uniform1iv(u, new Int32Array(a.shape));
+			break;
+		case 2:
+			e.gl.uniform2iv(u, new Int32Array(a.shape));
+			break;
+		case 3:
+			e.gl.uniform3iv(u, new Int32Array(a.shape));
+			break;
+		case 4:
+			e.gl.uniform4iv(u, new Int32Array(a.shape));
+			break;
+		default: break;
+	}
+	if (n.outShapeStridesLocation) {
+		let t = i(a.shape);
+		switch (a.shape.length) {
+			case 2:
+				e.gl.uniform1iv(n.outShapeStridesLocation, new Int32Array(t));
+				break;
+			case 3:
+				e.gl.uniform2iv(n.outShapeStridesLocation, new Int32Array(t));
+				break;
+			case 4:
+				e.gl.uniform3iv(n.outShapeStridesLocation, new Int32Array(t));
+				break;
+			default: break;
+		}
+	}
+	if (n.outTexShapeLocation && e.gl.uniform2i(n.outTexShapeLocation, a.texData.texShape[0], a.texData.texShape[1]), n.program.customUniforms && o) for (let t = 0; t < n.program.customUniforms.length; ++t) {
+		let r = n.program.customUniforms[t], i = n.customUniformLocations[t], a = o[t];
+		if (r.type === "float") e.gl.uniform1fv(i, a);
+		else if (r.type === "vec2") e.gl.uniform2fv(i, a);
+		else if (r.type === "vec3") e.gl.uniform3fv(i, a);
+		else if (r.type === "vec4") e.gl.uniform4fv(i, a);
+		else if (r.type === "int") e.gl.uniform1iv(i, a);
+		else if (r.type === "ivec2") e.gl.uniform2iv(i, a);
+		else if (r.type === "ivec3") e.gl.uniform3iv(i, a);
+		else if (r.type === "ivec4") e.gl.uniform4iv(i, a);
+		else throw Error(`uniform type ${r.type} is not supported yet.`);
+	}
+	e.executeProgram();
+}
+function Tt(r, a, o) {
+	let c = "";
+	a.concat(o).forEach((t) => {
+		let a = t.texData != null && t.texData.slice != null && t.texData.slice.flatOffset > 0;
+		if (r.enableShapeUniforms && !t.isUniform) {
+			let l = t.texData.texShape, { useSqueezeShape: u, uniformShape: d, keptDims: f } = Y(r.packedInputs, t.shape, l), p = "", m = "", h = "";
+			if (d.length === 1 && r.packedInputs) {
+				let e = [Math.ceil(l[0] / 2), Math.ceil(l[1] / 2)];
+				p = `${e[0] > 1}_${e[1] > 1}`;
+			} else if (d.length === 2 && !r.packedInputs) m = `${d[0] > 1}_${d[1] > 1}`;
+			else if (d.length > 2 && !r.packedInputs) {
+				let e = i(d);
+				h = `${e[0] === l[1]}_${e[e.length - 1] === l[1]}`;
+			}
+			let g = t.shape.length, _ = d.length === 2 && n(t.shape, l), v = s(t.shape) === 1, y = e(t.shape, o.shape), b = !r.packedInputs && g === o.shape.length && n(l, o.texData.texShape), x = r.packedInputs || d.length > 2 ? "" : `${l[0] > 1}_${l[1] > 1}`;
+			c += `${g}_${b}_${u ? f : ""}_${d.length}_${v}_${y}_${_}_${p}_${m}_${h}_${x}_${a}`;
+		} else {
+			let e = t.isUniform ? "uniform" : t.texData.texShape;
+			c += `${t.shape}_${e}_${a}`;
+		}
+	});
+	let l = r.userCode, u = r.constructor.name;
+	return u += "_" + c + "_" + l + `${t().getNumber("WEBGL_VERSION")}`, u;
+}
+function Et(e) {
+	return t().getBool("WEBGL_USE_SHAPES_UNIFORMS") && e <= 4;
+}
+//#endregion
+export { C as $, be as A, Fe as B, pe as C, oe as D, j as E, Oe as F, O as G, de as H, I, _ as J, fe as K, Me as L, Te as M, Ee as N, ke as O, Ae as P, S as Q, Ne as R, me as S, se as T, E as U, je as V, D as W, v as X, y as Y, ee as Z, ve as _, Et as a, _e as b, ze as c, Re as d, w as et, B as f, Se as g, Ce as h, wt as i, p as it, M as j, xe as k, Be as l, Ie as m, Q as n, b as nt, J as o, R as p, ge as q, Tt as r, m as rt, Ve as s, Ct as t, x as tt, z as u, T as v, he as w, ue as x, ie as y, De as z };