@genai-fi/nanogpt 0.3.2 → 0.4.1

package/dist/ops/webgl/fusedSoftmax.js

@@ -0,0 +1,3930 @@
+import { aW as Jt, n as y, aX as Qt, aY as ut, aj as It, aZ as K, a_ as nt, a$ as Ot, b0 as xt, b1 as gt, b2 as te, W as ot, ao as Z, b3 as W, b4 as ee, b5 as pt, j as zt, t as ne, b6 as mt, b7 as tt, Y as ht, b8 as oe, aI as se, ab as St, b9 as re, ba as ie, r as ae } from "../../index-XjBAhiFO.js";
+import { c as bt, g as Wt, a as kt, b as Ut, e as vt } from "../../axis_util-DeydwOoC.js";
+import { b as ue, i as le, c as ce } from "../../slice_util-CnVNPQI-.js";
+import { r as he } from "../../reshape-DFzh97Sc.js";
+import { g as fe } from "../../_commonjsHelpers-ByX85dGu.js";
+function de(t, e) {
+  for (var n = 0; n < e.length; n++) {
+    const o = e[n];
+    if (typeof o != "string" && !Array.isArray(o)) {
+      for (const s in o)
+        if (s !== "default" && !(s in t)) {
+          const r = Object.getOwnPropertyDescriptor(o, s);
+          r && Object.defineProperty(t, s, r.get ? r : {
+            enumerable: !0,
+            get: () => o[s]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var dt, yt;
+function ge() {
+  if (yt) return dt;
+  yt = 1, dt = e;
+  var t = null;
+  try {
+    t = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([
+      0,
+      97,
+      115,
+      109,
+      1,
+      0,
+      0,
+      0,
+      1,
+      13,
+      2,
+      96,
+      0,
+      1,
+      127,
+      96,
+      4,
+      127,
+      127,
+      127,
+      127,
+      1,
+      127,
+      3,
+      7,
+      6,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      6,
+      6,
+      1,
+      127,
+      1,
+      65,
+      0,
+      11,
+      7,
+      50,
+      6,
+      3,
+      109,
+      117,
+      108,
+      0,
+      1,
+      5,
+      100,
+      105,
+      118,
+      95,
+      115,
+      0,
+      2,
+      5,
+      100,
+      105,
+      118,
+      95,
+      117,
+      0,
+      3,
+      5,
+      114,
+      101,
+      109,
+      95,
+      115,
+      0,
+      4,
+      5,
+      114,
+      101,
+      109,
+      95,
+      117,
+      0,
+      5,
+      8,
+      103,
+      101,
+      116,
+      95,
+      104,
+      105,
+      103,
+      104,
+      0,
+      0,
+      10,
+      191,
+      1,
+      6,
+      4,
+      0,
+      35,
+      0,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      126,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      127,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      128,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      129,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      130,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11
+    ])), {}).exports;
+  } catch {
+  }
+  function e(x, l, v) {
+    this.low = x | 0, this.high = l | 0, this.unsigned = !!v;
+  }
+  e.prototype.__isLong__, Object.defineProperty(e.prototype, "__isLong__", { value: !0 });
+  function n(x) {
+    return (x && x.__isLong__) === !0;
+  }
+  e.isLong = n;
+  var o = {}, s = {};
+  function r(x, l) {
+    var v, O, V;
+    return l ? (x >>>= 0, (V = 0 <= x && x < 256) && (O = s[x], O) ? O : (v = a(x, (x | 0) < 0 ? -1 : 0, !0), V && (s[x] = v), v)) : (x |= 0, (V = -128 <= x && x < 128) && (O = o[x], O) ? O : (v = a(x, x < 0 ? -1 : 0, !1), V && (o[x] = v), v));
+  }
+  e.fromInt = r;
+  function i(x, l) {
+    if (isNaN(x))
+      return l ? I : g;
+    if (l) {
+      if (x < 0)
+        return I;
+      if (x >= m)
+        return A;
+    } else {
+      if (x <= -b)
+        return L;
+      if (x + 1 >= b)
+        return M;
+    }
+    return x < 0 ? i(-x, l).neg() : a(x % p | 0, x / p | 0, l);
+  }
+  e.fromNumber = i;
+  function a(x, l, v) {
+    return new e(x, l, v);
+  }
+  e.fromBits = a;
+  var u = Math.pow;
+  function c(x, l, v) {
+    if (x.length === 0)
+      throw Error("empty string");
+    if (x === "NaN" || x === "Infinity" || x === "+Infinity" || x === "-Infinity")
+      return g;
+    if (typeof l == "number" ? (v = l, l = !1) : l = !!l, v = v || 10, v < 2 || 36 < v)
+      throw RangeError("radix");
+    var O;
+    if ((O = x.indexOf("-")) > 0)
+      throw Error("interior hyphen");
+    if (O === 0)
+      return c(x.substring(1), l, v).neg();
+    for (var V = i(u(v, 8)), T = g, N = 0; N < x.length; N += 8) {
+      var U = Math.min(8, x.length - N), B = parseInt(x.substring(N, N + U), v);
+      if (U < 8) {
+        var C = i(u(v, U));
+        T = T.mul(C).add(i(B));
+      } else
+        T = T.mul(V), T = T.add(i(B));
+    }
+    return T.unsigned = l, T;
+  }
+  e.fromString = c;
+  function h(x, l) {
+    return typeof x == "number" ? i(x, l) : typeof x == "string" ? c(x, l) : a(x.low, x.high, typeof l == "boolean" ? l : x.unsigned);
+  }
+  e.fromValue = h;
+  var f = 65536, w = 1 << 24, p = f * f, m = p * p, b = m / 2, d = r(w), g = r(0);
+  e.ZERO = g;
+  var I = r(0, !0);
+  e.UZERO = I;
+  var $ = r(1);
+  e.ONE = $;
+  var E = r(1, !0);
+  e.UONE = E;
+  var F = r(-1);
+  e.NEG_ONE = F;
+  var M = a(-1, 2147483647, !1);
+  e.MAX_VALUE = M;
+  var A = a(-1, -1, !0);
+  e.MAX_UNSIGNED_VALUE = A;
+  var L = a(0, -2147483648, !1);
+  e.MIN_VALUE = L;
+  var S = e.prototype;
+  return S.toInt = function() {
+    return this.unsigned ? this.low >>> 0 : this.low;
+  }, S.toNumber = function() {
+    return this.unsigned ? (this.high >>> 0) * p + (this.low >>> 0) : this.high * p + (this.low >>> 0);
+  }, S.toString = function(l) {
+    if (l = l || 10, l < 2 || 36 < l)
+      throw RangeError("radix");
+    if (this.isZero())
+      return "0";
+    if (this.isNegative())
+      if (this.eq(L)) {
+        var v = i(l), O = this.div(v), V = O.mul(v).sub(this);
+        return O.toString(l) + V.toInt().toString(l);
+      } else
+        return "-" + this.neg().toString(l);
+    for (var T = i(u(l, 6), this.unsigned), N = this, U = ""; ; ) {
+      var B = N.div(T), C = N.sub(B.mul(T)).toInt() >>> 0, _ = C.toString(l);
+      if (N = B, N.isZero())
+        return _ + U;
+      for (; _.length < 6; )
+        _ = "0" + _;
+      U = "" + _ + U;
+    }
+  }, S.getHighBits = function() {
+    return this.high;
+  }, S.getHighBitsUnsigned = function() {
+    return this.high >>> 0;
+  }, S.getLowBits = function() {
+    return this.low;
+  }, S.getLowBitsUnsigned = function() {
+    return this.low >>> 0;
+  }, S.getNumBitsAbs = function() {
+    if (this.isNegative())
+      return this.eq(L) ? 64 : this.neg().getNumBitsAbs();
+    for (var l = this.high != 0 ? this.high : this.low, v = 31; v > 0 && (l & 1 << v) == 0; v--)
+      ;
+    return this.high != 0 ? v + 33 : v + 1;
+  }, S.isZero = function() {
+    return this.high === 0 && this.low === 0;
+  }, S.eqz = S.isZero, S.isNegative = function() {
+    return !this.unsigned && this.high < 0;
+  }, S.isPositive = function() {
+    return this.unsigned || this.high >= 0;
+  }, S.isOdd = function() {
+    return (this.low & 1) === 1;
+  }, S.isEven = function() {
+    return (this.low & 1) === 0;
+  }, S.equals = function(l) {
+    return n(l) || (l = h(l)), this.unsigned !== l.unsigned && this.high >>> 31 === 1 && l.high >>> 31 === 1 ? !1 : this.high === l.high && this.low === l.low;
+  }, S.eq = S.equals, S.notEquals = function(l) {
+    return !this.eq(
+      /* validates */
+      l
+    );
+  }, S.neq = S.notEquals, S.ne = S.notEquals, S.lessThan = function(l) {
+    return this.comp(
+      /* validates */
+      l
+    ) < 0;
+  }, S.lt = S.lessThan, S.lessThanOrEqual = function(l) {
+    return this.comp(
+      /* validates */
+      l
+    ) <= 0;
+  }, S.lte = S.lessThanOrEqual, S.le = S.lessThanOrEqual, S.greaterThan = function(l) {
+    return this.comp(
+      /* validates */
+      l
+    ) > 0;
+  }, S.gt = S.greaterThan, S.greaterThanOrEqual = function(l) {
+    return this.comp(
+      /* validates */
+      l
+    ) >= 0;
+  }, S.gte = S.greaterThanOrEqual, S.ge = S.greaterThanOrEqual, S.compare = function(l) {
+    if (n(l) || (l = h(l)), this.eq(l))
+      return 0;
+    var v = this.isNegative(), O = l.isNegative();
+    return v && !O ? -1 : !v && O ? 1 : this.unsigned ? l.high >>> 0 > this.high >>> 0 || l.high === this.high && l.low >>> 0 > this.low >>> 0 ? -1 : 1 : this.sub(l).isNegative() ? -1 : 1;
+  }, S.comp = S.compare, S.negate = function() {
+    return !this.unsigned && this.eq(L) ? L : this.not().add($);
+  }, S.neg = S.negate, S.add = function(l) {
+    n(l) || (l = h(l));
+    var v = this.high >>> 16, O = this.high & 65535, V = this.low >>> 16, T = this.low & 65535, N = l.high >>> 16, U = l.high & 65535, B = l.low >>> 16, C = l.low & 65535, _ = 0, G = 0, P = 0, q = 0;
+    return q += T + C, P += q >>> 16, q &= 65535, P += V + B, G += P >>> 16, P &= 65535, G += O + U, _ += G >>> 16, G &= 65535, _ += v + N, _ &= 65535, a(P << 16 | q, _ << 16 | G, this.unsigned);
+  }, S.subtract = function(l) {
+    return n(l) || (l = h(l)), this.add(l.neg());
+  }, S.sub = S.subtract, S.multiply = function(l) {
+    if (this.isZero())
+      return g;
+    if (n(l) || (l = h(l)), t) {
+      var v = t.mul(
+        this.low,
+        this.high,
+        l.low,
+        l.high
+      );
+      return a(v, t.get_high(), this.unsigned);
+    }
+    if (l.isZero())
+      return g;
+    if (this.eq(L))
+      return l.isOdd() ? L : g;
+    if (l.eq(L))
+      return this.isOdd() ? L : g;
+    if (this.isNegative())
+      return l.isNegative() ? this.neg().mul(l.neg()) : this.neg().mul(l).neg();
+    if (l.isNegative())
+      return this.mul(l.neg()).neg();
+    if (this.lt(d) && l.lt(d))
+      return i(this.toNumber() * l.toNumber(), this.unsigned);
+    var O = this.high >>> 16, V = this.high & 65535, T = this.low >>> 16, N = this.low & 65535, U = l.high >>> 16, B = l.high & 65535, C = l.low >>> 16, _ = l.low & 65535, G = 0, P = 0, q = 0, rt = 0;
+    return rt += N * _, q += rt >>> 16, rt &= 65535, q += T * _, P += q >>> 16, q &= 65535, q += N * C, P += q >>> 16, q &= 65535, P += V * _, G += P >>> 16, P &= 65535, P += T * C, G += P >>> 16, P &= 65535, P += N * B, G += P >>> 16, P &= 65535, G += O * _ + V * C + T * B + N * U, G &= 65535, a(q << 16 | rt, G << 16 | P, this.unsigned);
+  }, S.mul = S.multiply, S.divide = function(l) {
+    if (n(l) || (l = h(l)), l.isZero())
+      throw Error("division by zero");
+    if (t) {
+      if (!this.unsigned && this.high === -2147483648 && l.low === -1 && l.high === -1)
+        return this;
+      var v = (this.unsigned ? t.div_u : t.div_s)(
+        this.low,
+        this.high,
+        l.low,
+        l.high
+      );
+      return a(v, t.get_high(), this.unsigned);
+    }
+    if (this.isZero())
+      return this.unsigned ? I : g;
+    var O, V, T;
+    if (this.unsigned) {
+      if (l.unsigned || (l = l.toUnsigned()), l.gt(this))
+        return I;
+      if (l.gt(this.shru(1)))
+        return E;
+      T = I;
+    } else {
+      if (this.eq(L)) {
+        if (l.eq($) || l.eq(F))
+          return L;
+        if (l.eq(L))
+          return $;
+        var N = this.shr(1);
+        return O = N.div(l).shl(1), O.eq(g) ? l.isNegative() ? $ : F : (V = this.sub(l.mul(O)), T = O.add(V.div(l)), T);
+      } else if (l.eq(L))
+        return this.unsigned ? I : g;
+      if (this.isNegative())
+        return l.isNegative() ? this.neg().div(l.neg()) : this.neg().div(l).neg();
+      if (l.isNegative())
+        return this.div(l.neg()).neg();
+      T = g;
+    }
+    for (V = this; V.gte(l); ) {
+      O = Math.max(1, Math.floor(V.toNumber() / l.toNumber()));
+      for (var U = Math.ceil(Math.log(O) / Math.LN2), B = U <= 48 ? 1 : u(2, U - 48), C = i(O), _ = C.mul(l); _.isNegative() || _.gt(V); )
+        O -= B, C = i(O, this.unsigned), _ = C.mul(l);
+      C.isZero() && (C = $), T = T.add(C), V = V.sub(_);
+    }
+    return T;
+  }, S.div = S.divide, S.modulo = function(l) {
+    if (n(l) || (l = h(l)), t) {
+      var v = (this.unsigned ? t.rem_u : t.rem_s)(
+        this.low,
+        this.high,
+        l.low,
+        l.high
+      );
+      return a(v, t.get_high(), this.unsigned);
+    }
+    return this.sub(this.div(l).mul(l));
+  }, S.mod = S.modulo, S.rem = S.modulo, S.not = function() {
+    return a(~this.low, ~this.high, this.unsigned);
+  }, S.and = function(l) {
+    return n(l) || (l = h(l)), a(this.low & l.low, this.high & l.high, this.unsigned);
+  }, S.or = function(l) {
+    return n(l) || (l = h(l)), a(this.low | l.low, this.high | l.high, this.unsigned);
+  }, S.xor = function(l) {
+    return n(l) || (l = h(l)), a(this.low ^ l.low, this.high ^ l.high, this.unsigned);
+  }, S.shiftLeft = function(l) {
+    return n(l) && (l = l.toInt()), (l &= 63) === 0 ? this : l < 32 ? a(this.low << l, this.high << l | this.low >>> 32 - l, this.unsigned) : a(0, this.low << l - 32, this.unsigned);
+  }, S.shl = S.shiftLeft, S.shiftRight = function(l) {
+    return n(l) && (l = l.toInt()), (l &= 63) === 0 ? this : l < 32 ? a(this.low >>> l | this.high << 32 - l, this.high >> l, this.unsigned) : a(this.high >> l - 32, this.high >= 0 ? 0 : -1, this.unsigned);
+  }, S.shr = S.shiftRight, S.shiftRightUnsigned = function(l) {
+    if (n(l) && (l = l.toInt()), l &= 63, l === 0)
+      return this;
+    var v = this.high;
+    if (l < 32) {
+      var O = this.low;
+      return a(O >>> l | v << 32 - l, v >>> l, this.unsigned);
+    } else return l === 32 ? a(v, 0, this.unsigned) : a(v >>> l - 32, 0, this.unsigned);
+  }, S.shru = S.shiftRightUnsigned, S.shr_u = S.shiftRightUnsigned, S.toSigned = function() {
+    return this.unsigned ? a(this.low, this.high, !1) : this;
+  }, S.toUnsigned = function() {
+    return this.unsigned ? this : a(this.low, this.high, !0);
+  }, S.toBytes = function(l) {
+    return l ? this.toBytesLE() : this.toBytesBE();
+  }, S.toBytesLE = function() {
+    var l = this.high, v = this.low;
+    return [
+      v & 255,
+      v >>> 8 & 255,
+      v >>> 16 & 255,
+      v >>> 24,
+      l & 255,
+      l >>> 8 & 255,
+      l >>> 16 & 255,
+      l >>> 24
+    ];
+  }, S.toBytesBE = function() {
+    var l = this.high, v = this.low;
+    return [
+      l >>> 24,
+      l >>> 16 & 255,
+      l >>> 8 & 255,
+      l & 255,
+      v >>> 24,
+      v >>> 16 & 255,
+      v >>> 8 & 255,
+      v & 255
+    ];
+  }, e.fromBytes = function(l, v, O) {
+    return O ? e.fromBytesLE(l, v) : e.fromBytesBE(l, v);
+  }, e.fromBytesLE = function(l, v) {
+    return new e(
+      l[0] | l[1] << 8 | l[2] << 16 | l[3] << 24,
+      l[4] | l[5] << 8 | l[6] << 16 | l[7] << 24,
+      v
+    );
+  }, e.fromBytesBE = function(l, v) {
+    return new e(
+      l[4] << 24 | l[5] << 16 | l[6] << 8 | l[7],
+      l[0] << 24 | l[1] << 16 | l[2] << 8 | l[3],
+      v
+    );
+  }, dt;
+}
+var qt = ge();
+const Bt = /* @__PURE__ */ fe(qt), pe = /* @__PURE__ */ de({
+  __proto__: null,
+  default: Bt
+}, [qt]);
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Q = (
+  // tslint:disable-next-line
+  Bt || pe
+);
+function ft(t) {
+  return Q.fromString(t, !0, 16);
+}
+const Gt = ft("c3a5c85c97cb3127"), J = ft("b492b66fbe98f273"), z = ft("9ae16a3b2f90404f");
+function wt(t) {
+  return t.xor(t.shru(47));
+}
+function jt(t, e, n) {
+  const o = t.slice(e, e + n);
+  return Q.fromBytes(Array.from(o), !0, !0);
+}
+function R(t, e) {
+  return jt(t, e, 8);
+}
+function Rt(t, e) {
+  return jt(t, e, 4);
+}
+function D(t, e) {
+  return e === 0 ? t : t.shru(e).or(t.shl(64 - e));
+}
+function Y(t, e, n = ft("9ddfea08eb382d69")) {
+  let o = t.xor(e).mul(n);
+  o = o.xor(o.shru(47));
+  let s = e.xor(o).mul(n);
+  return s = s.xor(s.shru(47)), s = s.mul(n), s;
+}
+function me(t, e, n, o, s, r) {
+  s = s.add(t), r = D(r.add(s).add(o), 21);
+  const i = s;
+  return s = s.add(e), s = s.add(n), r = r.add(D(s, 44)), [s.add(o), r.add(i)];
+}
+function it(t, e, n, o) {
+  return me(R(t, e), R(t, e + 8), R(t, e + 16), R(t, e + 24), n, o);
+}
+function we(t, e = t.length) {
+  if (e >= 8) {
+    const n = z.add(e * 2), o = R(t, 0).add(z), s = R(t, e - 8), r = D(s, 37).mul(n).add(o), i = D(o, 25).add(s).mul(n);
+    return Y(r, i, n);
+  }
+  if (e >= 4) {
+    const n = z.add(e * 2), o = Rt(t, 0);
+    return Y(o.shl(3).add(e), Rt(t, e - 4), n);
+  }
+  if (e > 0) {
+    const n = t[0], o = t[e >> 1], s = t[e - 1], r = n + (o << 8), i = e + (s << 2);
+    return wt(z.mul(r).xor(Gt.mul(i))).mul(z);
+  }
+  return z;
+}
+function Ie(t, e = t.length) {
+  const n = z.add(e * 2), o = R(t, 0).mul(J), s = R(t, 8), r = R(t, e - 8).mul(n), i = R(t, e - 16).mul(z);
+  return Y(D(o.add(s), 43).add(D(r, 30)).add(i), o.add(D(s.add(z), 18)).add(r), n);
+}
+function xe(t, e = t.length) {
+  const n = z.add(e * 2), o = R(t, 0).mul(z), s = R(t, 8), r = R(t, e - 8).mul(n), i = R(t, e - 16).mul(z), a = D(o.add(s), 43).add(D(r, 30)).add(i), u = Y(a, o.add(D(s.add(z), 18)).add(r), n), c = R(t, 16).mul(n), h = R(t, 24), f = a.add(R(t, e - 32)).mul(n), w = u.add(R(t, e - 24)).mul(n);
+  return Y(D(c.add(h), 43).add(D(f, 30)).add(w), c.add(D(h.add(o), 18)).add(f), n);
+}
+function Se(t, e = t.length) {
+  const n = Q.fromNumber(81, !0);
+  if (e <= 32)
+    return e <= 16 ? we(t, e) : Ie(t, e);
+  if (e <= 64)
+    return xe(t, e);
+  let o = n, s = n.mul(J).add(113), r = wt(s.mul(z).add(113)).mul(z), i = [Q.UZERO, Q.UZERO], a = [Q.UZERO, Q.UZERO];
+  o = o.mul(z).add(R(t, 0));
+  let u = 0;
+  const c = (e - 1 >> 6) * 64, h = c + (e - 1 & 63) - 63;
+  do
+    o = D(o.add(s).add(i[0]).add(R(t, u + 8)), 37).mul(J), s = D(s.add(i[1]).add(R(t, u + 48)), 42).mul(J), o = o.xor(a[1]), s = s.add(i[0]).add(R(t, u + 40)), r = D(r.add(a[0]), 33).mul(J), i = it(t, u, i[1].mul(J), o.add(a[0])), a = it(t, u + 32, r.add(a[1]), s.add(R(t, u + 16))), [r, o] = [o, r], u += 64;
+  while (u !== c);
+  const f = J.add(r.and(255).shl(1));
+  return u = h, a[0] = a[0].add(e - 1 & 63), i[0] = i[0].add(a[0]), a[0] = a[0].add(i[0]), o = D(o.add(s).add(i[0]).add(R(t, u + 8)), 37).mul(f), s = D(s.add(i[1]).add(R(t, u + 48)), 42).mul(f), o = o.xor(a[1].mul(9)), s = s.add(i[0].mul(9).add(R(t, u + 40))), r = D(r.add(a[0]), 33).mul(f), i = it(t, u, i[1].mul(f), o.add(a[0])), a = it(t, u + 32, r.add(a[1]), s.add(R(t, u + 16))), [r, o] = [o, r], Y(Y(i[0], a[0], f).add(wt(s).mul(Gt)).add(r), Y(i[1], a[1], f).add(o), f);
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+var H;
+(function(t) {
+  t[t.FIRST_DIM_SIZE = 0] = "FIRST_DIM_SIZE", t[t.VALUE_ROWIDS = 1] = "VALUE_ROWIDS", t[t.ROW_LENGTHS = 2] = "ROW_LENGTHS", t[t.ROW_SPLITS = 3] = "ROW_SPLITS", t[t.ROW_LIMITS = 4] = "ROW_LIMITS", t[t.ROW_STARTS = 5] = "ROW_STARTS";
+})(H || (H = {}));
+function be(t, e, n) {
+  let o = new Array();
+  if (n == null && e == null)
+    return o;
+  if (e == null)
+    for (; o.length < t + n.length; )
+      o.push(-1);
+  else
+    o = e.slice();
+  if (n == null)
+    return o;
+  if (t + n.length !== o.length)
+    throw new Error(`rt input.shape and shape=${e} are incompatible: rt input.rank = ${t + n.length}, but shape.rank = ${o.length}`);
+  for (let s = 1; s < n.length; ++s) {
+    const r = n[s], i = o[o.length - n.length + s], a = o[i];
+    if (r >= 0)
+      if (a >= 0) {
+        if (a !== r)
+          throw new Error(`rt input.shape and shape=${e} are incompatible: rt input.shape[${s + t}] = ${r} but shape[${s + t}] = ${a}`);
+      } else
+        o[i] = r;
+  }
+  return o;
+}
+function ve(t) {
+  const e = {
+    FIRST_DIM_SIZE: H.FIRST_DIM_SIZE,
+    VALUE_ROWIDS: H.VALUE_ROWIDS,
+    ROW_LENGTHS: H.ROW_LENGTHS,
+    ROW_SPLITS: H.ROW_SPLITS,
+    ROW_LIMITS: H.ROW_LIMITS,
+    ROW_STARTS: H.ROW_STARTS
+  }, n = [];
+  for (const o of t)
+    if (o in e)
+      n.push(e[o]);
+    else
+      break;
+  return n;
+}
+function Ee(t) {
+  return t.length === 0 ? 0 : t[0] === H.FIRST_DIM_SIZE ? t.length - 1 : t.length;
+}
+function $e(t, e) {
+  if (t == null || e == null)
+    return;
+  const n = t.length, o = e.length;
+  if (n >= o)
+    throw new Error(`defaultValue.shape=${t} and ragged tensor flatValues.shape=${e}, are incompatible: defaultValue.rank = ${n} must be less than ragged tensor input flatValues.rank = ${o})`);
+  for (let s = 0; s < Math.min(n, o - 1); ++s) {
+    const r = t[s], i = e[s + 1];
+    if (r >= 0 && i >= 0 && r !== 1 && r !== i)
+      throw new Error(`defaultValue.shape=${t}, and ragged tensor input flatValues.shape=${e} are incompatible: defaultValue.shape[${s - t.length}] = ${r} but ragged tensor input.flatValues.shape[${s - t.length}] = ${i}`);
+  }
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Oe = 30;
+function ye(t) {
+  return t <= Oe ? t : Jt(t, Math.floor(Math.sqrt(t)));
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Re(t) {
+  return `Received SparseTensor with denseShape[0] = 0 but
+  indices.shape[0] = ${t}`;
+}
+function Fe(t, e) {
+  return `indices(${t}, 0) is invalid: ${e} < 0`;
+}
+function Te(t, e, n) {
+  return `indices(${t}, 0) is invalid: ${e} >= ${n}`;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Ve(t, e) {
+  return `only one output dimension may be -1, not both ${t} and ${e}`;
+}
+function Ae(t, e) {
+  return `size ${t} must be non-negative, not ${e}`;
+}
+function Le() {
+  return "reshape cannot infer the missing input size for an empty tensor unless all specified input sizes are non-zero";
+}
+function _e(t, e) {
+  const n = y(t), o = y(e);
+  return `Input to reshape is a SparseTensor with ${n}
+  dense values, but the requested shape requires a multiple of ${o}. inputShape=${t} outputShape= ${e}`;
+}
+function Me(t, e) {
+  const n = y(t), o = y(e);
+  return `Input to reshape is a tensor with ${n} dense values, but the requested shape has ${o}. inputShape=${t} outputShape=${e}`;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Ft() {
+  return "segment ids must be >= 0";
+}
+function Ne() {
+  return "segment ids are not increasing";
+}
+function De(t, e) {
+  return `Segment id ${t} out of range [0, ${e}), possibly because segmentIds input is not sorted.`;
+}
+function Pe(t, e, n) {
+  return `Bad: indices[${t}] == ${e} out of range [0, ${n})`;
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function lt(t) {
+  try {
+    return t.map((e) => Qt(e));
+  } catch (e) {
+    throw new Error(`Failed to decode encoded string bytes into utf-8, error: ${e}`);
+  }
+}
+function Ce(t) {
+  return t.map((e) => ut(e));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function ze(t) {
+  const e = new Float32Array(t.length);
+  for (let n = 0; n < t.length; ++n)
+    e[n] = Math.abs(t[n]);
+  return e;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function k(t) {
+  return (e, n, o, s, r) => {
+    const i = It(e, n), a = i.length, u = K(i), c = y(i), h = nt(r, c), f = e.length, w = n.length, p = K(e), m = K(n), b = Ot(e, i), d = Ot(n, i);
+    if (b.length + d.length === 0)
+      for (let g = 0; g < h.length; ++g)
+        h[g] = t(o[g % o.length], s[g % s.length]);
+    else
+      for (let g = 0; g < h.length; ++g) {
+        const I = xt(g, a, u), $ = I.slice(-f);
+        b.forEach((A) => $[A] = 0);
+        const E = gt($, f, p), F = I.slice(-w);
+        d.forEach((A) => F[A] = 0);
+        const M = gt(F, w, m);
+        h[g] = t(o[E], s[M]);
+      }
+    return [h, i];
+  };
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function We(t, e, n, o) {
+  if (o === "int32") {
+    const s = Int32Array.from(t);
+    return [e, "int32", s];
+  }
+  if (o === "bool") {
+    const s = te([0], n), [r, i] = k((a, u) => a !== u ? 1 : 0)(e, [], t, s, "bool");
+    return [i, "bool", r];
+  }
+  throw new Error(`Error in Cast: failed to cast ${n} to ${o}`);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const ke = k((t, e) => t + e);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Ue(t, e, n, o, s) {
+  const r = y(o), i = ot(s, n);
+  for (let a = 0; a < t.length; a++) {
+    const u = t[a];
+    if (u < 0)
+      throw new Error("Input x must be non-negative!");
+    u >= s || (r > 0 ? i[u] += e[a] : i[u] += 1);
+  }
+  return i;
+}
+function qe(t, e, n, o = !1) {
+  const s = t.shape[0], r = t.shape[1], i = Z([s, n], e.dtype);
+  for (let a = 0; a < s; a++)
+    for (let u = 0; u < r; u++) {
+      const c = t.get(a, u);
+      if (c < 0)
+        throw new Error("Input x must be non-negative!");
+      c >= n || (o ? i.set(1, a, c) : e.size > 0 ? i.set(i.get(a, c) + e.get(a, u), a, c) : i.set(i.get(a, c) + 1, a, c));
+    }
+  return i;
+}
+/**
+ * @license
+ * Copyright 2023 Google LLC.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Be = k((t, e) => t & e);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function X(t) {
+  return (e, n, o) => {
+    const s = W(n, e.length);
+    for (let r = 0; r < e.length; ++r)
+      s[r] = t(e[r], o);
+    return s;
+  };
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Ge = X((t) => Math.ceil(t));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function je(t, e, n, o) {
+  const s = W(n, y(e));
+  if (o && n !== "string") {
+    let r = 0;
+    t.forEach((i) => {
+      const a = y(i.shape);
+      s.set(i.vals, r), r += a;
+    });
+  } else {
+    let r = 0;
+    t.forEach((i) => {
+      const a = n === "string" ? lt(i.vals) : i.vals;
+      let u = 0;
+      for (let c = 0; c < i.shape[0]; ++c) {
+        const h = c * e[1] + r;
+        for (let f = 0; f < i.shape[1]; ++f)
+          s[h + f] = a[u++];
+      }
+      r += i.shape[1];
+    });
+  }
+  return s;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Ze = k((t, e) => t === e ? 1 : 0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const He = X((t) => Math.exp(t));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Ke = X((t) => Math.expm1(t));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Xe = X((t) => Math.floor(t));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Ye = k((t, e) => Math.floor(t / e));
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Je(t, e, n, o, s, r, i, a, u) {
+  const c = Z([o, r], n);
+  for (let h = 0; h < o; h++) {
+    const f = [];
+    let w = 0;
+    for (let p = 0; p < s; p++) {
+      const m = t[h * s + p];
+      w += m * i[p], f.push(m);
+    }
+    if (w < 0 || w >= u / r)
+      throw new Error(`Invalid indices: ${f} does not index into ${a}`);
+    for (let p = 0; p < r; p++)
+      c.values[h * r + p] = e.get(...e.indexToLoc(w * r + p));
+  }
+  return c;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Qe(t, e, n) {
+  const o = Z(n, t.dtype);
+  for (let s = 0; s < o.size; ++s) {
+    const i = o.indexToLoc(s).slice(), a = i[0], u = i[2], c = e.locToIndex([a, u]);
+    i[2] = e.values[c];
+    const h = t.locToIndex(i);
+    0 <= h && h < t.values.length && (o.values[s] = t.values[h]);
+  }
+  return o;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const tn = k((t, e) => t > e ? 1 : 0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const en = k((t, e) => t >= e ? 1 : 0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const nn = k((t, e) => t < e ? 1 : 0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const on = k((t, e) => t <= e ? 1 : 0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function sn(t, e, n) {
+  const o = (e - t) / (n - 1), s = ot(n, "float32");
+  s[0] = t;
+  for (let r = 1; r < s.length; r++)
+    s[r] = s[r - 1] + o;
+  return s;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const rn = X((t) => Math.log(t));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function an(t, e, n, o) {
+  const s = nt(o, y(n));
+  for (let r = 0; r < s.length; ++r) {
+    const i = r * e;
+    let a = t[i];
+    for (let u = 0; u < e; ++u) {
+      const c = t[i + u];
+      (Number.isNaN(c) || c > a) && (a = c);
+    }
+    s[r] = a;
+  }
+  return s;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const un = k((t, e) => Math.max(t, e));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const ln = k((t, e) => Math.min(t, e));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Zt = k((t, e) => t * e);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function cn(t, e, n) {
+  const o = ee(-1, n);
+  return Zt([], e, o, t, n);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const hn = k((t, e) => t !== e ? 1 : 0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function fn(t, e, n, o, s) {
+  const r = e.length, i = y(e), a = K(e), u = K(s), c = nt(n, y(s));
+  for (let h = 0; h < i; ++h) {
+    const f = xt(h, r, a), w = new Array(f.length);
+    for (let m = 0; m < w.length; m++)
+      w[m] = f[o[m]];
+    const p = gt(w, r, u);
+    c[p] = t[h];
+  }
+  return c;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function dn(t, e, n, o) {
+  const [s, r] = bt(t, o), i = pt(e, "int32"), a = ot(y(s), i), u = y(r);
+  for (let c = 0; c < a.length; ++c) {
+    const h = c * u;
+    let f = 1;
+    for (let w = 0; w < u; ++w)
+      f *= n[h + w];
+    a[c] = f;
+  }
+  return { outVals: a, outShape: s, outDtype: i };
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function gn(t, e, n) {
+  t.forEach((o, s) => {
+    if (o < 0 || o >= n) {
+      const r = xt(s, e.length, K(e)).join(",");
+      throw new Error(`indices[${r}] = ${o} is not in [0, ${n})`);
+    }
+  });
+}
+function pn(t, e) {
+  for (let n = 0; n < t.length; ++n) {
+    const o = t[n], s = n === t.length - 1 ? e : t[n + 1].length;
+    if (o.length === 0)
+      throw new Error("Ragged splits may not be empty");
+    if (o[0] < 0)
+      throw new Error("Ragged splits must be non-negative");
+    if (o[o.length - 1] > s)
+      throw new Error("Ragged splits must not point past values");
+    for (let r = 1; r < o.length; ++r)
+      if (o[r - 1] > o[r])
+        throw new Error("Ragged splits must be sorted in ascending order");
+  }
+}
+function mn(t, e, n, o) {
+  const s = [];
+  let r = 0;
+  const i = e.length - 1 + n.length, a = new Array(i).fill(null).map(() => [0]);
+  pn(n, o);
+  let u = 1;
+  for (let c = 0; c < e.length - 1; ++c) {
+    u *= e[c];
+    const h = e[c + 1];
+    for (let f = 1; f < u + 1; ++f)
+      a[c].push(f * h);
+  }
+  for (let c = 0; c < t.length; ++c) {
+    let h = t[c], f = t[c] + 1;
+    for (let w = 0; w < n.length; ++w) {
+      const p = n[w], m = w + e.length - 1;
+      if (m >= 0) {
+        const b = a[m], d = b[b.length - 1] - p[h];
+        for (let g = h; g < f; ++g)
+          a[m].push(p[g + 1] + d);
+      }
+      h = p[h], f = p[f];
+    }
+    f !== h && (s.push([h, f]), r += f - h);
+  }
+  return { outSplits: a, valueSlices: s, numValues: r };
+}
+function wn(t) {
+  const e = [];
+  for (let n = 0; n < t.length; ++n) {
+    const o = t[n].length, s = W("int32", o);
+    e.push(s), t[n].forEach((r, i) => s[i] = r);
+  }
+  return e;
+}
+function Tt(t, e) {
+  const n = t.slice(0, e);
+  for (; n.length < e; )
+    n.push(1);
+  for (let o = e; o < t.length; o++)
+    n[e - 1] *= t[o];
+  return n;
+}
+function In(t, e, n, o, s, r) {
+  const i = Tt(e, 2)[1], a = Tt(r, 2)[1];
+  let u = 0;
+  for (const c of n)
+    for (let h = c[0]; h < c[1]; ++h) {
+      for (let f = 0; f < o; ++f)
+        s[u * a + f] = t[h * i + f];
+      ++u;
+    }
+}
+function xn(t, e, n, o, s) {
+  const r = e.slice();
+  r[0] = s;
+  const i = W(n, y(r)), a = t.length, u = a === 0 ? 0 : a / e[0];
+  return In(t, e, o, u, i, r), [i, r];
+}
+function Sn(t, e, n, o, s, r, i, a) {
+  if (t.length === 0)
+    throw new Error("paramsNestedSplits must be non empty");
+  if (e[0].length === 0)
+    throw new Error("Split tensors must not be scalars");
+  const u = e[0][0] - 1;
+  if (gn(r, i, u), o.length === 0)
+    throw new Error("params.rank must be nonzero");
+  const c = o[0], { outSplits: h, valueSlices: f, numValues: w } = mn(r, i, t, c), p = wn(h), m = xn(n, o, s, f, w);
+  return [p, m[0], m[1]];
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Vt = 2147483647;
+function bn(t, e, n, o, s, r, i) {
+  if (e.length > 1)
+    throw new Error("starts must be a scalar or vector");
+  if (s.length > 1)
+    throw new Error("limits must be a scalar or vector");
+  if (i.length > 1)
+    throw new Error("deltas must be a scalar or vector");
+  const a = e.length === 0, u = s.length === 0, c = i.length === 0, h = [];
+  a || h.push(e[0]), u || h.push(s[0]), c || h.push(i[0]);
+  for (let d = 1; d < h.length; ++d)
+    if (h[d] !== h[d - 1])
+      throw new Error("starts, limits, and deltas must have the same shape");
+  const f = h.length === 0 ? 1 : h[0], w = W("int32", f + 1);
+  w[0] = 0;
+  for (let d = 0; d < f; ++d) {
+    const g = a ? t[0] : t[d], I = u ? o[0] : o[d], $ = c ? r[0] : r[d];
+    if ($ === 0)
+      throw new Error("Requires delta != 0");
+    let E;
+    if ($ > 0 && I < g || $ < 0 && I > g)
+      E = 0;
+    else if (E = Math.ceil(Math.abs((I - g) / $)), E > Vt)
+      throw new Error(`Requires ((limit - start) / delta) <= ${Vt}`);
+    w[d + 1] = w[d] + E;
+  }
+  const p = w[f], m = W(n, p);
+  let b = 0;
+  for (let d = 0; d < f; ++d) {
+    const g = w[d + 1] - w[d];
+    let I = a ? t[0] : t[d];
+    const $ = c ? r[0] : r[d];
+    for (let E = 0; E < g; ++E)
+      m[b++] = I, I += $;
+  }
+  return [w, m];
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+var j = H;
+class ct {
+  constructor(e, n, o, s, r, i, a, u, c, h) {
+    this.shape = e, this.shapeShape = n, this.values = o, this.valuesShape = s, this.valuesDType = r, this.defaultValue = i, this.defaultValueShape = a, this.rowPartitionValues = u, this.rowPartitionValuesShapes = c, this.rowPartitionTypes = ve(h), this.raggedRank = Ee(this.rowPartitionTypes);
+  }
+  getRowPartitionTypeByDimension(e) {
+    return this.rowPartitionTypes[0] === j.FIRST_DIM_SIZE ? this.rowPartitionTypes[e + 1] : this.rowPartitionTypes[e];
+  }
+  // Returns the relationship between dimension and dimension + 1.
+  getRowPartitionTensor(e) {
+    return this.rowPartitionTypes[0] === j.FIRST_DIM_SIZE ? this.rowPartitionValues[e + 1] : this.rowPartitionValues[e];
+  }
+  getMaxWidth(e) {
+    const n = this.getRowPartitionTensor(e - 1);
+    switch (this.getRowPartitionTypeByDimension(e - 1)) {
+      case j.VALUE_ROWIDS:
+        return ct.getMaxWidthValueRowID(n);
+      case j.ROW_SPLITS:
+        return ct.getMaxWidthRowSplit(n);
+      default:
+        throw new Error(`Cannot handle partition type ${j[this.getRowPartitionTypeByDimension(e - 1)]}`);
+    }
+  }
+  static getMaxWidthRowSplit(e) {
+    const n = e.length;
+    if (n === 0 || n === 1)
+      return 0;
+    let o = 0;
+    for (let s = 0; s < n - 1; ++s) {
+      const r = e[s + 1] - e[s];
+      r > o && (o = r);
+    }
+    return o;
+  }
+  static getMaxWidthValueRowID(e) {
+    const n = e.length;
+    if (n === 0)
+      return 0;
+    let o = 0, s = e[0], r = 0;
+    for (let i = 1; i < n; ++i) {
+      const a = e[i];
+      a !== s && (s = a, r = Math.max(i - o, r), o = i);
+    }
+    return Math.max(n - o, r);
+  }
+  tensorShapeFromTensor(e, n, o = !0) {
+    if (n.length === 0) {
+      if (e[0] === -1)
+        return [];
+      throw new Error("The only valid scalar shape tensor is the fully unknown shape specified as -1.");
+    }
+    return Lt(e, o);
+  }
+  calculateOutputSize(e) {
+    const n = this.valuesShape, o = this.defaultValueShape;
+    $e(o, n);
+    const s = this.tensorShapeFromTensor(this.shape, this.shapeShape), i = be(this.raggedRank, s, n);
+    i[0] < 0 && (i[0] = e);
+    for (let a = 1; a <= this.raggedRank; ++a)
+      i[a] < 0 && (i[a] = this.getMaxWidth(a));
+    return i;
+  }
+  /**
+   * The outputIndex represents the index in the output tensor
+   * where the first element of a particular dimension would be written.
+   * If it is -1, it indicates that the index is out of scope.
+   * Example, given firstDimension = 10, firstDimensionOutput = 6,
+   * and outputIndexMultiplier = 100:
+   * result = [0 100 200 300 400 500 -1 -1 -1 -1]
+   * If firstDimensionOutput = 11 instead, then:
+   * result = [0 100 200 300 400 500 600 700 800 900]
+   */
+  calculateFirstParentOutputIndex(e, n, o) {
+    const s = Math.min(e, o), r = [];
+    let i = 0;
+    for (let a = 0; a < s; ++a, i += n)
+      r.push(i);
+    for (let a = s; a < e; ++a)
+      r.push(-1);
+    return zt(r.length === e, () => "Final length of result must be equal to firstDimension."), r;
+  }
+  calculateOutputIndexRowSplit(e, n, o, s) {
+    const r = e.length, i = [];
+    for (let a = 0; a < r - 1; ++a) {
+      const u = e[a + 1] - e[a];
+      let c = Math.min(s, u), h = n[a];
+      h === -1 && (c = 0);
+      for (let f = 0; f < c; ++f)
+        i.push(h), h += o;
+      for (let f = 0; f < u - c; ++f)
+        i.push(-1);
+    }
+    if (r > 0 && i.length !== e[r - 1])
+      throw new Error("Invalid row split size.");
+    return i;
+  }
+  // Calculate the output index of the first element of a list.
+  // The parentOutputIndex is the same computation for the previous list.
+  // -1 indicates an element or list that is out of range.
+  // The outputIndexMultiplier is the number of output indices one moves
+  // forward for each column.
+  // E.g., given:
+  // valueRowIds:[0 1 2 2 2 3 5 5 6]
+  // parentOutputIndex:[1000 1100 2000 2100 -1 3000 4000]
+  // outputIndexMultiplier: 10
+  // outputSize: 2
+  // You get:
+  // result = [1000 1100 2000 2010 -1 2100 -1 -1 3000]
+  // result[0] = parentOutputIndex[valueRowIds[0]]
+  // result[1] = parentOutputIndex[valueRowIds[1]]
+  // result[2] = parentOutputIndex[valueRowIds[2]]
+  // result[3] = parentOutputIndex[valueRowIds[2] + 10]
+  // result[4] = -1 because it is the third element the size is 2.
+  // result[5] = parentOutputIndex[valueRowIds[3]]
+  // result[6] = -1 because parentOutputIndex[valueRowIds[6]] == -1
+  // result[7] = -1 because parentOutputIndex[valueRowIds[6]] == -1
+  // result[8] = parentOutputIndex[valueRowIds[7]]
+  calculateOutputIndexValueRowID(e, n, o, s) {
+    const r = e.length, i = [];
+    if (r === 0)
+      return [];
+    let a = 0, u = e[0];
+    if (u >= n.length)
+      throw new Error(`Got currentValueRowId=${u}, which is not less than ${n.length}`);
+    let c = n[u];
+    i.push(c);
+    for (let h = 1; h < r; ++h) {
+      const f = e[h];
+      if (f === u)
+        c >= 0 && (++a, a < s ? c += o : c = -1);
+      else {
+        if (a = 0, u = f, f >= n.length)
+          throw new Error(`Got nextValueRowId=${f} which is not less than ${n.length}`);
+        c = n[f];
+      }
+      i.push(c);
+    }
+    if (i.length !== e.length)
+      throw new Error("Invalid row ids.");
+    return i;
+  }
+  calculateOutputIndex(e, n, o, s) {
+    const r = this.getRowPartitionTensor(e), i = this.getRowPartitionTypeByDimension(e);
+    switch (i) {
+      case j.VALUE_ROWIDS:
+        return this.calculateOutputIndexValueRowID(r, n, o, s);
+      case j.ROW_SPLITS:
+        if (r.length - 1 > n.length)
+          throw new Error(`Row partition size is greater than output size: ${r.length - 1} > ${n.length}`);
+        return this.calculateOutputIndexRowSplit(r, n, o, s);
+      default:
+        throw new Error(`Unsupported partition type: ${j[i]}`);
+    }
+  }
+  getFirstDimensionSize() {
+    const e = this.rowPartitionValues[0];
+    if (this.rowPartitionTypes.length === 0)
+      throw new Error("No row_partition_types given.");
+    const n = this.rowPartitionTypes[0];
+    switch (n) {
+      case j.FIRST_DIM_SIZE:
+        return e[0];
+      case j.VALUE_ROWIDS:
+        throw new Error("Cannot handle VALUE_ROWIDS in first dimension.");
+      case j.ROW_SPLITS:
+        return this.rowPartitionValuesShapes[0][0] - 1;
+      default:
+        throw new Error(`Cannot handle type ${j[n]}`);
+    }
+  }
+  compute() {
+    if (this.rowPartitionValues[0].length <= 0)
+      throw new Error("Invalid first partition input. Tensor requires at least one element.");
+    const n = this.getFirstDimensionSize(), o = this.calculateOutputSize(n), s = new Array(this.raggedRank + 1);
+    s[s.length - 1] = 1;
+    for (let u = s.length - 2; u >= 0; --u)
+      s[u] = s[u + 1] * o[u + 1];
+    const r = Lt(o, !1), i = W(this.valuesDType, y(r));
+    if (s[0] * o[0] > 0) {
+      let u = this.calculateFirstParentOutputIndex(n, s[0], o[0]);
+      for (let c = 1; c <= this.raggedRank; ++c)
+        u = this.calculateOutputIndex(c - 1, u, s[c], o[c]);
+      this.setOutput(this.raggedRank, u, i, r);
+    }
+    return [r, i];
+  }
+  setOutput(e, n, o, s) {
+    if (o.length === 0)
+      return;
+    const r = this.values, i = o;
+    let a = s.slice();
+    a = a.slice(e + 1);
+    const u = y(a), c = n.length;
+    let h = this.defaultValue;
+    if (h.length !== u && h.length !== 1) {
+      const m = this.defaultValueShape;
+      ne(() => {
+        const b = he(h, m);
+        h = ue(b, a).dataSync();
+      });
+    }
+    let f = 0, w = 0, p = 0;
+    for (let m = 0; m <= c; ++m) {
+      let b = m < c ? n[m] : -1;
+      if (b === p) {
+        ++p;
+        continue;
+      }
+      if (w < p) {
+        const d = r.subarray(f * u), g = i.subarray(w * u), I = (p - w) * u;
+        At(g, d, I);
+      }
+      if (m >= c) {
+        const d = o.length;
+        b = Math.floor(d / u);
+      }
+      if (b > p)
+        if (this.defaultValue.length === 1)
+          i.subarray(p * u, b * u).fill(this.defaultValue[0]), p = b;
+        else
+          for (; b > p; ) {
+            const d = i.slice(p * u);
+            At(d, h, u), ++p;
+          }
+      b < 0 ? (f = m + 1, w = p) : (f = m, w = p, p = w + 1);
+    }
+  }
+}
+function At(t, e, n) {
+  for (let o = 0; o < n; o++)
+    t[o] = e[o];
+}
+function Lt(t, e) {
+  const n = [];
+  for (let o of t) {
+    if (o < 0) {
+      if (!e)
+        throw new Error(`Dimension ${o} must be >= 0`);
+      if (o < -1)
+        throw new Error(`Dimension ${o} must be >= -1`);
+      o = -1;
+    }
+    n.push(o);
+  }
+  return n;
+}
+function vn(t, e, n, o, s, r, i, a, u, c) {
+  return new ct(t, e, n, o, s, r, i, a, u, c).compute();
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function En(t, e, n, o) {
+  const s = t === e, r = t < e && n < 0, i = e < t && n > 1;
+  if (s || r || i)
+    return ot(0, o);
+  const a = Math.abs(Math.ceil((e - t) / n)), u = ot(a, o);
+  e < t && n === 1 && (n = -1), u[0] = t;
+  for (let c = 1; c < u.length; c++)
+    u[c] = u[c - 1] + n;
+  return u;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const $n = X((t) => 1 / Math.sqrt(t));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function On(t, e, n, o, s, r, i, a, u, c) {
+  const h = [o / s, s], f = t.values, w = e.values;
+  if (o === 0)
+    return Z(n, e.dtype);
+  const p = u instanceof mt ? u : Z(h, e.dtype);
+  typeof u == "string" || typeof u == "number" ? p.values.fill(u) : typeof u == "boolean" && p.values.fill(+u);
+  for (let m = 0; m < r; m++) {
+    const b = [];
+    let d = 0;
+    for (let g = 0; g < i; g++) {
+      const I = f[m * i + g];
+      b.push(I), d += I * a[g];
+    }
+    if (d < 0 || d >= o / s)
+      throw new Error(`Invalid indices: ${b} does not index into ${n}`);
+    for (let g = 0; g < s; g++)
+      c ? p.values[d * s + g] += w[m * s + g] : p.values[d * s + g] = e.rank === 0 ? w[0] : w[m * s + g];
+  }
+  return p;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const yn = X((t) => 1 / (1 + Math.exp(-t)));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Rn(t, e, n, o, s) {
+  const r = le(o, e, n), i = y(n), a = K(o);
+  if (r) {
+    const f = ce(e, a);
+    return s === "string" ? t.slice(f, f + i) : t.subarray(f, f + i);
+  }
+  const u = s === "string" ? lt(t) : t, c = Z(o, s, u), h = Z(n, s);
+  for (let f = 0; f < h.size; ++f) {
+    const w = h.indexToLoc(f), p = w.map((m, b) => m + e[b]);
+    h.set(c.get(...p), ...w);
+  }
+  return s === "string" ? Ce(h.values) : h.values;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Fn(t, e, n, o, s, r, i) {
+  const a = e[0], u = r[0], c = new Array(u), h = new Array(a), f = e[1];
+  if (u === 0) {
+    if (a !== 0)
+      throw new Error(Re(a));
+    const d = W(n, 0), g = W(s, 0);
+    return [
+      d,
+      [0, f],
+      g,
+      c,
+      h
+    ];
+  }
+  let w = !0, p = 0;
+  const m = new Array(u).fill(0);
+  for (let d = 0; d < a; ++d) {
+    const g = t[d * f];
+    if (g < 0)
+      throw new Error(Fe(d, g));
+    if (g >= u)
+      throw new Error(Te(d, g, u));
+    ++m[g], w = w && g >= p, p = g;
+  }
+  let b = !0;
+  for (let d = 0; d < u; ++d) {
+    const g = m[d] === 0;
+    c[d] = g, b = b && !g, m[d] = Math.max(m[d], 1), d > 0 && (m[d] += m[d - 1]);
+  }
+  if (b && w) {
+    const d = t, g = o;
+    for (let I = 0; I < a; ++I)
+      h[I] = I;
+    return [
+      d,
+      [a, f],
+      g,
+      c,
+      h
+    ];
+  } else {
+    const d = m[u - 1], g = W(n, d * f), I = W(s, d), $ = new Array(u).fill(0);
+    for (let E = 0; E < a; ++E) {
+      const F = t[E * f], M = $[F], A = (F === 0 ? 0 : m[F - 1]) + M;
+      $[F]++;
+      for (let L = 0; L < f; ++L)
+        g[A * f + L] = t[E * f + L];
+      I[A] = o[E], h[E] = A;
+    }
+    for (let E = 0; E < u; ++E)
+      if ($[E] === 0) {
+        const M = E === 0 ? 0 : m[E - 1];
+        g[M * f + 0] = E;
+        for (let A = 1; A < f; ++A)
+          g[M * f + A] = 0;
+        I[M] = i;
+      }
+    return [
+      g,
+      [d, f],
+      I,
+      c,
+      h
+    ];
+  }
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Tn(t, e, n, o, s) {
+  const r = y(o), i = e[0], a = s.length, u = [];
+  let c = 1, h = -1;
+  for (let d = 0; d < a; ++d) {
+    const g = s[d];
+    if (g === -1) {
+      if (h !== -1)
+        throw new Error(Ve(h, d));
+      h = d, u.push(1);
+    } else {
+      if (g < 0)
+        throw new Error(Ae(d, g));
+      c *= g, u.push(g);
+    }
+  }
+  if (h !== -1) {
+    if (c <= 0)
+      throw new Error(Le());
+    const d = Math.trunc(r / c);
+    if (c * d !== r)
+      throw new Error(_e(o, u));
+    u[h] = d;
+  }
+  if (y(u) !== r)
+    throw new Error(Me(o, u));
+  const w = o.length, p = [];
+  if (w > 0) {
+    p[w - 1] = 1;
+    for (let d = w - 2; d >= 0; --d)
+      p[d] = p[d + 1] * o[d + 1];
+  }
+  const m = [];
+  if (a > 0) {
+    m[a - 1] = 1;
+    for (let d = a - 2; d >= 0; --d)
+      m[d] = m[d + 1] * u[d + 1];
+  }
+  const b = W(n, i * a);
+  for (let d = 0; d < i; ++d) {
+    let g = 0;
+    for (let I = 0; I < w; ++I)
+      g += t[d * w + I] * p[I];
+    for (let I = 0; I < a; ++I)
+      b[d * a + I] = Math.trunc(g / m[I]), g %= m[I];
+  }
+  return [b, [i, a], u];
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Vn(t, e, n, o, s, r = !1, i = 0) {
+  const a = o.length, u = [e[0], t.length / e[0]], c = u[1], f = a > 0 ? s[a - 1] + 1 : 0;
+  if (f < 0)
+    throw new Error(Ft());
+  const w = e.slice();
+  w[0] = f;
+  const p = w.reduce(($, E) => $ * E, 1), m = W(n, p);
+  if (a === 0)
+    return f > 0 && m.fill(i), [m, w];
+  if (f <= 0)
+    throw new Error(Ft());
+  let b = 0, d = 1, g = 0, I = s[b];
+  for (; ; ) {
+    let $ = 0;
+    if (d < a) {
+      if ($ = s[d], I === $) {
+        ++d;
+        continue;
+      }
+      if (I >= $)
+        throw new Error(Ne());
+    }
+    if (I < 0 || I >= f)
+      throw new Error(De(I, f));
+    I > g && m.fill(i, g * c, I * c);
+    for (let E = b; E < d; ++E) {
+      const F = o[E];
+      if (F < 0 || F >= u[0])
+        throw new Error(Pe(E, o[E], u[0]));
+      for (let M = 0; M < c; M++)
+        m[I * c + M] += t[F * c + M];
+    }
+    if (r)
+      for (let E = 0; E < c; E++)
+        m[I * c + E] /= d - b;
+    if (b = d, ++d, g = I + 1, I = $, d > a)
+      break;
+  }
+  return g < f && m.fill(i, g * c, f * c), [m, w];
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const An = X((t) => Math.sqrt(t));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Ln = k((t, e) => {
+  const n = t - e;
+  return n * n;
+});
+/**
+ * @license
+ * Copyright 2023 Google LLC.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const _n = X((t, e) => {
+  const { pattern: n, replaceGlobal: o, rewrite: s } = e;
+  return t.replace(new RegExp(n, o ? "g" : ""), s);
+});
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Mn(t, e, n, o) {
+  const s = Z(t, e.dtype);
+  for (let r = 0; r < s.size; r++) {
+    const i = s.indexToLoc(r), a = new Array(i.length);
+    for (let u = 0; u < a.length; u++)
+      a[u] = i[u] * n[u] + o[u];
+    s.set(e.get(...a), ...i);
+  }
+  return s;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class Nn {
+  constructor(e, n, o, s, r, i) {
+    this.separator = ut(e), this.nGramWidths = n, this.leftPad = ut(o), this.rightPad = ut(s), this.padWidth = r, this.preserveShort = i;
+  }
+  getPadWidth(e) {
+    return Math.min(this.padWidth < 0 ? e - 1 : this.padWidth, e - 1);
+  }
+  getNumNGrams(e, n) {
+    const o = this.getPadWidth(n);
+    return Math.max(0, e + 2 * o - n + 1);
+  }
+  createNGrams(e, n, o, s, r, i) {
+    for (let a = 0; a < r; ++a) {
+      const u = this.getPadWidth(i), c = Math.max(0, u - a), h = Math.max(0, u - (r - (a + 1))), f = i - (c + h), w = n + (c > 0 ? 0 : a - u);
+      let p = 0;
+      p += c * this.leftPad.length;
+      for (let I = 0; I < f; ++I)
+        p += e[w + I].length;
+      p += h * this.rightPad.length;
+      const m = c + h + f - 1;
+      p += m * this.separator.length, o[s + a] = new Uint8Array(p);
+      const b = o[s + a];
+      let d = 0;
+      const g = (I) => I.forEach(($) => b[d++] = $);
+      for (let I = 0; I < c; ++I)
+        g(this.leftPad), g(this.separator);
+      for (let I = 0; I < f - 1; ++I)
+        g(e[w + I]), g(this.separator);
+      if (f > 0) {
+        g(e[w + f - 1]);
+        for (let I = 0; I < h; ++I)
+          g(this.separator), g(this.rightPad);
+      } else {
+        for (let I = 0; I < h - 1; ++I)
+          g(this.rightPad), g(this.separator);
+        g(this.rightPad);
+      }
+    }
+  }
+  // Data and splits together form the definition of the ragged tensor,
+  // where data is 1 dimensional and contains the values of the tensor
+  // and splits denotes the indices at which each row starts.
+  compute(e, n) {
+    const o = e.length, s = n.length;
+    if (s > 0) {
+      let u = n[0];
+      if (u !== 0)
+        throw new Error(`First split value must be 0, got ${u}`);
+      for (let c = 1; c < s; ++c) {
+        let h = n[c] >= u;
+        if (h = h && n[c] <= o, !h)
+          throw new Error(`Invalid split value ${n[c]}, must be in [${u}, ${o}]`);
+        u = n[c];
+      }
+      if (u !== o)
+        throw new Error(`Last split value must be data size. Expected ${o}, got ${u}`);
+    }
+    const r = s - 1, i = W("int32", s);
+    if (o === 0 || s === 0) {
+      const u = new Array(o);
+      for (let c = 0; c <= r; ++c)
+        i[c] = 0;
+      return [u, i];
+    }
+    i[0] = 0;
+    for (let u = 1; u <= r; ++u) {
+      const c = n[u] - n[u - 1];
+      let h = 0;
+      this.nGramWidths.forEach((f) => {
+        h += this.getNumNGrams(c, f);
+      }), this.preserveShort && c > 0 && h === 0 && (h = 1), i[u] = i[u - 1] + h;
+    }
+    const a = new Array(i[r]);
+    for (let u = 0; u < r; ++u) {
+      const c = n[u];
+      let h = i[u];
+      if (this.nGramWidths.forEach((f) => {
+        const w = n[u + 1] - n[u], p = this.getNumNGrams(w, f);
+        this.createNGrams(e, c, a, h, p, f), h += p;
+      }), this.preserveShort && h === i[u]) {
+        const f = n[u + 1] - n[u];
+        if (f === 0)
+          continue;
+        const w = f + 2 * this.padWidth;
+        this.createNGrams(e, c, a, h, 1, w);
+      }
+    }
+    return [a, i];
+  }
+}
+function Dn(t, e, n, o, s, r, i, a) {
+  return new Nn(n, o, s, r, i, a).compute(t, e);
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Pn(t, e, n, o) {
+  if (!t.length)
+    return;
+  if (e.length === 0) {
+    for (let r = 0; r < t.length; ++r)
+      o.push(t.subarray(r, r + 1));
+    return;
+  }
+  if (e.length === 1) {
+    const r = e[0];
+    let i = t.indexOf(r);
+    for (; i !== -1; ) {
+      const a = t.subarray(0, i);
+      (!n || a.length !== 0) && o.push(a), t = t.subarray(i + 1), i = t.indexOf(r);
+    }
+    (!n || t.length !== 0) && o.push(t);
+    return;
+  }
+  let s = 0;
+  for (let r = 0; r < t.length + 1; r++)
+    if (r === t.length || e.indexOf(t[r]) !== -1) {
+      const i = t.subarray(s, r);
+      (!n || i.length !== 0) && o.push(i), s = r + 1;
+    }
+}
+function Cn(t, e, n) {
+  const o = t.length, s = [];
+  let r = 0, i = 0;
+  const a = new Array(o);
+  for (let w = 0; w < o; ++w) {
+    const p = s.length;
+    Pn(t[w], e, n, s);
+    const m = s.length - p;
+    a[w] = m, r += m, i = Math.max(i, m);
+  }
+  const u = W("int32", r * 2), c = new Array(r), h = [o, i];
+  let f = 0;
+  for (let w = 0; w < o; ++w)
+    for (let p = 0; p < a[w]; ++p)
+      u[f * 2] = w, u[f * 2 + 1] = p, c[f] = s[f], ++f;
+  return [u, c, h];
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function zn(t, e) {
+  const n = W("int32", t.length);
+  for (let o = 0; o < t.length; ++o)
+    n[o] = Se(t[o]).modulo(e).getLowBitsUnsigned();
+  return n;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Wn = k((t, e) => t - e);
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function kn(t, e) {
+  const n = new Array(t.rank);
+  for (let s = 0; s < n.length; s++)
+    n[s] = t.shape[s] * e[s];
+  const o = Z(n, t.dtype);
+  for (let s = 0; s < o.values.length; ++s) {
+    const r = o.indexToLoc(s), i = new Array(t.rank);
+    for (let u = 0; u < i.length; u++)
+      i[u] = r[u] % t.shape[u];
+    const a = t.locToIndex(i);
+    o.values[s] = t.values[a];
+  }
+  return o;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const et = (t, e) => {
+  const n = e.value - t.value;
+  return n === 0 ? t.index - e.index : n;
+};
+function Ht(t, e, n = 0, o = t.length - 1) {
+  for (; o > n; ) {
+    if (o - n > 600) {
+      const a = o - n + 1, u = e - n + 1, c = Math.log(a), h = 0.5 * Math.exp(2 * c / 3), f = 0.5 * Math.sqrt(c * h * (a - h) / a) * Math.sign(u - a / 2), w = Math.max(n, Math.floor(e - u * h / a + f)), p = Math.min(o, Math.floor(e + (a - u) * h / a + f));
+      Ht(t, e, w, p);
+    }
+    const s = t[e];
+    let r = n, i = o;
+    for (tt(t, n, e), et(t[o], s) > 0 && tt(t, n, o); r < i; ) {
+      for (tt(t, r, i), r++, i--; et(t[r], s) < 0; )
+        r = r + 1;
+      for (; et(t[i], s) > 0; )
+        i = i - 1;
+    }
+    et(t[n], s) === 0 ? tt(t, n, i) : (i = i + 1, tt(t, i, o)), i <= e && (n = i + 1), e <= i && (o = i - 1);
+  }
+}
+function Un(t, e, n, o, s) {
+  const r = e[e.length - 1], [i, a] = [t.length / r, r], u = nt(n, i * o), c = nt("int32", i * o);
+  for (let f = 0; f < i; f++) {
+    const w = f * a, p = t.subarray(w, w + a);
+    let m = new Array(p.length);
+    p.forEach((I, $) => m[$] = { value: I, index: $ }), o < m.length && (Ht(m, o), m = m.slice(0, o)), s && m.sort(et);
+    const b = f * o, d = u.subarray(b, b + o), g = c.subarray(b, b + o);
+    for (let I = 0; I < o; I++)
+      d[I] = m[I].value, g[I] = m[I].index;
+  }
+  const h = e.slice();
+  return h[h.length - 1] = o, [
+    Z(h, n, u),
+    Z(h, "int32", c)
+  ];
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function qn(t, e, n, o) {
+  const s = ht(e, n)[0], r = [1, n[0], 1];
+  for (let m = 0; m < s; m++)
+    r[0] *= n[m];
+  r[1] = n[s];
+  for (let m = s + 1; m < n.length; m++)
+    r[2] *= n[m];
+  const i = /* @__PURE__ */ new Map(), a = new Int32Array(n[s]), u = new mt(r, o, t), c = [], h = r[0] === 1 && r[2] === 1;
+  for (let m = 0; m < n[s]; m++) {
+    let b;
+    if (h)
+      b = t[m].toString();
+    else {
+      const g = [];
+      for (let I = 0; I < r[0]; I++)
+        for (let $ = 0; $ < r[2]; $++)
+          g.push(u.get(I, m, $));
+      b = g.join(",");
+    }
+    const d = i.get(b);
+    if (d != null)
+      a[m] = d;
+    else {
+      const g = i.size;
+      i.set(b, g), a[m] = g, c.push(m);
+    }
+  }
+  const f = r.slice();
+  f[1] = i.size;
+  const w = new mt(f, o);
+  c.forEach((m, b) => {
+    for (let d = 0; d < r[0]; d++)
+      for (let g = 0; g < r[2]; g++)
+        w.set(u.get(d, m, g), d, b, g);
+  });
+  const p = n.slice();
+  return p[s] = f[1], {
+    outputValues: w.values,
+    outputShape: p,
+    indices: a
+  };
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Bn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  addImpl: ke,
+  bincountImpl: Ue,
+  bincountReduceImpl: qe,
+  bitwiseAndImpl: Be,
+  castImpl: We,
+  ceilImpl: Ge,
+  concatImpl: je,
+  equalImpl: Ze,
+  expImpl: He,
+  expm1Impl: Ke,
+  floorDivImpl: Ye,
+  floorImpl: Xe,
+  gatherNdImpl: Je,
+  gatherV2Impl: Qe,
+  greaterEqualImpl: en,
+  greaterImpl: tn,
+  lessEqualImpl: on,
+  lessImpl: nn,
+  linSpaceImpl: sn,
+  logImpl: rn,
+  maxImpl: an,
+  maximumImpl: un,
+  minimumImpl: ln,
+  multiplyImpl: Zt,
+  negImpl: cn,
+  notEqualImpl: hn,
+  prodImpl: dn,
+  raggedGatherImpl: Sn,
+  raggedRangeImpl: bn,
+  raggedTensorToTensorImpl: vn,
+  rangeImpl: En,
+  rsqrtImpl: $n,
+  scatterImpl: On,
+  sigmoidImpl: yn,
+  simpleAbsImpl: ze,
+  sliceImpl: Rn,
+  sparseFillEmptyRowsImpl: Fn,
+  sparseReshapeImpl: Tn,
+  sparseSegmentReductionImpl: Vn,
+  sqrtImpl: An,
+  squaredDifferenceImpl: Ln,
+  staticRegexReplaceImpl: _n,
+  stridedSliceImpl: Mn,
+  stringNGramsImpl: Dn,
+  stringSplitImpl: Cn,
+  stringToHashBucketFastImpl: zn,
+  subImpl: Wn,
+  tileImpl: kn,
+  topKImpl: Un,
+  transposeImpl: fn,
+  uniqueImpl: qn
+}, Symbol.toStringTag, { value: "Module" }));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const { maxImpl: Gn, transposeImpl: jn } = Bn;
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class _t {
+  constructor(e, n) {
+    this.variableNames = ["x"];
+    const { windowSize: o, batchSize: s, inSize: r, outSize: i } = e;
+    this.outputShape = [s, i];
+    const a = Math.floor(o / 4) * 4, u = o % 4;
+    let c = "sumValue += dot(values, ones);";
+    if (n != null) {
+      const f = 1 / n;
+      c = `sumValue += dot(values * ${oe(f) ? f.toPrecision(2) : f}, ones);`;
+    }
+    let h = "";
+    r % o > 0 && (h = `
+        if (inIdx < 0 || inIdx >= ${r}) {
+          return 0.0;
+        }
+      `), this.userCode = `
+      const vec4 ones = vec4(1.0, 1.0, 1.0, 1.0);
+
+      float getValue(int batch, int inIdx) {
+        ${h}
+        return getX(batch, inIdx);
+      }
+
+      void main() {
+        ivec2 coords = getOutputCoords();
+        int batch = coords[0];
+        int outIdx = coords[1];
+        int inOffset = outIdx * ${o};
+
+        float sumValue = 0.0;
+
+        for (int i = 0; i < ${a}; i += 4) {
+          int inIdx = inOffset + i;
+          vec4 values = vec4(
+            getValue(batch, inIdx),
+            getValue(batch, inIdx + 1),
+            getValue(batch, inIdx + 2),
+            getValue(batch, inIdx + 3)
+          );
+
+          ${c}
+        }
+
+        int inIdx = inOffset + ${a};
+        if (${u === 1}) {
+          vec4 values = vec4(getValue(batch, inIdx), 0.0, 0.0, 0.0);
+
+          ${c}
+        } else if (${u === 2}) {
+          vec4 values = vec4(
+            getValue(batch, inIdx),
+            getValue(batch, inIdx + 1), 0.0, 0.0);
+
+          ${c}
+        } else if (${u === 3}) {
+          vec4 values = vec4(
+            getValue(batch, inIdx),
+            getValue(batch, inIdx + 1),
+            getValue(batch, inIdx + 2), 0.0);
+
+          ${c}
+        }
+        setOutput(sumValue);
+      }
+    `;
+  }
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class Zn {
+  constructor(e, n) {
+    this.variableNames = ["x"];
+    const { windowSize: o, batchSize: s, inSize: r, outSize: i } = e;
+    this.outputShape = [s, i];
+    let a = "0.0", u = "";
+    n === "prod" ? a = "1.0" : n === "min" ? (a = "1.0 / 1e-20", u = "min") : n === "max" && (a = "-1.0 / 1e-20", u = "max");
+    let c = `${n}(${n}(${n}(minMaxValue[0], minMaxValue[1]), minMaxValue[2]), minMaxValue[3])`;
+    n === "sum" ? c = "sumValue" : n === "prod" ? c = "prodValue" : n === "all" ? c = "allValue" : n === "any" && (c = "anyValue");
+    const h = Math.floor(o / 4) * 4, f = o % 4;
+    let w = `
+      if (${n === "sum"}) {
+        sumValue += dot(values, ones);
+      } else if (${n === "prod"}) {
+        vec2 tmp = vec2(values[0], values[1]) * vec2(values[2], values[3]);
+        prodValue *= tmp[0] * tmp[1];
+      } else {
+        minMaxValue = ${u}(values, minMaxValue);
+        if (${n === "min"} || ${n === "max"}) {
+          minMaxValue = ${u}(values, minMaxValue);
+          bvec4 isNaN = isnan(values);
+          if (isNaN.r || isNaN.g || isNaN.b || isNaN.a) {
+            minMaxValue = vec4(NAN);
+          }
+        }
+      }
+    `, p = "vec4";
+    n === "all" ? (a = "1.0", w = `
+        bool reducedAllValue = all(values);
+        float floatedReducedAllValue = float(reducedAllValue);
+        allValue = float(allValue >= 1.0 && floatedReducedAllValue >= 1.0);
+      `, p = "bvec4") : n === "any" && (a = "0.0", w = `
+        bool reducedAnyValue = any(values);
+        float floatedReducedAnyValue = float(reducedAnyValue);
+        anyValue = float(anyValue >= 1.0 || floatedReducedAnyValue >= 1.0);
+      `, p = "bvec4");
+    let m = "";
+    r % o > 0 && (m = `
+        if (inIdx < 0 || inIdx >= ${r}) {
+          return initializationValue;
+        }
+      `), this.userCode = `
+      const float initializationValue = ${a};
+      const vec4 ones = vec4(1.0, 1.0, 1.0, 1.0);
+
+      float getValue(int batch, int inIdx) {
+        ${m}
+        return getX(batch, inIdx);
+      }
+
+      void main() {
+        ivec2 coords = getOutputCoords();
+        int batch = coords[0];
+        int outIdx = coords[1];
+        int inOffset = outIdx * ${o};
+
+        vec4 minMaxValue = vec4(${a});
+        float prodValue = 1.0;
+        float sumValue = 0.0;
+        float allValue = 1.0;
+        float anyValue = 0.0;
+
+        for (int i = 0; i < ${h}; i += 4) {
+          int inIdx = inOffset + i;
+          ${p} values = ${p}(
+            getValue(batch, inIdx),
+            getValue(batch, inIdx + 1),
+            getValue(batch, inIdx + 2),
+            getValue(batch, inIdx + 3)
+          );
+
+          ${w}
+        }
+
+        int inIdx = inOffset + ${h};
+        if (${f === 1}) {
+          ${p} values = ${p}(
+            getValue(batch, inIdx),
+            initializationValue,
+            initializationValue,
+            initializationValue
+          );
+
+          ${w}
+        } else if (${f === 2}) {
+          ${p} values = ${p}(
+            getValue(batch, inIdx),
+            getValue(batch, inIdx + 1),
+            initializationValue,
+            initializationValue
+          );
+
+          ${w}
+        } else if (${f === 3}) {
+          ${p} values = ${p}(
+            getValue(batch, inIdx),
+            getValue(batch, inIdx + 1),
+            getValue(batch, inIdx + 2),
+            initializationValue
+          );
+
+          ${w}
+        }
+        setOutput(${c});
+      }
+    `;
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Hn(t) {
+  const e = [];
+  for (; e.length === 0 || e[e.length - 1].outSize !== 1; ) {
+    const n = e.length ? e[e.length - 1].outSize : t[1], o = ye(n);
+    e.push({
+      inSize: n,
+      windowSize: o,
+      outSize: Math.ceil(n / o)
+    });
+  }
+  return e;
+}
+function Kt(t, e, n, o) {
+  const s = Hn(t.shape);
+  let r = t;
+  for (let i = 0; i < s.length; i++) {
+    const { inSize: a, windowSize: u, outSize: c } = s[i];
+    let h, f;
+    n === "mean" ? h = i === 0 ? new _t({ windowSize: u, inSize: a, batchSize: t.shape[0], outSize: c }, a) : new _t({ windowSize: u, inSize: a, batchSize: t.shape[0], outSize: c }) : h = new Zn({ windowSize: u, inSize: a, batchSize: t.shape[0], outSize: c }, n), f = r, r = o.runWebGLProgram(h, [r], e), f.dataId !== t.dataId && o.disposeIntermediateTensorInfo(f);
+  }
+  return r;
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Kn(t, e, n = "index") {
+  const o = K(e);
+  return o.map((s, r) => {
+    const i = `int ${t[r]} = ${n} / ${s}`, a = r === o.length - 1 ? `int ${t[r + 1]} = ${n} - ${t[r]} * ${s}` : `index -= ${t[r]} * ${s}`;
+    return `${i}; ${a};`;
+  }).join("");
+}
+function Xn(t, e) {
+  const n = t.length, o = t.map((r) => `${e}[${r}]`), s = new Array(n - 1);
+  s[n - 2] = o[n - 1];
+  for (let r = n - 3; r >= 0; --r)
+    s[r] = `(${s[r + 1]} * ${o[r + 1]})`;
+  return s;
+}
+function Yn(t, e, n = "index") {
+  const o = t.map((r, i) => i), s = Xn(o, e);
+  return s.map((r, i) => {
+    const a = `int ${t[i]} = ${n} / ${s[i]}`, u = i === s.length - 1 ? `int ${t[i + 1]} = ${n} - ${t[i]} * ${s[i]}` : `index -= ${t[i]} * ${s[i]}`;
+    return `${a}; ${u};`;
+  }).join("");
+}
+function Jn(t) {
+  const e = K(t).map((n) => n.toString());
+  return `
+  int getFlatIndex(ivec3 coords) {
+    return coords.x * ${e[0]} + coords.y * ${e[1]} + coords.z;
+  }
+`;
+}
+function Qn() {
+  return `
+  int getFlatIndex(ivec3 coords) {
+    return coords.x * outShapeStrides[0] + coords.y * outShapeStrides[1] + coords.z;
+  }
+`;
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Et(t) {
+  if (t <= 1)
+    return "int";
+  if (t === 2)
+    return "ivec2";
+  if (t === 3)
+    return "ivec3";
+  if (t === 4)
+    return "ivec4";
+  if (t === 5)
+    return "ivec5";
+  if (t === 6)
+    return "ivec6";
+  throw Error(`GPU for rank ${t} is not yet supported`);
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Mt(t, e = 2) {
+  return y(t.slice(0, t.length - e));
+}
+function Nt(t) {
+  if (t.length === 0)
+    throw Error("Cannot get rows and columns of an empty shape array.");
+  return [
+    t.length > 1 ? t[t.length - 2] : 1,
+    t[t.length - 1]
+  ];
+}
+function at(t) {
+  return t % 2 === 0;
+}
+function Dt(t, e) {
+  if (t = t.slice(-2), e = e.slice(-2), se(t, e) || !t.length || !e.length || t[0] === 0 || t[1] === 0 || e[0] === 0 || e[1] === 0)
+    return !0;
+  if (t.length !== e.length) {
+    const n = t[t.length - 1], o = e[e.length - 1];
+    if (n === o || at(n) && at(o) && (t[0] === 1 || e[0] === 1))
+      return !0;
+  }
+  return t[1] === e[1] && at(t[0]) && at(e[0]);
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function $t(t) {
+  return St().getBool("WEBGL_USE_SHAPES_UNIFORMS") && t <= 4;
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class to {
+  constructor(e, n) {
+    this.variableNames = ["A"], this.packedInputs = !0, this.packedOutput = !0, this.customUniforms = [{ name: "inputShape", type: "ivec3" }], this.outputShape = e, this.enableShapeUniforms = $t(this.outputShape.length);
+    let o = "";
+    for (let s = 0; s < 4; s++) {
+      let r = "thisRC = rc;";
+      s % 2 === 1 && (r += "thisRC.z += 1;"), s > 1 && (r += "thisRC.y += 1;"), o += `
+        ${r}
+        ${s > 0 ? "if(thisRC.y < rows && thisRC.z < cols){" : ""}
+          int flatIndex = getFlatIndex(thisRC);
+
+          ivec3 inputRC = inputCoordsFromReshapedOutCoords(flatIndex);
+          vec2 inputRCInnerDims = vec2(float(inputRC.y),float(inputRC.z));
+
+          result[${s}] =
+            getChannel(getA(inputRC.x, inputRC.y, inputRC.z), inputRCInnerDims);
+        ${s > 0 ? "}" : ""}
+      `;
+    }
+    this.userCode = `
+      ${eo(n, this.enableShapeUniforms)}
+      ${this.enableShapeUniforms ? Qn() : Jn(e)}
+
+      void main() {
+        ivec3 rc = getOutputCoords();
+
+        vec4 result = vec4(0.);
+
+        ivec3 thisRC;
+        int rows = ${this.enableShapeUniforms ? "outShape[1]" : e[1]};
+        int cols = ${this.enableShapeUniforms ? "outShape[2]" : e[2]};
+
+        ${o}
+
+        setOutput(result);
+      }
+    `;
+  }
+}
+function eo(t, e) {
+  return `
+    ivec3 inputCoordsFromReshapedOutCoords(int index) {
+      ${e ? Yn(["r", "c", "d"], "inputShape") : Kn(["r", "c", "d"], t)}
+      return ivec3(r, c, d);
+    }
+  `;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function no(t, e, n) {
+  const o = [
+    Mt(t.shape),
+    ...Nt(t.shape)
+  ], s = {
+    dtype: t.dtype,
+    shape: o,
+    dataId: t.dataId
+  }, r = [
+    Mt(e),
+    ...Nt(e)
+  ], i = new to(r, o), a = !0, u = [o], c = n.runWebGLProgram(i, [s], t.dtype, u, a);
+  return { dataId: c.dataId, shape: e, dtype: c.dtype };
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function st(t) {
+  const { inputs: e, backend: n, attrs: o } = t, { x: s } = e, { shape: r } = o, i = n, a = y(s.shape), u = re(r, a), c = y(u);
+  zt(a === c, () => `The new shape (${u}) has ${c} elements and the old shape (${s.shape}) has ${a} elements. The new shape and old shape must have the same number of elements.`);
+  const h = i.texData.get(s.dataId);
+  return h.isPacked && !Dt(s.shape, u) && !(h.texture !== null && Dt(h.shape, u)) ? no(s, u, i) : (i.incRef(s.dataId), { dataId: s.dataId, shape: u, dtype: s.dtype });
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function oo(t, e, n, o) {
+  const s = y(e), i = y(t.shape) / s, a = st({ inputs: { x: t }, attrs: { shape: [i, s] }, backend: o }), u = Kt(a, t.dtype, "max", o), c = st({ inputs: { x: u }, attrs: { shape: n }, backend: o });
+  return o.disposeIntermediateTensorInfo(a), o.disposeIntermediateTensorInfo(u), c;
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class so {
+  constructor(e, n) {
+    this.variableNames = ["A"];
+    const o = new Array(e.length);
+    for (let i = 0; i < o.length; i++)
+      o[i] = e[n[i]];
+    this.outputShape = o, this.rank = o.length;
+    const s = Et(this.rank), r = ro(n);
+    this.userCode = `
+    void main() {
+      ${s} resRC = getOutputCoords();
+      setOutput(getA(${r}));
+    }
+    `;
+  }
+}
+function ro(t) {
+  const e = t.length;
+  if (e > 6)
+    throw Error(`Transpose for rank ${e} is not yet supported`);
+  const n = ["resRC.x", "resRC.y", "resRC.z", "resRC.w", "resRC.u", "resRC.v"], o = new Array(e);
+  for (let s = 0; s < t.length; s++)
+    o[t[s]] = n[s];
+  return o.join();
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Xt(t, e) {
+  return ["x", "y", "z", "w", "u", "v"].slice(0, e).map((n) => `${t}.${n}`);
+}
+function io(t, e) {
+  return e === 1 ? [t] : Xt(t, e);
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class ao {
+  constructor(e, n) {
+    this.variableNames = ["A"], this.packedInputs = !0, this.packedOutput = !0;
+    const o = new Array(e.length);
+    for (let h = 0; h < o.length; h++)
+      o[h] = e[n[h]];
+    if (this.outputShape = o, this.rank = o.length, this.rank > 6)
+      throw Error(`Packed transpose for rank ${this.rank} is not yet supported.`);
+    const s = Et(this.rank), r = Xt("rc", this.rank), i = new Array(this.rank);
+    for (let h = 0; h < n.length; h++)
+      i[n[h]] = r[h];
+    const a = `vec2(${i.slice(-2).join()})`, u = `++${r[this.rank - 1]} < ${o[this.rank - 1]}`, c = `getChannel(getA(${i.join()}), ${a})`;
+    this.userCode = `
+    void main() {
+      ${s} rc = getOutputCoords();
+      vec4 result = vec4(0.);
+      result[0] = ${c};
+      if(${u}) {
+        result[1] = ${c};
+      }
+      --${r[this.rank - 1]};
+      if(++${r[this.rank - 2]} < ${o[this.rank - 2]}) {
+        result[2] = ${c};
+        if(${u}) {
+          result[3] = ${c};
+        }
+      }
+      setOutput(result);
+    }
+    `;
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Yt(t, e, n) {
+  const o = St().getBool("WEBGL_PACK_ARRAY_OPERATIONS") ? new ao(t.shape, e) : new so(t.shape, e);
+  return n.runWebGLProgram(o, [t], t.dtype);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function uo(t) {
+  const { inputs: e, backend: n, attrs: o } = t, { x: s } = e, { reductionIndices: r, keepDims: i } = o, a = s.shape.length, u = ht(r, s.shape);
+  let c = u;
+  const h = Wt(c, a), f = h != null, w = n.shouldExecuteOnCPU([s]);
+  let p = s;
+  if (f) {
+    if (w) {
+      const $ = n.texData.get(p.dataId).values, E = new Array(a);
+      for (let A = 0; A < E.length; A++)
+        E[A] = s.shape[h[A]];
+      const F = jn($, s.shape, s.dtype, h, E);
+      p = n.makeTensorInfo(E, s.dtype);
+      const M = n.texData.get(p.dataId);
+      M.values = F;
+    } else
+      p = Yt(s, h, n);
+    c = kt(c.length, a);
+  }
+  Ut("max", c, a);
+  const [m, b] = bt(p.shape, c);
+  let d = m;
+  i && (d = vt(m, u));
+  let g;
+  if (w) {
+    const $ = n.texData.get(p.dataId).values, E = Gn($, y(b), d, s.dtype);
+    g = n.makeTensorInfo(d, s.dtype);
+    const F = n.texData.get(g.dataId);
+    F.values = E;
+  } else
+    g = oo(p, b, d, n);
+  return f && n.disposeIntermediateTensorInfo(p), g;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function lo(t, e, n, o) {
+  const s = e, r = t.shape.length, i = ht(s, t.shape);
+  let a = i;
+  const u = Wt(a, r), c = u != null;
+  let h = t;
+  c && (h = Yt(t, u, o), a = kt(a.length, r)), Ut("sum", a, r);
+  const [f, w] = bt(h.shape, a);
+  let p = f;
+  n && (p = vt(f, i));
+  const m = y(w), d = y(t.shape) / m, g = st({ inputs: { x: h }, attrs: { shape: [d, m] }, backend: o }), I = ie(t.dtype), $ = Kt(g, I, "sum", o), E = st({ inputs: { x: $ }, attrs: { shape: p }, backend: o });
+  return o.disposeIntermediateTensorInfo(g), o.disposeIntermediateTensorInfo($), c && o.disposeIntermediateTensorInfo(h), E;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function co(t) {
+  const { inputs: e, backend: n, attrs: o } = t, { x: s } = e, { axis: r, keepDims: i } = o;
+  return lo(s, r, i, n);
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class Pt {
+  constructor(e, n, o) {
+    this.variableNames = ["A", "B"], this.outputShape = It(n, o), this.enableShapeUniforms = $t(this.outputShape.length), this.userCode = `
+      float binaryOperation(float a, float b) {
+        ${e}
+      }
+
+      void main() {
+        float a = getAAtOutCoords();
+        float b = getBAtOutCoords();
+        setOutput(binaryOperation(a, b));
+      }
+    `;
+  }
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class ho {
+  constructor(e, n, o, s = !1) {
+    this.variableNames = ["A", "B"], this.supportsBroadcasting = !0, this.packedInputs = !0, this.packedOutput = !0, this.outputShape = It(n, o);
+    const r = this.outputShape.length;
+    this.enableShapeUniforms = $t(r);
+    let i = "";
+    if (s)
+      if (r === 0 || y(this.outputShape) === 1)
+        i = `
+          result.y = 0.;
+          result.z = 0.;
+          result.w = 0.;
+        `;
+      else if (i = `
+          ${Et(r)} coords = getOutputCoords();
+        `, r === 1)
+        this.enableShapeUniforms ? i += `
+            result.y = (coords + 1) >= outShape ? 0. : result.y;
+            result.z = 0.;
+            result.w = 0.;
+          ` : i += `
+            result.y = (coords + 1) >= ${this.outputShape[0]} ? 0. : result.y;
+            result.z = 0.;
+            result.w = 0.;
+          `;
+      else {
+        const u = io("coords", r);
+        this.enableShapeUniforms ? i += `
+            bool nextRowOutOfBounds =
+              (${u[r - 2]} + 1) >= outShape[${r} - 2];
+            bool nextColOutOfBounds =
+              (${u[r - 1]} + 1) >= outShape[${r} - 1];
+            result.y = nextColOutOfBounds ? 0. : result.y;
+            result.z = nextRowOutOfBounds ? 0. : result.z;
+            result.w = nextColOutOfBounds || nextRowOutOfBounds ? 0. : result.w;
+          ` : i += `
+            bool nextRowOutOfBounds =
+              (${u[r - 2]} + 1) >= ${this.outputShape[r - 2]};
+            bool nextColOutOfBounds =
+              (${u[r - 1]} + 1) >= ${this.outputShape[r - 1]};
+            result.y = nextColOutOfBounds ? 0. : result.y;
+            result.z = nextRowOutOfBounds ? 0. : result.z;
+            result.w = nextColOutOfBounds || nextRowOutOfBounds ? 0. : result.w;
+          `;
+      }
+    this.userCode = `
+      vec4 binaryOperation(vec4 a, vec4 b) {
+        ${e}
+      }
+
+      void main() {
+        vec4 a = getAAtOutCoords();
+        vec4 b = getBAtOutCoords();
+
+        vec4 result = binaryOperation(a, b);
+        ${i}
+
+        setOutput(result);
+      }
+    `;
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Ct(t) {
+  const { inputs: e, backend: n } = t, { x: o } = e;
+  return n.incRef(o.dataId), { dataId: o.dataId, shape: o.shape, dtype: o.dtype };
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function fo(t) {
+  const { inputs: e, backend: n } = t, { real: o, imag: s } = e, r = n.makeTensorInfo(o.shape, "complex64"), i = n.texData.get(r.dataId), a = Ct({ inputs: { x: o }, backend: n }), u = Ct({ inputs: { x: s }, backend: n });
+  return i.complexTensorInfos = { real: a, imag: u }, r;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function go({ opSnippet: t, packedOpSnippet: e, checkOutOfBounds: n = !1, supportsComplex: o = !1, cpuKernelImpl: s, dtype: r }) {
+  return ({ inputs: i, backend: a }) => {
+    const { a: u, b: c } = i, h = a;
+    if (o && u.dtype === "complex64") {
+      const m = h.texData.get(u.dataId), b = h.texData.get(c.dataId), [d, g] = [
+        [m.complexTensorInfos.real, b.complexTensorInfos.real],
+        [m.complexTensorInfos.imag, b.complexTensorInfos.imag]
+      ].map(($) => {
+        const [E, F] = $, M = {
+          dataId: E.dataId,
+          dtype: E.dtype,
+          shape: u.shape
+        }, A = {
+          dataId: F.dataId,
+          dtype: F.dtype,
+          shape: c.shape
+        }, L = new Pt(t, u.shape, c.shape);
+        return h.runWebGLProgram(L, [M, A], pt(E.dtype, F.dtype));
+      }), I = fo({ inputs: { real: d, imag: g }, backend: h });
+      return h.disposeIntermediateTensorInfo(d), h.disposeIntermediateTensorInfo(g), I;
+    }
+    const f = r || pt(u.dtype, c.dtype);
+    if ((u.dtype === "string" || c.dtype === "string" || h.shouldExecuteOnCPU([u, c])) && s != null) {
+      const m = h.texData.get(u.dataId).values, b = h.texData.get(c.dataId).values, d = u.dtype === "string" ? (
+        // tslint:disable-next-line: no-any
+        lt(m)
+      ) : m, g = u.dtype === "string" ? (
+        // tslint:disable-next-line: no-any
+        lt(b)
+      ) : b, [I, $] = s(u.shape, c.shape, d, g, f), E = h.makeTensorInfo($, f), F = h.texData.get(E.dataId);
+      return F.values = I, E;
+    }
+    const w = St().getBool("WEBGL_PACK_BINARY_OPERATIONS") && e != null;
+    let p;
+    return w ? p = new ho(e, u.shape, c.shape, n) : p = new Pt(t, u.shape, c.shape), h.runWebGLProgram(p, [u, c], f);
+  };
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const po = `
+if (a == b) {
+  return 1.0;
+};
+return a / b;`, mo = `
+  // vec4 one = vec4(equal(a, b));
+  // return one + (vec4(1.0) - one) * a / b;
+  vec4 result = a / b;
+  if(a.x == b.x) {
+    result.x = 1.;
+  }
+  if(a.y == b.y) {
+    result.y = 1.;
+  }
+  if(a.z == b.z) {
+    result.z = 1.;
+  }
+  if(a.w == b.w) {
+    result.w = 1.;
+  }
+
+  return result;
+`, wo = go({ opSnippet: po, packedOpSnippet: mo, checkOutOfBounds: !0 });
+class Io {
+  variableNames = ["logits", "maxLogits"];
+  outputShape;
+  userCode;
+  constructor(e) {
+    this.outputShape = e, this.userCode = `
+        void main() {
+        ivec4 coords = getOutputCoords(); // [batch, nh, t1, t2]
+            int b = coords.x;
+            int h = coords.y;
+            int t1 = coords.z;
+            int t2 = coords.w;
+            float x = getLogitsAtOutCoords();
+            float maxLogit = getMaxLogits(b, h, t1);
+            setOutput(exp(x - maxLogit));
+        }
+        `;
+  }
+}
+class xo {
+  variableNames = ["exp", "sum"];
+  outputShape;
+  userCode;
+  customUniforms = [
+    { name: "dropoutRate", type: "float" },
+    { name: "seed", type: "float" }
+  ];
+  constructor(e) {
+    this.outputShape = e, this.userCode = `
+        float random(ivec4 coords) {
+            float x = float(coords.x * 4096 + coords.y * 256 + coords.z * 16 + coords.w);
+            return fract(sin(seed + x) * 43758.5453123);
+        }
+        void main() {
+            ivec4 coords = getOutputCoords();
+            float numerator = getExp(coords.x, coords.y, coords.z, coords.w);
+            float denominator = getSum(coords.x, coords.y, coords.z, coords.w);
+            float val = numerator / denominator;
+            float keepProb = 1.0 - dropoutRate;
+            float rand = random(coords);
+            float mask = step(rand, keepProb);
+            setOutput(val * mask / keepProb);
+        }
+        `;
+  }
+}
+function So(t) {
+  const { inputs: e, attrs: n } = t, { logits: o } = e, { dim: s, dropoutRate: r, seed: i } = n, a = t.backend;
+  if (!o)
+    throw new Error("Error in softmax: input logits is null");
+  const u = ht([s], o.shape), c = uo({
+    inputs: { x: o },
+    backend: a,
+    attrs: { reductionIndices: u, keepDims: !1 }
+  }), h = vt(c.shape, u), f = new Io(o.shape), w = a.runWebGLProgram(f, [o, c], "float32"), p = co({ inputs: { x: w }, backend: a, attrs: { axis: u, keepDims: !1 } }), m = st({ inputs: { x: p }, backend: a, attrs: { shape: h } });
+  if (r !== void 0 && r > 0) {
+    const d = new xo(o.shape), g = a.runWebGLProgram(d, [w, m], "float32", [
+      [r],
+      [i ?? Math.random() * 1e4]
+    ]);
+    return a.disposeIntermediateTensorInfo(c), a.disposeIntermediateTensorInfo(w), a.disposeIntermediateTensorInfo(p), a.disposeIntermediateTensorInfo(m), g;
+  }
+  const b = wo({ inputs: { a: w, b: m }, backend: a });
+  return a.disposeIntermediateTensorInfo(c), a.disposeIntermediateTensorInfo(w), a.disposeIntermediateTensorInfo(p), a.disposeIntermediateTensorInfo(m), b;
+}
+const bo = {
+  kernelName: "FusedSoftmax",
+  backendName: "webgl",
+  kernelFunc: So
+};
+ae(bo);
+export {
+  So as softmax
+};