@genai-fi/nanogpt 0.5.5 → 0.6.0

package/dist/ops/webgl/fusedSoftmax.js

@@ -1,2703 +1,11 @@
-import { a_ as qt, q as y, Q as Ct, ac as J, a$ as nt, b0 as It, b1 as pt, b2 as ft, b3 as kt, Z as ot, ak as B, b4 as q, b5 as Ut, U as Gt, l as jt, t as Zt, b6 as dt, an as ct, b7 as tt, a1 as ut, b8 as Bt, N as Ht, b9 as Kt, r as Xt } from "../../index-Du-bmOP8.js";
-import { f as $t, a as Qt, g as yt, b as Yt, c as Jt } from "../../kernel_funcs_utils-DShm7-0k.js";
-import { c as mt, g as Tt, a as Vt, b as Mt, e as wt } from "../../axis_util-BczFISHz.js";
-import { b as te } from "../../broadcast_to-B7NGsBSh.js";
-import { r as ee } from "../../reshape-BH7eBpwq.js";
-import { i as ne, c as oe } from "../../slice_util-DskXqRZa.js";
-import { g as se } from "../../_commonjsHelpers-ByX85dGu.js";
-import { r as st } from "../../Reshape-Biok_3X1.js";
-function re(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 ht, xt;
-function ie() {
-  if (xt) return ht;
-  xt = 1, ht = 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(I, l, E) {
-    this.low = I | 0, this.high = l | 0, this.unsigned = !!E;
-  }
-  e.prototype.__isLong__, Object.defineProperty(e.prototype, "__isLong__", { value: !0 });
-  function n(I) {
-    return (I && I.__isLong__) === !0;
-  }
-  e.isLong = n;
-  var o = {}, s = {};
-  function r(I, l) {
-    var E, F, T;
-    return l ? (I >>>= 0, (T = 0 <= I && I < 256) && (F = s[I], F) ? F : (E = i(I, (I | 0) < 0 ? -1 : 0, !0), T && (s[I] = E), E)) : (I |= 0, (T = -128 <= I && I < 128) && (F = o[I], F) ? F : (E = i(I, I < 0 ? -1 : 0, !1), T && (o[I] = E), E));
-  }
-  e.fromInt = r;
-  function a(I, l) {
-    if (isNaN(I))
-      return l ? x : g;
-    if (l) {
-      if (I < 0)
-        return x;
-      if (I >= m)
-        return L;
-    } else {
-      if (I <= -v)
-        return _;
-      if (I + 1 >= v)
-        return D;
-    }
-    return I < 0 ? a(-I, l).neg() : i(I % p | 0, I / p | 0, l);
-  }
-  e.fromNumber = a;
-  function i(I, l, E) {
-    return new e(I, l, E);
-  }
-  e.fromBits = i;
-  var u = Math.pow;
-  function c(I, l, E) {
-    if (I.length === 0)
-      throw Error("empty string");
-    if (I === "NaN" || I === "Infinity" || I === "+Infinity" || I === "-Infinity")
-      return g;
-    if (typeof l == "number" ? (E = l, l = !1) : l = !!l, E = E || 10, E < 2 || 36 < E)
-      throw RangeError("radix");
-    var F;
-    if ((F = I.indexOf("-")) > 0)
-      throw Error("interior hyphen");
-    if (F === 0)
-      return c(I.substring(1), l, E).neg();
-    for (var T = a(u(E, 8)), $ = g, N = 0; N < I.length; N += 8) {
-      var k = Math.min(8, I.length - N), G = parseInt(I.substring(N, N + k), E);
-      if (k < 8) {
-        var z = a(u(E, k));
-        $ = $.mul(z).add(a(G));
-      } else
-        $ = $.mul(T), $ = $.add(a(G));
-    }
-    return $.unsigned = l, $;
-  }
-  e.fromString = c;
-  function h(I, l) {
-    return typeof I == "number" ? a(I, l) : typeof I == "string" ? c(I, l) : i(I.low, I.high, typeof l == "boolean" ? l : I.unsigned);
-  }
-  e.fromValue = h;
-  var f = 65536, w = 1 << 24, p = f * f, m = p * p, v = m / 2, d = r(w), g = r(0);
-  e.ZERO = g;
-  var x = r(0, !0);
-  e.UZERO = x;
-  var O = r(1);
-  e.ONE = O;
-  var b = r(1, !0);
-  e.UONE = b;
-  var V = r(-1);
-  e.NEG_ONE = V;
-  var D = i(-1, 2147483647, !1);
-  e.MAX_VALUE = D;
-  var L = i(-1, -1, !0);
-  e.MAX_UNSIGNED_VALUE = L;
-  var _ = i(0, -2147483648, !1);
-  e.MIN_VALUE = _;
-  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(_)) {
-        var E = a(l), F = this.div(E), T = F.mul(E).sub(this);
-        return F.toString(l) + T.toInt().toString(l);
-      } else
-        return "-" + this.neg().toString(l);
-    for (var $ = a(u(l, 6), this.unsigned), N = this, k = ""; ; ) {
-      var G = N.div($), z = N.sub(G.mul($)).toInt() >>> 0, M = z.toString(l);
-      if (N = G, N.isZero())
-        return M + k;
-      for (; M.length < 6; )
-        M = "0" + M;
-      k = "" + M + k;
-    }
-  }, 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(_) ? 64 : this.neg().getNumBitsAbs();
-    for (var l = this.high != 0 ? this.high : this.low, E = 31; E > 0 && (l & 1 << E) == 0; E--)
-      ;
-    return this.high != 0 ? E + 33 : E + 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 E = this.isNegative(), F = l.isNegative();
-    return E && !F ? -1 : !E && F ? 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(_) ? _ : this.not().add(O);
-  }, S.neg = S.negate, S.add = function(l) {
-    n(l) || (l = h(l));
-    var E = this.high >>> 16, F = this.high & 65535, T = this.low >>> 16, $ = this.low & 65535, N = l.high >>> 16, k = l.high & 65535, G = l.low >>> 16, z = l.low & 65535, M = 0, j = 0, P = 0, U = 0;
-    return U += $ + z, P += U >>> 16, U &= 65535, P += T + G, j += P >>> 16, P &= 65535, j += F + k, M += j >>> 16, j &= 65535, M += E + N, M &= 65535, i(P << 16 | U, M << 16 | j, 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 E = t.mul(
-        this.low,
-        this.high,
-        l.low,
-        l.high
-      );
-      return i(E, t.get_high(), this.unsigned);
-    }
-    if (l.isZero())
-      return g;
-    if (this.eq(_))
-      return l.isOdd() ? _ : g;
-    if (l.eq(_))
-      return this.isOdd() ? _ : 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 a(this.toNumber() * l.toNumber(), this.unsigned);
-    var F = this.high >>> 16, T = this.high & 65535, $ = this.low >>> 16, N = this.low & 65535, k = l.high >>> 16, G = l.high & 65535, z = l.low >>> 16, M = l.low & 65535, j = 0, P = 0, U = 0, rt = 0;
-    return rt += N * M, U += rt >>> 16, rt &= 65535, U += $ * M, P += U >>> 16, U &= 65535, U += N * z, P += U >>> 16, U &= 65535, P += T * M, j += P >>> 16, P &= 65535, P += $ * z, j += P >>> 16, P &= 65535, P += N * G, j += P >>> 16, P &= 65535, j += F * M + T * z + $ * G + N * k, j &= 65535, i(U << 16 | rt, j << 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 E = (this.unsigned ? t.div_u : t.div_s)(
-        this.low,
-        this.high,
-        l.low,
-        l.high
-      );
-      return i(E, t.get_high(), this.unsigned);
-    }
-    if (this.isZero())
-      return this.unsigned ? x : g;
-    var F, T, $;
-    if (this.unsigned) {
-      if (l.unsigned || (l = l.toUnsigned()), l.gt(this))
-        return x;
-      if (l.gt(this.shru(1)))
-        return b;
-      $ = x;
-    } else {
-      if (this.eq(_)) {
-        if (l.eq(O) || l.eq(V))
-          return _;
-        if (l.eq(_))
-          return O;
-        var N = this.shr(1);
-        return F = N.div(l).shl(1), F.eq(g) ? l.isNegative() ? O : V : (T = this.sub(l.mul(F)), $ = F.add(T.div(l)), $);
-      } else if (l.eq(_))
-        return this.unsigned ? x : 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();
-      $ = g;
-    }
-    for (T = this; T.gte(l); ) {
-      F = Math.max(1, Math.floor(T.toNumber() / l.toNumber()));
-      for (var k = Math.ceil(Math.log(F) / Math.LN2), G = k <= 48 ? 1 : u(2, k - 48), z = a(F), M = z.mul(l); M.isNegative() || M.gt(T); )
-        F -= G, z = a(F, this.unsigned), M = z.mul(l);
-      z.isZero() && (z = O), $ = $.add(z), T = T.sub(M);
-    }
-    return $;
-  }, S.div = S.divide, S.modulo = function(l) {
-    if (n(l) || (l = h(l)), t) {
-      var E = (this.unsigned ? t.rem_u : t.rem_s)(
-        this.low,
-        this.high,
-        l.low,
-        l.high
-      );
-      return i(E, 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 i(~this.low, ~this.high, this.unsigned);
-  }, S.and = function(l) {
-    return n(l) || (l = h(l)), i(this.low & l.low, this.high & l.high, this.unsigned);
-  }, S.or = function(l) {
-    return n(l) || (l = h(l)), i(this.low | l.low, this.high | l.high, this.unsigned);
-  }, S.xor = function(l) {
-    return n(l) || (l = h(l)), i(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 ? i(this.low << l, this.high << l | this.low >>> 32 - l, this.unsigned) : i(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 ? i(this.low >>> l | this.high << 32 - l, this.high >> l, this.unsigned) : i(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 E = this.high;
-    if (l < 32) {
-      var F = this.low;
-      return i(F >>> l | E << 32 - l, E >>> l, this.unsigned);
-    } else return l === 32 ? i(E, 0, this.unsigned) : i(E >>> l - 32, 0, this.unsigned);
-  }, S.shru = S.shiftRightUnsigned, S.shr_u = S.shiftRightUnsigned, S.toSigned = function() {
-    return this.unsigned ? i(this.low, this.high, !1) : this;
-  }, S.toUnsigned = function() {
-    return this.unsigned ? this : i(this.low, this.high, !0);
-  }, S.toBytes = function(l) {
-    return l ? this.toBytesLE() : this.toBytesBE();
-  }, S.toBytesLE = function() {
-    var l = this.high, E = this.low;
-    return [
-      E & 255,
-      E >>> 8 & 255,
-      E >>> 16 & 255,
-      E >>> 24,
-      l & 255,
-      l >>> 8 & 255,
-      l >>> 16 & 255,
-      l >>> 24
-    ];
-  }, S.toBytesBE = function() {
-    var l = this.high, E = this.low;
-    return [
-      l >>> 24,
-      l >>> 16 & 255,
-      l >>> 8 & 255,
-      l & 255,
-      E >>> 24,
-      E >>> 16 & 255,
-      E >>> 8 & 255,
-      E & 255
-    ];
-  }, e.fromBytes = function(l, E, F) {
-    return F ? e.fromBytesLE(l, E) : e.fromBytesBE(l, E);
-  }, e.fromBytesLE = function(l, E) {
-    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,
-      E
-    );
-  }, e.fromBytesBE = function(l, E) {
-    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],
-      E
-    );
-  }, ht;
-}
-var Lt = ie();
-const _t = /* @__PURE__ */ se(Lt), ae = /* @__PURE__ */ re({
-  __proto__: null,
-  default: _t
-}, [Lt]);
-/**
- * @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 Y = (
-  // tslint:disable-next-line
-  _t || ae
-);
-function lt(t) {
-  return Y.fromString(t, !0, 16);
-}
-const Nt = lt("c3a5c85c97cb3127"), Q = lt("b492b66fbe98f273"), W = lt("9ae16a3b2f90404f");
-function gt(t) {
-  return t.xor(t.shru(47));
-}
-function At(t, e, n) {
-  const o = t.slice(e, e + n);
-  return Y.fromBytes(Array.from(o), !0, !0);
-}
-function R(t, e) {
-  return At(t, e, 8);
-}
-function St(t, e) {
-  return At(t, e, 4);
-}
-function A(t, e) {
-  return e === 0 ? t : t.shru(e).or(t.shl(64 - e));
-}
-function X(t, e, n = lt("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 ue(t, e, n, o, s, r) {
-  s = s.add(t), r = A(r.add(s).add(o), 21);
-  const a = s;
-  return s = s.add(e), s = s.add(n), r = r.add(A(s, 44)), [s.add(o), r.add(a)];
-}
-function it(t, e, n, o) {
-  return ue(R(t, e), R(t, e + 8), R(t, e + 16), R(t, e + 24), n, o);
-}
-function le(t, e = t.length) {
-  if (e >= 8) {
-    const n = W.add(e * 2), o = R(t, 0).add(W), s = R(t, e - 8), r = A(s, 37).mul(n).add(o), a = A(o, 25).add(s).mul(n);
-    return X(r, a, n);
-  }
-  if (e >= 4) {
-    const n = W.add(e * 2), o = St(t, 0);
-    return X(o.shl(3).add(e), St(t, e - 4), n);
-  }
-  if (e > 0) {
-    const n = t[0], o = t[e >> 1], s = t[e - 1], r = n + (o << 8), a = e + (s << 2);
-    return gt(W.mul(r).xor(Nt.mul(a))).mul(W);
-  }
-  return W;
-}
-function ce(t, e = t.length) {
-  const n = W.add(e * 2), o = R(t, 0).mul(Q), s = R(t, 8), r = R(t, e - 8).mul(n), a = R(t, e - 16).mul(W);
-  return X(A(o.add(s), 43).add(A(r, 30)).add(a), o.add(A(s.add(W), 18)).add(r), n);
-}
-function he(t, e = t.length) {
-  const n = W.add(e * 2), o = R(t, 0).mul(W), s = R(t, 8), r = R(t, e - 8).mul(n), a = R(t, e - 16).mul(W), i = A(o.add(s), 43).add(A(r, 30)).add(a), u = X(i, o.add(A(s.add(W), 18)).add(r), n), c = R(t, 16).mul(n), h = R(t, 24), f = i.add(R(t, e - 32)).mul(n), w = u.add(R(t, e - 24)).mul(n);
-  return X(A(c.add(h), 43).add(A(f, 30)).add(w), c.add(A(h.add(o), 18)).add(f), n);
-}
-function fe(t, e = t.length) {
-  const n = Y.fromNumber(81, !0);
-  if (e <= 32)
-    return e <= 16 ? le(t, e) : ce(t, e);
-  if (e <= 64)
-    return he(t, e);
-  let o = n, s = n.mul(Q).add(113), r = gt(s.mul(W).add(113)).mul(W), a = [Y.UZERO, Y.UZERO], i = [Y.UZERO, Y.UZERO];
-  o = o.mul(W).add(R(t, 0));
-  let u = 0;
-  const c = (e - 1 >> 6) * 64, h = c + (e - 1 & 63) - 63;
-  do
-    o = A(o.add(s).add(a[0]).add(R(t, u + 8)), 37).mul(Q), s = A(s.add(a[1]).add(R(t, u + 48)), 42).mul(Q), o = o.xor(i[1]), s = s.add(a[0]).add(R(t, u + 40)), r = A(r.add(i[0]), 33).mul(Q), a = it(t, u, a[1].mul(Q), o.add(i[0])), i = it(t, u + 32, r.add(i[1]), s.add(R(t, u + 16))), [r, o] = [o, r], u += 64;
-  while (u !== c);
-  const f = Q.add(r.and(255).shl(1));
-  return u = h, i[0] = i[0].add(e - 1 & 63), a[0] = a[0].add(i[0]), i[0] = i[0].add(a[0]), o = A(o.add(s).add(a[0]).add(R(t, u + 8)), 37).mul(f), s = A(s.add(a[1]).add(R(t, u + 48)), 42).mul(f), o = o.xor(i[1].mul(9)), s = s.add(a[0].mul(9).add(R(t, u + 40))), r = A(r.add(i[0]), 33).mul(f), a = it(t, u, a[1].mul(f), o.add(i[0])), i = it(t, u + 32, r.add(i[1]), s.add(R(t, u + 16))), [r, o] = [o, r], X(X(a[0], i[0], f).add(gt(s).mul(Nt)).add(r), X(a[1], i[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 de(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], a = o[o.length - n.length + s], i = o[a];
-    if (r >= 0)
-      if (i >= 0) {
-        if (i !== r)
-          throw new Error(`rt input.shape and shape=${e} are incompatible: rt input.shape[${s + t}] = ${r} but shape[${s + t}] = ${i}`);
-      } else
-        o[a] = r;
-  }
-  return o;
-}
-function ge(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 pe(t) {
-  return t.length === 0 ? 0 : t[0] === H.FIRST_DIM_SIZE ? t.length - 1 : t.length;
-}
-function me(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], a = e[s + 1];
-    if (r >= 0 && a >= 0 && r !== 1 && r !== a)
-      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}] = ${a}`);
-  }
-}
-/**
- * @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 we = 30;
-function Ie(t) {
-  return t <= we ? t : qt(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 xe(t) {
-  return `Received SparseTensor with denseShape[0] = 0 but
-  indices.shape[0] = ${t}`;
-}
-function Se(t, e) {
-  return `indices(${t}, 0) is invalid: ${e} < 0`;
-}
-function Ee(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 be(t, e) {
-  return `size ${t} must be non-negative, not ${e}`;
-}
-function Oe() {
-  return "reshape cannot infer the missing input size for an empty tensor unless all specified input sizes are non-zero";
-}
-function Fe(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 Re(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 Et() {
-  return "segment ids must be >= 0";
-}
-function $e() {
-  return "segment ids are not increasing";
-}
-function ye(t, e) {
-  return `Segment id ${t} out of range [0, ${e}), possibly because segmentIds input is not sorted.`;
-}
-function Te(t, e, n) {
-  return `Bad: indices[${t}] == ${e} out of range [0, ${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.
- * =============================================================================
- */
-function Ve(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 C(t) {
-  return (e, n, o, s, r) => {
-    const a = Ct(e, n), i = a.length, u = J(a), c = y(a), h = nt(r, c), f = e.length, w = n.length, p = J(e), m = J(n), v = It(e, a), d = It(n, a);
-    if (v.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 x = pt(g, i, u), O = x.slice(-f);
-        v.forEach((L) => O[L] = 0);
-        const b = ft(O, f, p), V = x.slice(-w);
-        d.forEach((L) => V[L] = 0);
-        const D = ft(V, w, m);
-        h[g] = t(o[b], s[D]);
-      }
-    return [h, 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.
- * =============================================================================
- */
-function Me(t, e, n, o) {
-  if (o === "int32") {
-    const s = Int32Array.from(t);
-    return [e, "int32", s];
-  }
-  if (o === "bool") {
-    const s = kt([0], n), [r, a] = C((i, u) => i !== u ? 1 : 0)(e, [], t, s, "bool");
-    return [a, "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 Le = C((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 _e(t, e, n, o, s) {
-  const r = y(o), a = ot(s, n);
-  for (let i = 0; i < t.length; i++) {
-    const u = t[i];
-    if (u < 0)
-      throw new Error("Input x must be non-negative!");
-    u >= s || (r > 0 ? a[u] += e[i] : a[u] += 1);
-  }
-  return a;
-}
-function Ne(t, e, n, o = !1) {
-  const s = t.shape[0], r = t.shape[1], a = B([s, n], e.dtype);
-  for (let i = 0; i < s; i++)
-    for (let u = 0; u < r; u++) {
-      const c = t.get(i, u);
-      if (c < 0)
-        throw new Error("Input x must be non-negative!");
-      c >= n || (o ? a.set(1, i, c) : e.size > 0 ? a.set(a.get(i, c) + e.get(i, u), i, c) : a.set(a.get(i, c) + 1, i, c));
-    }
-  return a;
-}
-/**
- * @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 Ae = C((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 K(t) {
-  return (e, n, o) => {
-    const s = q(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 Pe = K((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 De(t, e, n, o) {
-  const s = q(n, y(e));
-  if (o && n !== "string") {
-    let r = 0;
-    t.forEach((a) => {
-      const i = y(a.shape);
-      s.set(a.vals, r), r += i;
-    });
-  } else {
-    let r = 0;
-    t.forEach((a) => {
-      const i = n === "string" ? $t(a.vals) : a.vals;
-      let u = 0;
-      for (let c = 0; c < a.shape[0]; ++c) {
-        const h = c * e[1] + r;
-        for (let f = 0; f < a.shape[1]; ++f)
-          s[h + f] = i[u++];
-      }
-      r += a.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 = C((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 We = K((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 qe = K((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 Ce = K((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 ke = C((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 Ue(t, e, n, o, s, r, a, i, u) {
-  const c = B([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 * a[p], f.push(m);
-    }
-    if (w < 0 || w >= u / r)
-      throw new Error(`Invalid indices: ${f} does not index into ${i}`);
-    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 Ge(t, e, n) {
-  const o = B(n, t.dtype);
-  for (let s = 0; s < o.size; ++s) {
-    const a = o.indexToLoc(s).slice(), i = a[0], u = a[2], c = e.locToIndex([i, u]);
-    a[2] = e.values[c];
-    const h = t.locToIndex(a);
-    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 je = C((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 Ze = C((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 Be = C((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 = C((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 Ke(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 Xe = K((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 Qe(t, e, n, o) {
-  const s = nt(o, y(n));
-  for (let r = 0; r < s.length; ++r) {
-    const a = r * e;
-    let i = t[a];
-    for (let u = 0; u < e; ++u) {
-      const c = t[a + u];
-      (Number.isNaN(c) || c > i) && (i = c);
-    }
-    s[r] = i;
-  }
-  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 Ye = C((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 Je = C((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 Pt = C((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 tn(t, e, n) {
-  const o = Ut(-1, n);
-  return Pt([], 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 en = C((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 nn(t, e, n, o, s) {
-  const r = e.length, a = y(e), i = J(e), u = J(s), c = nt(n, y(s));
-  for (let h = 0; h < a; ++h) {
-    const f = pt(h, r, i), w = new Array(f.length);
-    for (let m = 0; m < w.length; m++)
-      w[m] = f[o[m]];
-    const p = ft(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 on(t, e, n, o) {
-  const [s, r] = mt(t, o), a = Gt(e, "int32"), i = ot(y(s), a), u = y(r);
-  for (let c = 0; c < i.length; ++c) {
-    const h = c * u;
-    let f = 1;
-    for (let w = 0; w < u; ++w)
-      f *= n[h + w];
-    i[c] = f;
-  }
-  return { outVals: i, outShape: s, outDtype: a };
-}
-/**
- * @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 sn(t, e, n) {
-  t.forEach((o, s) => {
-    if (o < 0 || o >= n) {
-      const r = pt(s, e.length, J(e)).join(",");
-      throw new Error(`indices[${r}] = ${o} is not in [0, ${n})`);
-    }
-  });
-}
-function rn(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 an(t, e, n, o) {
-  const s = [];
-  let r = 0;
-  const a = e.length - 1 + n.length, i = new Array(a).fill(null).map(() => [0]);
-  rn(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)
-      i[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 v = i[m], d = v[v.length - 1] - p[h];
-        for (let g = h; g < f; ++g)
-          i[m].push(p[g + 1] + d);
-      }
-      h = p[h], f = p[f];
-    }
-    f !== h && (s.push([h, f]), r += f - h);
-  }
-  return { outSplits: i, valueSlices: s, numValues: r };
-}
-function un(t) {
-  const e = [];
-  for (let n = 0; n < t.length; ++n) {
-    const o = t[n].length, s = q("int32", o);
-    e.push(s), t[n].forEach((r, a) => s[a] = r);
-  }
-  return e;
-}
-function vt(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 ln(t, e, n, o, s, r) {
-  const a = vt(e, 2)[1], i = vt(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 * i + f] = t[h * a + f];
-      ++u;
-    }
-}
-function cn(t, e, n, o, s) {
-  const r = e.slice();
-  r[0] = s;
-  const a = q(n, y(r)), i = t.length, u = i === 0 ? 0 : i / e[0];
-  return ln(t, e, o, u, a, r), [a, r];
-}
-function hn(t, e, n, o, s, r, a, i) {
-  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 (sn(r, a, u), o.length === 0)
-    throw new Error("params.rank must be nonzero");
-  const c = o[0], { outSplits: h, valueSlices: f, numValues: w } = an(r, a, t, c), p = un(h), m = cn(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 bt = 2147483647;
-function fn(t, e, n, o, s, r, a) {
-  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 (a.length > 1)
-    throw new Error("deltas must be a scalar or vector");
-  const i = e.length === 0, u = s.length === 0, c = a.length === 0, h = [];
-  i || h.push(e[0]), u || h.push(s[0]), c || h.push(a[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 = q("int32", f + 1);
-  w[0] = 0;
-  for (let d = 0; d < f; ++d) {
-    const g = i ? t[0] : t[d], x = u ? o[0] : o[d], O = c ? r[0] : r[d];
-    if (O === 0)
-      throw new Error("Requires delta != 0");
-    let b;
-    if (O > 0 && x < g || O < 0 && x > g)
-      b = 0;
-    else if (b = Math.ceil(Math.abs((x - g) / O)), b > bt)
-      throw new Error(`Requires ((limit - start) / delta) <= ${bt}`);
-    w[d + 1] = w[d] + b;
-  }
-  const p = w[f], m = q(n, p);
-  let v = 0;
-  for (let d = 0; d < f; ++d) {
-    const g = w[d + 1] - w[d];
-    let x = i ? t[0] : t[d];
-    const O = c ? r[0] : r[d];
-    for (let b = 0; b < g; ++b)
-      m[v++] = x, x += O;
-  }
-  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 Z = H;
-class at {
-  constructor(e, n, o, s, r, a, i, u, c, h) {
-    this.shape = e, this.shapeShape = n, this.values = o, this.valuesShape = s, this.valuesDType = r, this.defaultValue = a, this.defaultValueShape = i, this.rowPartitionValues = u, this.rowPartitionValuesShapes = c, this.rowPartitionTypes = ge(h), this.raggedRank = pe(this.rowPartitionTypes);
-  }
-  getRowPartitionTypeByDimension(e) {
-    return this.rowPartitionTypes[0] === Z.FIRST_DIM_SIZE ? this.rowPartitionTypes[e + 1] : this.rowPartitionTypes[e];
-  }
-  // Returns the relationship between dimension and dimension + 1.
-  getRowPartitionTensor(e) {
-    return this.rowPartitionTypes[0] === Z.FIRST_DIM_SIZE ? this.rowPartitionValues[e + 1] : this.rowPartitionValues[e];
-  }
-  getMaxWidth(e) {
-    const n = this.getRowPartitionTensor(e - 1);
-    switch (this.getRowPartitionTypeByDimension(e - 1)) {
-      case Z.VALUE_ROWIDS:
-        return at.getMaxWidthValueRowID(n);
-      case Z.ROW_SPLITS:
-        return at.getMaxWidthRowSplit(n);
-      default:
-        throw new Error(`Cannot handle partition type ${Z[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 a = 1; a < n; ++a) {
-      const i = e[a];
-      i !== s && (s = i, r = Math.max(a - o, r), o = a);
-    }
-    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 Ft(e, o);
-  }
-  calculateOutputSize(e) {
-    const n = this.valuesShape, o = this.defaultValueShape;
-    me(o, n);
-    const s = this.tensorShapeFromTensor(this.shape, this.shapeShape), a = de(this.raggedRank, s, n);
-    a[0] < 0 && (a[0] = e);
-    for (let i = 1; i <= this.raggedRank; ++i)
-      a[i] < 0 && (a[i] = this.getMaxWidth(i));
-    return a;
-  }
-  /**
-   * 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 a = 0;
-    for (let i = 0; i < s; ++i, a += n)
-      r.push(a);
-    for (let i = s; i < e; ++i)
-      r.push(-1);
-    return jt(r.length === e, () => "Final length of result must be equal to firstDimension."), r;
-  }
-  calculateOutputIndexRowSplit(e, n, o, s) {
-    const r = e.length, a = [];
-    for (let i = 0; i < r - 1; ++i) {
-      const u = e[i + 1] - e[i];
-      let c = Math.min(s, u), h = n[i];
-      h === -1 && (c = 0);
-      for (let f = 0; f < c; ++f)
-        a.push(h), h += o;
-      for (let f = 0; f < u - c; ++f)
-        a.push(-1);
-    }
-    if (r > 0 && a.length !== e[r - 1])
-      throw new Error("Invalid row split size.");
-    return a;
-  }
-  // 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, a = [];
-    if (r === 0)
-      return [];
-    let i = 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];
-    a.push(c);
-    for (let h = 1; h < r; ++h) {
-      const f = e[h];
-      if (f === u)
-        c >= 0 && (++i, i < s ? c += o : c = -1);
-      else {
-        if (i = 0, u = f, f >= n.length)
-          throw new Error(`Got nextValueRowId=${f} which is not less than ${n.length}`);
-        c = n[f];
-      }
-      a.push(c);
-    }
-    if (a.length !== e.length)
-      throw new Error("Invalid row ids.");
-    return a;
-  }
-  calculateOutputIndex(e, n, o, s) {
-    const r = this.getRowPartitionTensor(e), a = this.getRowPartitionTypeByDimension(e);
-    switch (a) {
-      case Z.VALUE_ROWIDS:
-        return this.calculateOutputIndexValueRowID(r, n, o, s);
-      case Z.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: ${Z[a]}`);
-    }
-  }
-  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 Z.FIRST_DIM_SIZE:
-        return e[0];
-      case Z.VALUE_ROWIDS:
-        throw new Error("Cannot handle VALUE_ROWIDS in first dimension.");
-      case Z.ROW_SPLITS:
-        return this.rowPartitionValuesShapes[0][0] - 1;
-      default:
-        throw new Error(`Cannot handle type ${Z[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 = Ft(o, !1), a = q(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, a, r);
-    }
-    return [r, a];
-  }
-  setOutput(e, n, o, s) {
-    if (o.length === 0)
-      return;
-    const r = this.values, a = o;
-    let i = s.slice();
-    i = i.slice(e + 1);
-    const u = y(i), c = n.length;
-    let h = this.defaultValue;
-    if (h.length !== u && h.length !== 1) {
-      const m = this.defaultValueShape;
-      Zt(() => {
-        const v = ee(h, m);
-        h = te(v, i).dataSync();
-      });
-    }
-    let f = 0, w = 0, p = 0;
-    for (let m = 0; m <= c; ++m) {
-      let v = m < c ? n[m] : -1;
-      if (v === p) {
-        ++p;
-        continue;
-      }
-      if (w < p) {
-        const d = r.subarray(f * u), g = a.subarray(w * u), x = (p - w) * u;
-        Ot(g, d, x);
-      }
-      if (m >= c) {
-        const d = o.length;
-        v = Math.floor(d / u);
-      }
-      if (v > p)
-        if (this.defaultValue.length === 1)
-          a.subarray(p * u, v * u).fill(this.defaultValue[0]), p = v;
-        else
-          for (; v > p; ) {
-            const d = a.slice(p * u);
-            Ot(d, h, u), ++p;
-          }
-      v < 0 ? (f = m + 1, w = p) : (f = m, w = p, p = w + 1);
-    }
-  }
-}
-function Ot(t, e, n) {
-  for (let o = 0; o < n; o++)
-    t[o] = e[o];
-}
-function Ft(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 dn(t, e, n, o, s, r, a, i, u, c) {
-  return new at(t, e, n, o, s, r, a, i, 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 gn(t, e, n, o) {
-  const s = t === e, r = t < e && n < 0, a = e < t && n > 1;
-  if (s || r || a)
-    return ot(0, o);
-  const i = Math.abs(Math.ceil((e - t) / n)), u = ot(i, 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 pn = K((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 mn(t, e, n, o, s, r, a, i, u, c) {
-  const h = [o / s, s], f = t.values, w = e.values;
-  if (o === 0)
-    return B(n, e.dtype);
-  const p = u instanceof dt ? u : B(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 v = [];
-    let d = 0;
-    for (let g = 0; g < a; g++) {
-      const x = f[m * a + g];
-      v.push(x), d += x * i[g];
-    }
-    if (d < 0 || d >= o / s)
-      throw new Error(`Invalid indices: ${v} 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 wn = K((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 In(t, e, n, o, s) {
-  const r = ne(o, e, n), a = y(n), i = J(o);
-  if (r) {
-    const f = oe(e, i);
-    return s === "string" ? t.slice(f, f + a) : t.subarray(f, f + a);
-  }
-  const u = s === "string" ? $t(t) : t, c = B(o, s, u), h = B(n, s);
-  for (let f = 0; f < h.size; ++f) {
-    const w = h.indexToLoc(f), p = w.map((m, v) => m + e[v]);
-    h.set(c.get(...p), ...w);
-  }
-  return s === "string" ? Qt(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 xn(t, e, n, o, s, r, a) {
-  const i = e[0], u = r[0], c = new Array(u), h = new Array(i), f = e[1];
-  if (u === 0) {
-    if (i !== 0)
-      throw new Error(xe(i));
-    const d = q(n, 0), g = q(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 < i; ++d) {
-    const g = t[d * f];
-    if (g < 0)
-      throw new Error(Se(d, g));
-    if (g >= u)
-      throw new Error(Ee(d, g, u));
-    ++m[g], w = w && g >= p, p = g;
-  }
-  let v = !0;
-  for (let d = 0; d < u; ++d) {
-    const g = m[d] === 0;
-    c[d] = g, v = v && !g, m[d] = Math.max(m[d], 1), d > 0 && (m[d] += m[d - 1]);
-  }
-  if (v && w) {
-    const d = t, g = o;
-    for (let x = 0; x < i; ++x)
-      h[x] = x;
-    return [
-      d,
-      [i, f],
-      g,
-      c,
-      h
-    ];
-  } else {
-    const d = m[u - 1], g = q(n, d * f), x = q(s, d), O = new Array(u).fill(0);
-    for (let b = 0; b < i; ++b) {
-      const V = t[b * f], D = O[V], L = (V === 0 ? 0 : m[V - 1]) + D;
-      O[V]++;
-      for (let _ = 0; _ < f; ++_)
-        g[L * f + _] = t[b * f + _];
-      x[L] = o[b], h[b] = L;
-    }
-    for (let b = 0; b < u; ++b)
-      if (O[b] === 0) {
-        const D = b === 0 ? 0 : m[b - 1];
-        g[D * f + 0] = b;
-        for (let L = 1; L < f; ++L)
-          g[D * f + L] = 0;
-        x[D] = a;
-      }
-    return [
-      g,
-      [d, f],
-      x,
-      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 Sn(t, e, n, o, s) {
-  const r = y(o), a = e[0], i = s.length, u = [];
-  let c = 1, h = -1;
-  for (let d = 0; d < i; ++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(be(d, g));
-      c *= g, u.push(g);
-    }
-  }
-  if (h !== -1) {
-    if (c <= 0)
-      throw new Error(Oe());
-    const d = Math.trunc(r / c);
-    if (c * d !== r)
-      throw new Error(Fe(o, u));
-    u[h] = d;
-  }
-  if (y(u) !== r)
-    throw new Error(Re(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 (i > 0) {
-    m[i - 1] = 1;
-    for (let d = i - 2; d >= 0; --d)
-      m[d] = m[d + 1] * u[d + 1];
-  }
-  const v = q(n, a * i);
-  for (let d = 0; d < a; ++d) {
-    let g = 0;
-    for (let x = 0; x < w; ++x)
-      g += t[d * w + x] * p[x];
-    for (let x = 0; x < i; ++x)
-      v[d * i + x] = Math.trunc(g / m[x]), g %= m[x];
-  }
-  return [v, [a, i], 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 En(t, e, n, o, s, r = !1, a = 0) {
-  const i = o.length, u = [e[0], t.length / e[0]], c = u[1], f = i > 0 ? s[i - 1] + 1 : 0;
-  if (f < 0)
-    throw new Error(Et());
-  const w = e.slice();
-  w[0] = f;
-  const p = w.reduce((O, b) => O * b, 1), m = q(n, p);
-  if (i === 0)
-    return f > 0 && m.fill(a), [m, w];
-  if (f <= 0)
-    throw new Error(Et());
-  let v = 0, d = 1, g = 0, x = s[v];
-  for (; ; ) {
-    let O = 0;
-    if (d < i) {
-      if (O = s[d], x === O) {
-        ++d;
-        continue;
-      }
-      if (x >= O)
-        throw new Error($e());
-    }
-    if (x < 0 || x >= f)
-      throw new Error(ye(x, f));
-    x > g && m.fill(a, g * c, x * c);
-    for (let b = v; b < d; ++b) {
-      const V = o[b];
-      if (V < 0 || V >= u[0])
-        throw new Error(Te(b, o[b], u[0]));
-      for (let D = 0; D < c; D++)
-        m[x * c + D] += t[V * c + D];
-    }
-    if (r)
-      for (let b = 0; b < c; b++)
-        m[x * c + b] /= d - v;
-    if (v = d, ++d, g = x + 1, x = O, d > i)
-      break;
-  }
-  return g < f && m.fill(a, 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 vn = K((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 bn = C((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 On = K((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 Fn(t, e, n, o) {
-  const s = B(t, e.dtype);
-  for (let r = 0; r < s.size; r++) {
-    const a = s.indexToLoc(r), i = new Array(a.length);
-    for (let u = 0; u < i.length; u++)
-      i[u] = a[u] * n[u] + o[u];
-    s.set(e.get(...i), ...a);
-  }
-  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 Rn {
-  constructor(e, n, o, s, r, a) {
-    this.separator = ct(e), this.nGramWidths = n, this.leftPad = ct(o), this.rightPad = ct(s), this.padWidth = r, this.preserveShort = a;
-  }
-  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, a) {
-    for (let i = 0; i < r; ++i) {
-      const u = this.getPadWidth(a), c = Math.max(0, u - i), h = Math.max(0, u - (r - (i + 1))), f = a - (c + h), w = n + (c > 0 ? 0 : i - u);
-      let p = 0;
-      p += c * this.leftPad.length;
-      for (let x = 0; x < f; ++x)
-        p += e[w + x].length;
-      p += h * this.rightPad.length;
-      const m = c + h + f - 1;
-      p += m * this.separator.length, o[s + i] = new Uint8Array(p);
-      const v = o[s + i];
-      let d = 0;
-      const g = (x) => x.forEach((O) => v[d++] = O);
-      for (let x = 0; x < c; ++x)
-        g(this.leftPad), g(this.separator);
-      for (let x = 0; x < f - 1; ++x)
-        g(e[w + x]), g(this.separator);
-      if (f > 0) {
-        g(e[w + f - 1]);
-        for (let x = 0; x < h; ++x)
-          g(this.separator), g(this.rightPad);
-      } else {
-        for (let x = 0; x < h - 1; ++x)
-          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, a = q("int32", s);
-    if (o === 0 || s === 0) {
-      const u = new Array(o);
-      for (let c = 0; c <= r; ++c)
-        a[c] = 0;
-      return [u, a];
-    }
-    a[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), a[u] = a[u - 1] + h;
-    }
-    const i = new Array(a[r]);
-    for (let u = 0; u < r; ++u) {
-      const c = n[u];
-      let h = a[u];
-      if (this.nGramWidths.forEach((f) => {
-        const w = n[u + 1] - n[u], p = this.getNumNGrams(w, f);
-        this.createNGrams(e, c, i, h, p, f), h += p;
-      }), this.preserveShort && h === a[u]) {
-        const f = n[u + 1] - n[u];
-        if (f === 0)
-          continue;
-        const w = f + 2 * this.padWidth;
-        this.createNGrams(e, c, i, h, 1, w);
-      }
-    }
-    return [i, a];
-  }
-}
-function $n(t, e, n, o, s, r, a, i) {
-  return new Rn(n, o, s, r, a, i).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 yn(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 a = t.indexOf(r);
-    for (; a !== -1; ) {
-      const i = t.subarray(0, a);
-      (!n || i.length !== 0) && o.push(i), t = t.subarray(a + 1), a = 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 a = t.subarray(s, r);
-      (!n || a.length !== 0) && o.push(a), s = r + 1;
-    }
-}
-function Tn(t, e, n) {
-  const o = t.length, s = [];
-  let r = 0, a = 0;
-  const i = new Array(o);
-  for (let w = 0; w < o; ++w) {
-    const p = s.length;
-    yn(t[w], e, n, s);
-    const m = s.length - p;
-    i[w] = m, r += m, a = Math.max(a, m);
-  }
-  const u = q("int32", r * 2), c = new Array(r), h = [o, a];
-  let f = 0;
-  for (let w = 0; w < o; ++w)
-    for (let p = 0; p < i[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 Vn(t, e) {
-  const n = q("int32", t.length);
-  for (let o = 0; o < t.length; ++o)
-    n[o] = fe(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 Mn = C((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 Ln(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 = B(n, t.dtype);
-  for (let s = 0; s < o.values.length; ++s) {
-    const r = o.indexToLoc(s), a = new Array(t.rank);
-    for (let u = 0; u < a.length; u++)
-      a[u] = r[u] % t.shape[u];
-    const i = t.locToIndex(a);
-    o.values[s] = t.values[i];
-  }
-  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 Dt(t, e, n = 0, o = t.length - 1) {
-  for (; o > n; ) {
-    if (o - n > 600) {
-      const i = o - n + 1, u = e - n + 1, c = Math.log(i), h = 0.5 * Math.exp(2 * c / 3), f = 0.5 * Math.sqrt(c * h * (i - h) / i) * Math.sign(u - i / 2), w = Math.max(n, Math.floor(e - u * h / i + f)), p = Math.min(o, Math.floor(e + (i - u) * h / i + f));
-      Dt(t, e, w, p);
-    }
-    const s = t[e];
-    let r = n, a = o;
-    for (tt(t, n, e), et(t[o], s) > 0 && tt(t, n, o); r < a; ) {
-      for (tt(t, r, a), r++, a--; et(t[r], s) < 0; )
-        r = r + 1;
-      for (; et(t[a], s) > 0; )
-        a = a - 1;
-    }
-    et(t[n], s) === 0 ? tt(t, n, a) : (a = a + 1, tt(t, a, o)), a <= e && (n = a + 1), e <= a && (o = a - 1);
-  }
-}
-function _n(t, e, n, o, s) {
-  const r = e[e.length - 1], [a, i] = [t.length / r, r], u = nt(n, a * o), c = nt("int32", a * o);
-  for (let f = 0; f < a; f++) {
-    const w = f * i, p = t.subarray(w, w + i);
-    let m = new Array(p.length);
-    p.forEach((x, O) => m[O] = { value: x, index: O }), o < m.length && (Dt(m, o), m = m.slice(0, o)), s && m.sort(et);
-    const v = f * o, d = u.subarray(v, v + o), g = c.subarray(v, v + o);
-    for (let x = 0; x < o; x++)
-      d[x] = m[x].value, g[x] = m[x].index;
-  }
-  const h = e.slice();
-  return h[h.length - 1] = o, [
-    B(h, n, u),
-    B(h, "int32", c)
-  ];
-}
+import { ao as E, ap as T, q as V, N as L, a1 as w, aq as K, r as W } from "../../index-bMBtI-WR.js";
+import { t as B, m as G } from "../../shared-XNAoXhOa.js";
+import { r as b } from "../../Reshape-CLOrdpve.js";
+import { g as C, a as U, b as _ } from "../../kernel_funcs_utils-CNmjLWnB.js";
+import { g as k, a as R, b as P, c as y, e as O } from "../../axis_util-D17qZRQm.js";
 /**
  * @license
- * Copyright 2020 Google LLC. All Rights Reserved.
+ * 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
@@ -2711,47 +19,9 @@ function _n(t, e, n, o, s) {
  * limitations under the License.
  * =============================================================================
  */
-function Nn(t, e, n, o) {
-  const s = ut(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 a = /* @__PURE__ */ new Map(), i = new Int32Array(n[s]), u = new dt(r, o, t), c = [], h = r[0] === 1 && r[2] === 1;
-  for (let m = 0; m < n[s]; m++) {
-    let v;
-    if (h)
-      v = t[m].toString();
-    else {
-      const g = [];
-      for (let x = 0; x < r[0]; x++)
-        for (let O = 0; O < r[2]; O++)
-          g.push(u.get(x, m, O));
-      v = g.join(",");
-    }
-    const d = a.get(v);
-    if (d != null)
-      i[m] = d;
-    else {
-      const g = a.size;
-      a.set(v, g), i[m] = g, c.push(m);
-    }
-  }
-  const f = r.slice();
-  f[1] = a.size;
-  const w = new dt(f, o);
-  c.forEach((m, v) => {
-    for (let d = 0; d < r[0]; d++)
-      for (let g = 0; g < r[2]; g++)
-        w.set(u.get(d, m, g), d, v, g);
-  });
-  const p = n.slice();
-  return p[s] = f[1], {
-    outputValues: w.values,
-    outputShape: p,
-    indices: i
-  };
+const q = 30;
+function F(a) {
+  return a <= q ? a : E(a, Math.floor(Math.sqrt(a)));
 }
 /**
  * @license
@@ -2769,114 +39,27 @@ function Nn(t, e, n, o) {
  * limitations under the License.
  * =============================================================================
  */
-const An = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  addImpl: Le,
-  bincountImpl: _e,
-  bincountReduceImpl: Ne,
-  bitwiseAndImpl: Ae,
-  castImpl: Me,
-  ceilImpl: Pe,
-  concatImpl: De,
-  equalImpl: ze,
-  expImpl: We,
-  expm1Impl: qe,
-  floorDivImpl: ke,
-  floorImpl: Ce,
-  gatherNdImpl: Ue,
-  gatherV2Impl: Ge,
-  greaterEqualImpl: Ze,
-  greaterImpl: je,
-  lessEqualImpl: He,
-  lessImpl: Be,
-  linSpaceImpl: Ke,
-  logImpl: Xe,
-  maxImpl: Qe,
-  maximumImpl: Ye,
-  minimumImpl: Je,
-  multiplyImpl: Pt,
-  negImpl: tn,
-  notEqualImpl: en,
-  prodImpl: on,
-  raggedGatherImpl: hn,
-  raggedRangeImpl: fn,
-  raggedTensorToTensorImpl: dn,
-  rangeImpl: gn,
-  rsqrtImpl: pn,
-  scatterImpl: mn,
-  sigmoidImpl: wn,
-  simpleAbsImpl: Ve,
-  sliceImpl: In,
-  sparseFillEmptyRowsImpl: xn,
-  sparseReshapeImpl: Sn,
-  sparseSegmentReductionImpl: En,
-  sqrtImpl: vn,
-  squaredDifferenceImpl: bn,
-  staticRegexReplaceImpl: On,
-  stridedSliceImpl: Fn,
-  stringNGramsImpl: $n,
-  stringSplitImpl: Tn,
-  stringToHashBucketFastImpl: Vn,
-  subImpl: Mn,
-  tileImpl: Ln,
-  topKImpl: _n,
-  transposeImpl: nn,
-  uniqueImpl: Nn
-}, 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: Pn, transposeImpl: Dn } = An;
-/**
- * @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 Rt {
-  constructor(e, n) {
+class A {
+  constructor(o, t) {
     this.variableNames = ["x"];
-    const { windowSize: o, batchSize: s, inSize: r, outSize: a } = e;
-    this.outputShape = [s, a];
-    const i = 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 * ${Bt(f) ? f.toPrecision(2) : f}, ones);`;
-    }
-    let h = "";
-    r % o > 0 && (h = `
-        if (inIdx < 0 || inIdx >= ${r}) {
+    const { windowSize: e, batchSize: n, inSize: u, outSize: l } = o;
+    this.outputShape = [n, l];
+    const s = Math.floor(e / 4) * 4, c = e % 4;
+    let i = "sumValue += dot(values, ones);";
+    if (t != null) {
+      const p = 1 / t;
+      i = `sumValue += dot(values * ${T(p) ? p.toPrecision(2) : p}, ones);`;
+    }
+    let r = "";
+    u % e > 0 && (r = `
+        if (inIdx < 0 || inIdx >= ${u}) {
           return 0.0;
         }
       `), this.userCode = `
       const vec4 ones = vec4(1.0, 1.0, 1.0, 1.0);
 
       float getValue(int batch, int inIdx) {
-        ${h}
+        ${r}
         return getX(batch, inIdx);
       }
 
@@ -2884,11 +67,11 @@ class Rt {
         ivec2 coords = getOutputCoords();
         int batch = coords[0];
         int outIdx = coords[1];
-        int inOffset = outIdx * ${o};
+        int inOffset = outIdx * ${e};
 
         float sumValue = 0.0;
 
-        for (int i = 0; i < ${i}; i += 4) {
+        for (int i = 0; i < ${s}; i += 4) {
           int inIdx = inOffset + i;
           vec4 values = vec4(
             getValue(batch, inIdx),
@@ -2897,27 +80,27 @@ class Rt {
             getValue(batch, inIdx + 3)
           );
 
-          ${c}
+          ${i}
         }
 
-        int inIdx = inOffset + ${i};
-        if (${u === 1}) {
+        int inIdx = inOffset + ${s};
+        if (${c === 1}) {
           vec4 values = vec4(getValue(batch, inIdx), 0.0, 0.0, 0.0);
 
-          ${c}
-        } else if (${u === 2}) {
+          ${i}
+        } else if (${c === 2}) {
           vec4 values = vec4(
             getValue(batch, inIdx),
             getValue(batch, inIdx + 1), 0.0, 0.0);
 
-          ${c}
-        } else if (${u === 3}) {
+          ${i}
+        } else if (${c === 3}) {
           vec4 values = vec4(
             getValue(batch, inIdx),
             getValue(batch, inIdx + 1),
             getValue(batch, inIdx + 2), 0.0);
 
-          ${c}
+          ${i}
         }
         setOutput(sumValue);
       }
@@ -2940,53 +123,53 @@ class Rt {
  * limitations under the License.
  * =============================================================================
  */
-class zn {
-  constructor(e, n) {
+class j {
+  constructor(o, t) {
     this.variableNames = ["x"];
-    const { windowSize: o, batchSize: s, inSize: r, outSize: a } = e;
-    this.outputShape = [s, a];
-    let i = "0.0", u = "";
-    n === "prod" ? i = "1.0" : n === "min" ? (i = "1.0 / 1e-20", u = "min") : n === "max" && (i = "-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"}) {
+    const { windowSize: e, batchSize: n, inSize: u, outSize: l } = o;
+    this.outputShape = [n, l];
+    let s = "0.0", c = "";
+    t === "prod" ? s = "1.0" : t === "min" ? (s = "1.0 / 1e-20", c = "min") : t === "max" && (s = "-1.0 / 1e-20", c = "max");
+    let i = `${t}(${t}(${t}(minMaxValue[0], minMaxValue[1]), minMaxValue[2]), minMaxValue[3])`;
+    t === "sum" ? i = "sumValue" : t === "prod" ? i = "prodValue" : t === "all" ? i = "allValue" : t === "any" && (i = "anyValue");
+    const r = Math.floor(e / 4) * 4, p = e % 4;
+    let h = `
+      if (${t === "sum"}) {
         sumValue += dot(values, ones);
-      } else if (${n === "prod"}) {
+      } else if (${t === "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);
+        minMaxValue = ${c}(values, minMaxValue);
+        if (${t === "min"} || ${t === "max"}) {
+          minMaxValue = ${c}(values, minMaxValue);
           bvec4 isNaN = isnan(values);
           if (isNaN.r || isNaN.g || isNaN.b || isNaN.a) {
             minMaxValue = vec4(NAN);
           }
         }
       }
-    `, p = "vec4";
-    n === "all" ? (i = "1.0", w = `
+    `, d = "vec4";
+    t === "all" ? (s = "1.0", h = `
         bool reducedAllValue = all(values);
         float floatedReducedAllValue = float(reducedAllValue);
         allValue = float(allValue >= 1.0 && floatedReducedAllValue >= 1.0);
-      `, p = "bvec4") : n === "any" && (i = "0.0", w = `
+      `, d = "bvec4") : t === "any" && (s = "0.0", h = `
         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}) {
+      `, d = "bvec4");
+    let f = "";
+    u % e > 0 && (f = `
+        if (inIdx < 0 || inIdx >= ${u}) {
           return initializationValue;
         }
       `), this.userCode = `
-      const float initializationValue = ${i};
+      const float initializationValue = ${s};
       const vec4 ones = vec4(1.0, 1.0, 1.0, 1.0);
 
       float getValue(int batch, int inIdx) {
-        ${m}
+        ${f}
         return getX(batch, inIdx);
       }
 
@@ -2994,56 +177,56 @@ class zn {
         ivec2 coords = getOutputCoords();
         int batch = coords[0];
         int outIdx = coords[1];
-        int inOffset = outIdx * ${o};
+        int inOffset = outIdx * ${e};
 
-        vec4 minMaxValue = vec4(${i});
+        vec4 minMaxValue = vec4(${s});
         float prodValue = 1.0;
         float sumValue = 0.0;
         float allValue = 1.0;
         float anyValue = 0.0;
 
-        for (int i = 0; i < ${h}; i += 4) {
+        for (int i = 0; i < ${r}; i += 4) {
           int inIdx = inOffset + i;
-          ${p} values = ${p}(
+          ${d} values = ${d}(
             getValue(batch, inIdx),
             getValue(batch, inIdx + 1),
             getValue(batch, inIdx + 2),
             getValue(batch, inIdx + 3)
           );
 
-          ${w}
+          ${h}
         }
 
-        int inIdx = inOffset + ${h};
-        if (${f === 1}) {
-          ${p} values = ${p}(
+        int inIdx = inOffset + ${r};
+        if (${p === 1}) {
+          ${d} values = ${d}(
             getValue(batch, inIdx),
             initializationValue,
             initializationValue,
             initializationValue
           );
 
-          ${w}
-        } else if (${f === 2}) {
-          ${p} values = ${p}(
+          ${h}
+        } else if (${p === 2}) {
+          ${d} values = ${d}(
             getValue(batch, inIdx),
             getValue(batch, inIdx + 1),
             initializationValue,
             initializationValue
           );
 
-          ${w}
-        } else if (${f === 3}) {
-          ${p} values = ${p}(
+          ${h}
+        } else if (${p === 3}) {
+          ${d} values = ${d}(
             getValue(batch, inIdx),
             getValue(batch, inIdx + 1),
             getValue(batch, inIdx + 2),
             initializationValue
           );
 
-          ${w}
+          ${h}
         }
-        setOutput(${c});
+        setOutput(${i});
       }
     `;
   }
@@ -3064,27 +247,27 @@ class zn {
  * limitations under the License.
  * =============================================================================
  */
-function Wn(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 = Ie(n);
-    e.push({
-      inSize: n,
-      windowSize: o,
-      outSize: Math.ceil(n / o)
+function H(a) {
+  const o = [];
+  for (; o.length === 0 || o[o.length - 1].outSize !== 1; ) {
+    const t = o.length ? o[o.length - 1].outSize : a[1], e = F(t);
+    o.push({
+      inSize: t,
+      windowSize: e,
+      outSize: Math.ceil(t / e)
     });
   }
-  return e;
+  return o;
 }
-function zt(t, e, n, o) {
-  const s = Wn(t.shape);
-  let r = t;
-  for (let a = 0; a < s.length; a++) {
-    const { inSize: i, windowSize: u, outSize: c } = s[a];
-    let h, f;
-    n === "mean" ? h = a === 0 ? new Rt({ windowSize: u, inSize: i, batchSize: t.shape[0], outSize: c }, i) : new Rt({ windowSize: u, inSize: i, batchSize: t.shape[0], outSize: c }) : h = new zn({ windowSize: u, inSize: i, batchSize: t.shape[0], outSize: c }, n), f = r, r = o.runWebGLProgram(h, [r], e), f.dataId !== t.dataId && o.disposeIntermediateTensorInfo(f);
+function N(a, o, t, e) {
+  const n = H(a.shape);
+  let u = a;
+  for (let l = 0; l < n.length; l++) {
+    const { inSize: s, windowSize: c, outSize: i } = n[l];
+    let r, p;
+    t === "mean" ? r = l === 0 ? new A({ windowSize: c, inSize: s, batchSize: a.shape[0], outSize: i }, s) : new A({ windowSize: c, inSize: s, batchSize: a.shape[0], outSize: i }) : r = new j({ windowSize: c, inSize: s, batchSize: a.shape[0], outSize: i }, t), p = u, u = e.runWebGLProgram(r, [u], o), p.dataId !== a.dataId && e.disposeIntermediateTensorInfo(p);
   }
-  return r;
+  return u;
 }
 /**
  * @license
@@ -3102,9 +285,9 @@ function zt(t, e, n, o) {
  * limitations under the License.
  * =============================================================================
  */
-function qn(t, e, n, o) {
-  const s = y(e), a = y(t.shape) / s, i = st({ inputs: { x: t }, attrs: { shape: [a, s] }, backend: o }), u = zt(i, t.dtype, "max", o), c = st({ inputs: { x: u }, attrs: { shape: n }, backend: o });
-  return o.disposeIntermediateTensorInfo(i), o.disposeIntermediateTensorInfo(u), c;
+function X(a, o, t, e) {
+  const n = V(o), l = V(a.shape) / n, s = b({ inputs: { x: a }, attrs: { shape: [l, n] }, backend: e }), c = N(s, a.dtype, "max", e), i = b({ inputs: { x: c }, attrs: { shape: t }, backend: e });
+  return e.disposeIntermediateTensorInfo(s), e.disposeIntermediateTensorInfo(c), i;
 }
 /**
  * @license
@@ -3122,30 +305,30 @@ function qn(t, e, n, o) {
  * limitations under the License.
  * =============================================================================
  */
-class Cn {
-  constructor(e, n) {
+class Y {
+  constructor(o, t) {
     this.variableNames = ["A"];
-    const o = new Array(e.length);
-    for (let a = 0; a < o.length; a++)
-      o[a] = e[n[a]];
-    this.outputShape = o, this.rank = o.length;
-    const s = yt(this.rank), r = kn(n);
+    const e = new Array(o.length);
+    for (let l = 0; l < e.length; l++)
+      e[l] = o[t[l]];
+    this.outputShape = e, this.rank = e.length;
+    const n = C(this.rank), u = Z(t);
     this.userCode = `
     void main() {
-      ${s} resRC = getOutputCoords();
-      setOutput(getA(${r}));
+      ${n} resRC = getOutputCoords();
+      setOutput(getA(${u}));
     }
     `;
   }
 }
-function kn(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();
+function Z(a) {
+  const o = a.length;
+  if (o > 6)
+    throw Error(`Transpose for rank ${o} is not yet supported`);
+  const t = ["resRC.x", "resRC.y", "resRC.z", "resRC.w", "resRC.u", "resRC.v"], e = new Array(o);
+  for (let n = 0; n < a.length; n++)
+    e[a[n]] = t[n];
+  return e.join();
 }
 /**
  * @license
@@ -3163,31 +346,31 @@ function kn(t) {
  * limitations under the License.
  * =============================================================================
  */
-class Un {
-  constructor(e, n) {
+class J {
+  constructor(o, t) {
     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)
+    const e = new Array(o.length);
+    for (let r = 0; r < e.length; r++)
+      e[r] = o[t[r]];
+    if (this.outputShape = e, this.rank = e.length, this.rank > 6)
       throw Error(`Packed transpose for rank ${this.rank} is not yet supported.`);
-    const s = yt(this.rank), r = Yt("rc", this.rank), a = new Array(this.rank);
-    for (let h = 0; h < n.length; h++)
-      a[n[h]] = r[h];
-    const i = `vec2(${a.slice(-2).join()})`, u = `++${r[this.rank - 1]} < ${o[this.rank - 1]}`, c = `getChannel(getA(${a.join()}), ${i})`;
+    const n = C(this.rank), u = U("rc", this.rank), l = new Array(this.rank);
+    for (let r = 0; r < t.length; r++)
+      l[t[r]] = u[r];
+    const s = `vec2(${l.slice(-2).join()})`, c = `++${u[this.rank - 1]} < ${e[this.rank - 1]}`, i = `getChannel(getA(${l.join()}), ${s})`;
     this.userCode = `
     void main() {
-      ${s} rc = getOutputCoords();
+      ${n} rc = getOutputCoords();
       vec4 result = vec4(0.);
-      result[0] = ${c};
-      if(${u}) {
-        result[1] = ${c};
+      result[0] = ${i};
+      if(${c}) {
+        result[1] = ${i};
       }
-      --${r[this.rank - 1]};
-      if(++${r[this.rank - 2]} < ${o[this.rank - 2]}) {
-        result[2] = ${c};
-        if(${u}) {
-          result[3] = ${c};
+      --${u[this.rank - 1]};
+      if(++${u[this.rank - 2]} < ${e[this.rank - 2]}) {
+        result[2] = ${i};
+        if(${c}) {
+          result[3] = ${i};
         }
       }
       setOutput(result);
@@ -3211,9 +394,9 @@ class Un {
  * limitations under the License.
  * =============================================================================
  */
-function Wt(t, e, n) {
-  const o = Ht().getBool("WEBGL_PACK_ARRAY_OPERATIONS") ? new Un(t.shape, e) : new Cn(t.shape, e);
-  return n.runWebGLProgram(o, [t], t.dtype);
+function D(a, o, t) {
+  const e = L().getBool("WEBGL_PACK_ARRAY_OPERATIONS") ? new J(a.shape, o) : new Y(a.shape, o);
+  return t.runWebGLProgram(e, [a], a.dtype);
 }
 /**
  * @license
@@ -3231,37 +414,37 @@ function Wt(t, e, n) {
  * limitations under the License.
  * =============================================================================
  */
-function Gn(t) {
-  const { inputs: e, backend: n, attrs: o } = t, { x: s } = e, { reductionIndices: r, keepDims: a } = o, i = s.shape.length, u = ut(r, s.shape);
-  let c = u;
-  const h = Tt(c, i), f = h != null, w = n.shouldExecuteOnCPU([s]);
-  let p = s;
-  if (f) {
-    if (w) {
-      const O = n.texData.get(p.dataId).values, b = new Array(i);
-      for (let L = 0; L < b.length; L++)
-        b[L] = s.shape[h[L]];
-      const V = Dn(O, s.shape, s.dtype, h, b);
-      p = n.makeTensorInfo(b, s.dtype);
-      const D = n.texData.get(p.dataId);
-      D.values = V;
+function Q(a) {
+  const { inputs: o, backend: t, attrs: e } = a, { x: n } = o, { reductionIndices: u, keepDims: l } = e, s = n.shape.length, c = w(u, n.shape);
+  let i = c;
+  const r = k(i, s), p = r != null, h = t.shouldExecuteOnCPU([n]);
+  let d = n;
+  if (p) {
+    if (h) {
+      const I = t.texData.get(d.dataId).values, g = new Array(s);
+      for (let $ = 0; $ < g.length; $++)
+        g[$] = n.shape[r[$]];
+      const z = B(I, n.shape, n.dtype, r, g);
+      d = t.makeTensorInfo(g, n.dtype);
+      const M = t.texData.get(d.dataId);
+      M.values = z;
     } else
-      p = Wt(s, h, n);
-    c = Vt(c.length, i);
-  }
-  Mt("max", c, i);
-  const [m, v] = mt(p.shape, c);
-  let d = m;
-  a && (d = wt(m, u));
-  let g;
-  if (w) {
-    const O = n.texData.get(p.dataId).values, b = Pn(O, y(v), d, s.dtype);
-    g = n.makeTensorInfo(d, s.dtype);
-    const V = n.texData.get(g.dataId);
-    V.values = b;
+      d = D(n, r, t);
+    i = R(i.length, s);
+  }
+  P("max", i, s);
+  const [f, v] = y(d.shape, i);
+  let x = f;
+  l && (x = O(f, c));
+  let m;
+  if (h) {
+    const I = t.texData.get(d.dataId).values, g = G(I, V(v), x, n.dtype);
+    m = t.makeTensorInfo(x, n.dtype);
+    const z = t.texData.get(m.dataId);
+    z.values = g;
   } else
-    g = qn(p, v, d, n);
-  return f && n.disposeIntermediateTensorInfo(p), g;
+    m = X(d, v, x, t);
+  return p && t.disposeIntermediateTensorInfo(d), m;
 }
 /**
  * @license
@@ -3279,17 +462,17 @@ function Gn(t) {
  * limitations under the License.
  * =============================================================================
  */
-function jn(t, e, n, o) {
-  const s = e, r = t.shape.length, a = ut(s, t.shape);
-  let i = a;
-  const u = Tt(i, r), c = u != null;
-  let h = t;
-  c && (h = Wt(t, u, o), i = Vt(i.length, r)), Mt("sum", i, r);
-  const [f, w] = mt(h.shape, i);
-  let p = f;
-  n && (p = wt(f, a));
-  const m = y(w), d = y(t.shape) / m, g = st({ inputs: { x: h }, attrs: { shape: [d, m] }, backend: o }), x = Kt(t.dtype), O = zt(g, x, "sum", o), b = st({ inputs: { x: O }, attrs: { shape: p }, backend: o });
-  return o.disposeIntermediateTensorInfo(g), o.disposeIntermediateTensorInfo(O), c && o.disposeIntermediateTensorInfo(h), b;
+function ee(a, o, t, e) {
+  const n = o, u = a.shape.length, l = w(n, a.shape);
+  let s = l;
+  const c = k(s, u), i = c != null;
+  let r = a;
+  i && (r = D(a, c, e), s = R(s.length, u)), P("sum", s, u);
+  const [p, h] = y(r.shape, s);
+  let d = p;
+  t && (d = O(p, l));
+  const f = V(h), x = V(a.shape) / f, m = b({ inputs: { x: r }, attrs: { shape: [x, f] }, backend: e }), S = K(a.dtype), I = N(m, S, "sum", e), g = b({ inputs: { x: I }, attrs: { shape: d }, backend: e });
+  return e.disposeIntermediateTensorInfo(m), e.disposeIntermediateTensorInfo(I), i && e.disposeIntermediateTensorInfo(r), g;
 }
 /**
  * @license
@@ -3307,9 +490,9 @@ function jn(t, e, n, o) {
  * limitations under the License.
  * =============================================================================
  */
-function Zn(t) {
-  const { inputs: e, backend: n, attrs: o } = t, { x: s } = e, { axis: r, keepDims: a } = o;
-  return jn(s, r, a, n);
+function te(a) {
+  const { inputs: o, backend: t, attrs: e } = a, { x: n } = o, { axis: u, keepDims: l } = e;
+  return ee(n, u, l, t);
 }
 /**
  * @license
@@ -3327,11 +510,11 @@ function Zn(t) {
  * limitations under the License.
  * =============================================================================
  */
-const Bn = `
+const ae = `
 if (a == b) {
   return 1.0;
 };
-return a / b;`, Hn = `
+return a / b;`, se = `
   // vec4 one = vec4(equal(a, b));
   // return one + (vec4(1.0) - one) * a / b;
   vec4 result = a / b;
@@ -3349,13 +532,13 @@ return a / b;`, Hn = `
   }
 
   return result;
-`, Kn = Jt({ opSnippet: Bn, packedOpSnippet: Hn, checkOutOfBounds: !0 });
-class Xn {
+`, oe = _({ opSnippet: ae, packedOpSnippet: se, checkOutOfBounds: !0 });
+class ne {
   variableNames = ["logits", "maxLogits"];
   outputShape;
   userCode;
-  constructor(e) {
-    this.outputShape = e, this.userCode = `
+  constructor(o) {
+    this.outputShape = o, this.userCode = `
         void main() {
         ivec4 coords = getOutputCoords(); // [batch, nh, t1, t2]
             int b = coords.x;
@@ -3369,7 +552,7 @@ class Xn {
         `;
   }
 }
-class Qn {
+class ie {
   variableNames = ["exp", "sum"];
   outputShape;
   userCode;
@@ -3377,8 +560,8 @@ class Qn {
     { name: "dropoutRate", type: "float" },
     { name: "seed", type: "float" }
   ];
-  constructor(e) {
-    this.outputShape = e, this.userCode = `
+  constructor(o) {
+    this.outputShape = o, 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);
@@ -3396,33 +579,33 @@ class Qn {
         `;
   }
 }
-function Yn(t) {
-  const { inputs: e, attrs: n } = t, { logits: o } = e, { dim: s, dropoutRate: r, seed: a } = n, i = t.backend;
-  if (!o)
+function re(a) {
+  const { inputs: o, attrs: t } = a, { logits: e } = o, { dim: n, dropoutRate: u, seed: l } = t, s = a.backend;
+  if (!e)
     throw new Error("Error in softmax: input logits is null");
-  const u = ut([s], o.shape), c = Gn({
-    inputs: { x: o },
-    backend: i,
-    attrs: { reductionIndices: u, keepDims: !1 }
-  }), h = wt(c.shape, u), f = new Xn(o.shape), w = i.runWebGLProgram(f, [o, c], "float32");
-  i.disposeIntermediateTensorInfo(c);
-  const p = Zn({ inputs: { x: w }, backend: i, attrs: { axis: u, keepDims: !1 } }), m = st({ inputs: { x: p }, backend: i, attrs: { shape: h } });
-  if (r !== void 0 && r > 0) {
-    const d = new Qn(o.shape), g = i.runWebGLProgram(d, [w, m], "float32", [
-      [r],
-      [a ?? Math.random() * 1e4]
+  const c = w([n], e.shape), i = Q({
+    inputs: { x: e },
+    backend: s,
+    attrs: { reductionIndices: c, keepDims: !1 }
+  }), r = O(i.shape, c), p = new ne(e.shape), h = s.runWebGLProgram(p, [e, i], "float32");
+  s.disposeIntermediateTensorInfo(i);
+  const d = te({ inputs: { x: h }, backend: s, attrs: { axis: c, keepDims: !1 } }), f = b({ inputs: { x: d }, backend: s, attrs: { shape: r } });
+  if (u !== void 0 && u > 0) {
+    const x = new ie(e.shape), m = s.runWebGLProgram(x, [h, f], "float32", [
+      [u],
+      [l ?? Math.random() * 1e4]
     ]);
-    return i.disposeIntermediateTensorInfo(w), i.disposeIntermediateTensorInfo(p), i.disposeIntermediateTensorInfo(m), g;
+    return s.disposeIntermediateTensorInfo(h), s.disposeIntermediateTensorInfo(d), s.disposeIntermediateTensorInfo(f), m;
   }
-  const v = Kn({ inputs: { a: w, b: m }, backend: i });
-  return i.disposeIntermediateTensorInfo(w), i.disposeIntermediateTensorInfo(p), i.disposeIntermediateTensorInfo(m), v;
+  const v = oe({ inputs: { a: h, b: f }, backend: s });
+  return s.disposeIntermediateTensorInfo(h), s.disposeIntermediateTensorInfo(d), s.disposeIntermediateTensorInfo(f), v;
 }
-const Jn = {
+const ue = {
   kernelName: "FusedSoftmax",
   backendName: "webgl",
-  kernelFunc: Yn
+  kernelFunc: re
 };
-Xt(Jn);
+W(ue);
 export {
-  Yn as softmax
+  re as softmax
 };