@genai-fi/nanogpt 0.13.0 → 0.14.0

package/dist/Generator.js

@@ -1,40 +1,40 @@
 import { E as Ui } from "./index-DvYrXKkX.js";
-import { o as Hi, q as Xi, E as Ki, dn as Ss, am as pe, aa as _, ar as oo, as as ao, e as Oe, aZ as Dt, ax as ro, ay as io, at as ji, au as Ft, aC as Ge, ad as co, aF as ws, aG as qi, U as G, ae as _e, aH as Yi, H as Ns, aI as Rs, R as Qi, ah as Zi, x as te, D as lo, _ as Ne, a8 as ee, bd as uo, c9 as Ts, ca as Es, cQ as po, bo as ho, af as ue, Q as Ye, bp as fo, bq as mo, cb as go, cc as Ds, cd as Fs, ce as Ps, cf as Os, cg as As, br as xo, ab as nt, cA as Co, cR as bo, cS as Io, bu as ko, bt as yo, bf as $o, dg as vo, C as _s, cU as So, an as wo, z as No, bv as Ro, c4 as $e, cF as To, bw as Eo, cB as Do, cV as Fo, cC as Po, bx as Ls, by as Vs, bh as Oo, bz as Ao, ak as Qe, V as Ji, bA as _o, cD as Lo, ch as Vo, bB as Wo, cH as Mo, cI as Bo, dh as Go, ci as zo, bZ as ns, bT as St, bW as Ws, cW as kn, dv as ut, dw as Uo, cX as yn, di as ec, N as tc, bg as Ho, cY as Xo, bD as Ms, A as Ko, aW as jo, aU as mt, cr as qo, de as Yo, df as Qo, bi as Zo, cG as Jo, dk as ea, aj as ta, G as sa, cs as na, cj as Bs, ck as Gs, cl as zs, dl as oa, b5 as Us, b6 as Hs, bF as Xs, cn as Ks, cm as aa, c_ as ra, aL as sc, bG as ia, cE as ca, c$ as la, d0 as ua, dm as da, aO as pa, a_ as ha, co as fa, bS as ma, M as js, I as ga, bk as xa, bm as Ca, bl as ba, bH as Ia, d5 as ka, bI as ya, P as $a, a6 as va, bJ as Sa, d1 as qs, dx as wa, dy as Na, dz as Ra, Z as Ta, cp as Ys, bb as Ea, d2 as Da, bc as Fa, d3 as Pa, bL as Oa, bj as Aa, b8 as Qs, ai as _a, dp as La, aK as Va, bN as Zs, cq as Js, bO as en, bP as tn, bE as sn, bK as Wa, dA as Ma, dB as Ba, dq as Ga, dr as za, ds as Ua, J as Ha, d4 as Xa, aJ as nn, ct as Ka, dt as ja, dC as qa, dD as Ya, cu as on, bs as an, du as Qa, T as Za, cv as Ja, bn as er, a5 as rn, cw as tr, ba as sr, bQ as nr, f as or, dE as ar, dF as $n, av as vn, aw as nc, t as rr, a as oc, dG as ac, dH as rc, c2 as ic, aq as cc, bR as lc, bX as uc, S as dc, bY as pc, aP as hc, ap as fc, bU as mc, bV as gc, b_ as xc, aR as ir, bC as Cc, aM as bc, b$ as Ic, F as kc, c0 as yc, dj as $c, b1 as vc, b2 as Sc, b3 as wc, b4 as Nc, aN as Rc, c1 as Tc, b7 as Ec, c7 as Dc, ao as Fc, c3 as Pc, aV as cr, bM as Oc, aE as Ac, c5 as _c, b9 as Lc, c6 as Vc, k as Wc } from "./index-twYeuV3_.js";
-import { n as Mc } from "./random_width-dPGM2S8E.js";
-import { t as Bc } from "./zeros_like-DkwhY6XC.js";
+import { o as Hi, q as Xi, E as Ki, dn as Ss, am as pe, a8 as _, ar as oo, as as ao, e as Oe, a_ as Dt, ax as ro, ay as io, at as ji, au as Ft, aD as Ge, ab as co, aG as ws, aH as qi, N as G, ac as _e, aI as Yi, D as Ns, aJ as Rs, R as Qi, af as Zi, x as te, B as lo, Y as Ne, a6 as ee, bd as uo, c9 as Ts, ca as Es, cQ as po, bo as ho, ad as ue, L as Ye, bp as fo, bq as mo, cb as go, cc as Ds, cd as Fs, ce as Ps, cf as Os, cg as As, br as xo, a9 as nt, cA as Co, cR as bo, cS as Io, bu as yo, bt as ko, bf as $o, dg as vo, aj as _s, cU as So, an as wo, C as No, bv as Ro, c4 as $e, cF as To, bw as Eo, cB as Do, cV as Fo, cC as Po, bx as Ls, by as Vs, bh as Oo, bz as Ao, ai as Qe, Q as Ji, bA as _o, cD as Lo, ch as Vo, bB as Wo, cH as Mo, cI as Bo, dh as Go, ci as zo, bZ as ns, bT as St, bW as Ws, cW as yn, dv as ut, dw as Uo, cX as kn, di as ec, K as tc, bg as Ho, cY as Xo, bD as Ms, z as Ko, aX as jo, aV as mt, cr as qo, de as Yo, df as Qo, bi as Zo, cG as Jo, dk as ea, ah as ta, G as sa, cs as na, cj as Bs, ck as Gs, cl as zs, dl as oa, b5 as Us, b6 as Hs, bF as Xs, cn as Ks, cm as aa, c_ as ra, aM as sc, bG as ia, cE as ca, c$ as la, d0 as ua, dm as da, aP as pa, a$ as ha, co as fa, bS as ma, M as js, F as ga, bk as xa, bm as Ca, bl as ba, bH as Ia, d5 as ya, bI as ka, P as $a, a4 as va, bJ as Sa, d1 as qs, dx as wa, dy as Na, dz as Ra, X as Ta, cp as Ys, bb as Ea, d2 as Da, bc as Fa, d3 as Pa, bL as Oa, bj as Aa, b8 as Qs, ag as _a, dp as La, aL as Va, bN as Zs, cq as Js, bO as en, bP as tn, bE as sn, bK as Wa, dA as Ma, dB as Ba, dq as Ga, dr as za, ds as Ua, H as Ha, d4 as Xa, aK as nn, ct as Ka, dt as ja, dC as qa, dD as Ya, cu as on, bs as an, du as Qa, T as Za, cv as Ja, bn as er, a3 as rn, cw as tr, ba as sr, bQ as nr, c as or, dE as ar, dF as $n, av as vn, aw as nc, t as rr, a as oc, dG as ac, dH as rc, c2 as ic, aq as cc, bR as lc, bX as uc, S as dc, bY as pc, aQ as hc, ap as fc, bU as mc, bV as gc, b_ as xc, aS as ir, bC as Cc, aN as bc, b$ as Ic, ak as yc, c0 as kc, dj as $c, b1 as vc, b2 as Sc, b3 as wc, b4 as Nc, aO as Rc, c1 as Tc, b7 as Ec, c7 as Dc, ao as Fc, c3 as Pc, aW as cr, bM as Oc, aF as Ac, c5 as _c, b9 as Lc, c6 as Vc, k as Wc } from "./index-3FfEY3tm.js";
+import { n as Mc } from "./random_width-DSeITIFc.js";
+import { t as Bc } from "./zeros_like-WQK7VrX-.js";
 import "./index-Cp39cXWe.js";
-import "./dataset-BMe3pbsL.js";
-import { a as j, u as ae, c as ot, i as at, b as Gc, d as wt, t as Re, e as gt, f as dt, g as lr, r as Nt, h as Ae, j as zc, k as Uc, l as cn, z as Hc, m as ln, n as ur, o as Xc, p as Kc, q as jc, v as qc, w as Yc, x as Qc, y as Zc, A as Jc, B as el, C as tl, D as lt, E as sl, F as nl, G as dr, H as ol, I as al, J as rl, K as il, L as cl, M as ll, N as ul, O as dl, P as pl, Q as hl, R as fl, S as ml, T as gl, U as xl, V as Cl, W as bl, X as Il, Y as kl, Z as yl, _ as $l, $ as vl, a0 as Sl, a1 as wl, a2 as Nl, a3 as Rl, a4 as Tl, a5 as El, a6 as Dl, a7 as Fl, a8 as Pl, a9 as Ol, aa as Al, ab as _l, ac as Ll, ad as Vl, ae as Wl, af as Ml, ag as Bl, ah as Gl, ai as zl } from "./shared-CGPl8HF1.js";
+import "./dataset-ZUdlBUXV.js";
+import { a as j, u as ae, c as ot, i as at, b as Gc, d as wt, t as Re, e as gt, f as dt, g as lr, r as Nt, h as Ae, j as zc, k as Uc, l as cn, z as Hc, m as ln, n as ur, o as Xc, p as Kc, q as jc, v as qc, w as Yc, x as Qc, y as Zc, A as Jc, B as el, C as tl, D as lt, E as sl, F as nl, G as dr, H as ol, I as al, J as rl, K as il, L as cl, M as ll, N as ul, O as dl, P as pl, Q as hl, R as fl, S as ml, T as gl, U as xl, V as Cl, W as bl, X as Il, Y as yl, Z as kl, _ as $l, $ as vl, a0 as Sl, a1 as wl, a2 as Nl, a3 as Rl, a4 as Tl, a5 as El, a6 as Dl, a7 as Fl, a8 as Pl, a9 as Ol, aa as Al, ab as _l, ac as Ll, ad as Vl, ae as Wl, af as Ml, ag as Bl, ah as Gl, ai as zl } from "./shared-DeC0UJkK.js";
 import { m as pt, g as pr, s as Ul, c as Hl, b as Xl, d as Kl, a as jl, e as ql } from "./complex_util-Yc1A_gV1.js";
-import { a as ge, b as xe, d as ye, c as ve, e as Te, g as os } from "./axis_util-BHRVWB9q.js";
-import { k as Ze, h as Le, i as Je, j as rt, b as Se, d as xt, g as as } from "./step-BKoz1z1b.js";
-import { z as rs, A as is, B as cs, C as hr, D as fr, F as mr, G as gr, H as xr, I as Cr, J as br, y as Ir, x as kr, w as yr, u as $r, t as vr, E as Sr, K as wr, L as Nr, M as Rr, N as Tr, c as Er, f as Yl, O as Ql, P as Zl } from "./backend_util-WwsVDDYb.js";
-import { a as Dr, c as Ue } from "./concat_util-B4pv30-l.js";
+import { a as ge, b as xe, d as ke, c as ve, e as Te, g as os } from "./axis_util-RrJzDQJc.js";
+import { k as Ze, h as Le, i as Je, j as rt, b as Se, d as xt, g as as } from "./step-CA-PdcE1.js";
+import { z as rs, A as is, B as cs, C as hr, D as fr, F as mr, G as gr, H as xr, I as Cr, J as br, y as Ir, x as yr, w as kr, u as $r, t as vr, E as Sr, K as wr, L as Nr, M as Rr, N as Tr, c as Er, f as Yl, O as Ql, P as Zl } from "./backend_util-9wV3yg0r.js";
+import { a as Dr, c as Ue } from "./concat_util-DVNU-Nn3.js";
 import { s as Jl } from "./index-CieiGp4Y.js";
 import { n as Fr, b as Pr, a as Or } from "./non_max_suppression_impl-B2W7YjZB.js";
-import { c as Ct } from "./scatter_nd_util-BGx2xTV9.js";
-import { S as Ar, a as _r } from "./selu_util-D-1DRWiG.js";
-import { b as Lr, d as Vr, p as eu, a as tu, i as su, c as nu } from "./slice_util-BDUbSScY.js";
-import { h as Sn, j as ou, k as au, l as ru, m as iu, n as cu, o as lu, P as un, p as Ve, u as Pe, q as Wr, c as Mr, T as De, E as Br, g as Gr, a as zr, r as uu, s as du, t as Y, v as Pt, w as pu, x as wn, y as hu, z as fu, A as Ot, B as mu, C as gu, D as bs, F as Gt, G as zt, H as xu, I as Cu, J as Nn, K as bu, L as Iu, M as fs, N as ku, O as yu, Q as $u, R as Ut, S as ms, U as vu, f as he, V as be, W as Ht, X as Xt, Y as Su, d as Rn, e as Tn, i as Ur, Z as wu, _ as Nu, $ as Ru, a0 as Tu, a1 as Eu, a2 as Du, a3 as At } from "./gpgpu_math-DHr3JJdA.js";
-import { s as Hr, a as Fu, t as Xr, b as Pu, c as Ou, d as Kr, e as Au, n as _u, f as Lu, g as Vu, h as Wu, i as Mu, j as Bu, k as Gu, l as zu, o as Uu, p as Hu, q as Xu, r as Ku, u as ju, v as qu, w as Yu, x as Qu, y as Zu, z as Ju, A as ed, B as td, C as sd, D as nd, E as od, F as ad, G as rd, H as id, I as cd, J as ld, K as ud, L as dd, M as jr, N as pd, O as hd, P as fd, Q as md, R as gd, S as xd, T as Cd, U as bd, V as Id, W as kd } from "./shared-Bcb0d2u4.js";
-import { a as ke, c as yd, U as st, d as qe, e as ze, A as En, f as bt, B as dn, h as pn, m as Rt, u as se, C as We, b as Ce, i as Fe, j as hn, k as it, l as It, n as $d, o as vd, p as Sd, q as wd } from "./kernel_funcs_utils-BmhOJVrj.js";
-import { R as Nd, r as U, a as Rd } from "./Reshape-Bif3B22e.js";
-import { M as qr } from "./matMulGelu-CoUYwB2k.js";
-import { t as Yr, s as fn, a as _t, m as Td, r as Ed, b as Dd, c as Fd, d as Pd } from "./RealDiv-Bh9xYk2V.js";
-import { z as Od } from "./zeros-BhOPXbkT.js";
+import { c as Ct } from "./scatter_nd_util-6lhBuxGa.js";
+import { S as Ar, a as _r } from "./selu_util-emNhirms.js";
+import { b as Lr, d as Vr, p as eu, a as tu, i as su, c as nu } from "./slice_util-5UIO9Akz.js";
+import { h as Sn, j as ou, k as au, l as ru, m as iu, n as cu, o as lu, P as un, p as Ve, u as Pe, q as Wr, c as Mr, T as De, E as Br, g as Gr, a as zr, r as uu, s as du, t as Y, v as Pt, w as pu, x as wn, y as hu, z as fu, A as Ot, B as mu, C as gu, D as bs, F as Gt, G as zt, H as xu, I as Cu, J as Nn, K as bu, L as Iu, M as fs, N as yu, O as ku, Q as $u, R as Ut, S as ms, U as vu, f as he, V as be, W as Ht, X as Xt, Y as Su, d as Rn, e as Tn, i as Ur, Z as wu, _ as Nu, $ as Ru, a0 as Tu, a1 as Eu, a2 as Du, a3 as At } from "./gpgpu_math-Dzx_EUJa.js";
+import { s as Hr, a as Fu, t as Xr, b as Pu, c as Ou, d as Kr, e as Au, n as _u, f as Lu, g as Vu, h as Wu, i as Mu, j as Bu, k as Gu, l as zu, o as Uu, p as Hu, q as Xu, r as Ku, u as ju, v as qu, w as Yu, x as Qu, y as Zu, z as Ju, A as ed, B as td, C as sd, D as nd, E as od, F as ad, G as rd, H as id, I as cd, J as ld, K as ud, L as dd, M as jr, N as pd, O as hd, P as fd, Q as md, R as gd, S as xd, T as Cd, U as bd, V as Id, W as yd } from "./shared-Wn4Lkf40.js";
+import { a as ye, c as kd, U as st, d as qe, e as ze, A as En, f as bt, B as dn, h as pn, m as Rt, u as se, C as We, b as Ce, i as Fe, j as hn, k as it, l as It, n as $d, o as vd, p as Sd, q as wd } from "./kernel_funcs_utils-BLvDeLPe.js";
+import { R as Nd, r as U, a as Rd } from "./Reshape-D973Ba8R.js";
+import { M as qr } from "./matMulGelu-Bdxn3VPX.js";
+import { t as Yr, s as fn, a as _t, m as Td, r as Ed, b as Dd, c as Fd, d as Pd } from "./RealDiv-B2Tyc34U.js";
+import { z as Od } from "./zeros-BJogAj4Z.js";
 import "./ops/cpu/attentionMask.js";
 import "./ops/webgl/attentionMask.js";
 import "./ops/grads/attentionMask.js";
 import "./ops/cpu/rope.js";
 import "./ops/webgl/rope.js";
-import "./rope-D4uclsO_.js";
+import "./rope-D5BJXlc7.js";
 import "./ops/cpu/appendCache.js";
 import "./ops/webgl/appendCache.js";
 import "./ops/grads/softmax16.js";
-import "./matMul16-CH8D42Kx.js";
+import "./matMul16-Bp17gt56.js";
 import "./ops/webgl/matMul16.js";
 import "./ops/cpu/matMul16.js";
-import "./pack16--wBZRF6e.js";
+import "./pack16-F9gxcBrq.js";
 import "./ops/transpose16.js";
 import "./ops/reshape16.js";
 import "./ops/cpu/qkv.js";
@@ -62,17 +62,17 @@ import "./ops/cpu/matMulGelu.js";
 import "./ops/grads/matMulGelu.js";
 import "./ops/cpu/gelu.js";
 import "./ops/webgl/gelu.js";
-import "./gelu-BtVbXd4E.js";
+import "./gelu-9_DFp2Q5.js";
 import "./ops/webgl/log.js";
 import "./checks/normRMS.js";
 import "./checks/normRMSGrad.js";
 import Wd from "./utilities/multinomialCPU.js";
-import { r as Dn } from "./reshape-C5l1dyBS.js";
-import { t as Kt } from "./tensor2d-C9fH5XJR.js";
-import { z as Md } from "./unsorted_segment_sum-Bmy800Yn.js";
-import { s as gs } from "./softmax-DpG1TdjZ.js";
-import { g as Bd } from "./gather-BsgneLul.js";
-import { c as Gd } from "./concat-BftwuH26.js";
+import { r as Dn } from "./reshape-3ugLpT-p.js";
+import { t as Kt } from "./tensor2d-DryAvP1o.js";
+import { z as Md } from "./unsorted_segment_sum-C23hrdi0.js";
+import { s as gs } from "./softmax-BSXRSMAA.js";
+import { g as Bd } from "./gather-BYhIiO5e.js";
+import { c as Gd } from "./concat-B9WckkXa.js";
 function zd(a, t, e, n = !1) {
   const s = Xi(a, "logits", "multinomial"), o = s.size, r = s.rank;
   if (o < 2)
@@ -316,7 +316,7 @@ function ni(a) {
   j([s, o], "matMul");
   const i = s.shape.length, l = o.shape.length, u = r ? s.shape[i - 2] : s.shape[i - 1], p = c ? o.shape[l - 1] : o.shape[l - 2], d = r ? s.shape[i - 1] : s.shape[i - 2], h = c ? o.shape[l - 2] : o.shape[l - 1], f = s.shape.slice(0, -2), m = o.shape.slice(0, -2), x = G(f), g = G(m), I = Ne(s.shape.slice(0, -2), o.shape.slice(0, -2)).concat([d, h]);
   te(u === p, () => `Error in matMul: inner shapes (${u}) and (${p}) of Tensors with shapes ${s.shape} and ${o.shape} and transposeA=${r} and transposeB=${c} must match.`);
-  const b = r ? [x, u, d] : [x, d, u], k = c ? [g, h, p] : [g, p, h], y = ce({ inputs: { x: s }, backend: e, attrs: { shape: b } }), $ = ce({ inputs: { x: o }, backend: e, attrs: { shape: k } }), v = r ? y.shape[1] : y.shape[2], w = r ? y.shape[2] : y.shape[1], S = c ? $.shape[1] : $.shape[2], E = Math.max(x, g), P = e.data.get(y.dataId).values, D = e.data.get($.dataId).values, F = ee(y.shape), R = ee($.shape), [T, A, N] = r ? [F[0], 1, F[1]] : [F[0], F[1], 1], [O, V, L] = c ? [1, R[1], R[0]] : [R[1], 1, R[0]], B = w * S, W = pe([E, w, S], y.dtype), z = W.values, M = e.blockSize;
+  const b = r ? [x, u, d] : [x, d, u], y = c ? [g, h, p] : [g, p, h], k = ce({ inputs: { x: s }, backend: e, attrs: { shape: b } }), $ = ce({ inputs: { x: o }, backend: e, attrs: { shape: y } }), v = r ? k.shape[1] : k.shape[2], w = r ? k.shape[2] : k.shape[1], S = c ? $.shape[1] : $.shape[2], E = Math.max(x, g), P = e.data.get(k.dataId).values, D = e.data.get($.dataId).values, F = ee(k.shape), R = ee($.shape), [T, A, N] = r ? [F[0], 1, F[1]] : [F[0], F[1], 1], [O, V, L] = c ? [1, R[1], R[0]] : [R[1], 1, R[0]], B = w * S, W = pe([E, w, S], k.dtype), z = W.values, M = e.blockSize;
   for (let H = 0; H < E; H++) {
     const K = H % x, Q = H % g;
     for (let q = 0; q < w; q += M) {
@@ -344,7 +344,7 @@ function ni(a) {
       }
     }
   }
-  return e.disposeIntermediateTensorInfo(y), e.disposeIntermediateTensorInfo($), e.makeTensorInfo(I, W.dtype, W.values);
+  return e.disposeIntermediateTensorInfo(k), e.disposeIntermediateTensorInfo($), e.makeTensorInfo(I, W.dtype, W.values);
 }
 const Jd = {
   kernelName: lo,
@@ -398,14 +398,14 @@ function cp(a) {
   let i = c;
   const l = ge(i, s.shape.length);
   let u = s;
-  l != null && (u = Re({ inputs: { x: s }, backend: e, attrs: { perm: l } }), i = xe(i.length, s.shape.length)), ye("all", i, u.shape.length);
+  l != null && (u = Re({ inputs: { x: s }, backend: e, attrs: { perm: l } }), i = xe(i.length, s.shape.length)), ke("all", i, u.shape.length);
   const [p, d] = ve(u.shape, i), h = G(d), f = Ye(G(p), u.dtype), m = e.data.get(u.dataId).values;
   for (let g = 0; g < f.length; ++g) {
     const C = g * h;
     let I = m[C];
     for (let b = 0; b < h; ++b) {
-      const k = m[C + b];
-      I = I && k;
+      const y = m[C + b];
+      I = I && y;
     }
     f[g] = I;
   }
@@ -429,14 +429,14 @@ function up(a) {
   let i = c;
   const l = ge(i, s.shape.length);
   let u = s;
-  l != null && (u = Re({ inputs: { x: s }, backend: e, attrs: { perm: l } }), i = xe(i.length, s.shape.length)), ye("any", i, u.shape.length);
+  l != null && (u = Re({ inputs: { x: s }, backend: e, attrs: { perm: l } }), i = xe(i.length, s.shape.length)), ke("any", i, u.shape.length);
   const [p, d] = ve(u.shape, i), h = G(d), f = Ye(G(p), u.dtype), m = e.data.get(u.dataId).values;
   for (let g = 0; g < f.length; ++g) {
     const C = g * h;
     let I = m[C];
     for (let b = 0; b < h; ++b) {
-      const k = m[C + b];
-      I = I || k;
+      const y = m[C + b];
+      I = I || y;
     }
     f[g] = I;
   }
@@ -460,14 +460,14 @@ function pp(a) {
   const c = ge(r, s.shape.length);
   let i = s;
   const l = [];
-  c != null && (i = Re({ inputs: { x: s }, backend: e, attrs: { perm: c } }), l.push(i), r = xe(r.length, i.shape.length)), r = [r[0]], ye("argMax", r, i.shape.length);
+  c != null && (i = Re({ inputs: { x: s }, backend: e, attrs: { perm: c } }), l.push(i), r = xe(r.length, i.shape.length)), r = [r[0]], ke("argMax", r, i.shape.length);
   const [u, p] = ve(i.shape, r), d = G(u), h = Ye(d, "int32"), f = G(p), m = e.data.get(i.dataId).values;
   for (let x = 0; x < h.length; ++x) {
     const g = x * f;
     let C = m[g], I = 0;
     for (let b = 0; b < f; ++b) {
-      const k = m[g + b];
-      k > C && (C = k, I = b);
+      const y = m[g + b];
+      y > C && (C = y, I = b);
     }
     h[x] = I;
   }
@@ -485,14 +485,14 @@ function fp(a) {
   const c = ge(r, s.shape.length);
   let i = s;
   const l = [];
-  c != null && (i = Re({ inputs: { x: s }, backend: e, attrs: { perm: c } }), l.push(i), r = xe(r.length, i.shape.length)), r = [r[0]], ye("argMin", r, i.shape.length);
+  c != null && (i = Re({ inputs: { x: s }, backend: e, attrs: { perm: c } }), l.push(i), r = xe(r.length, i.shape.length)), r = [r[0]], ke("argMin", r, i.shape.length);
   const [u, p] = ve(i.shape, r), d = G(u), h = Ye(d, "int32"), f = G(p), m = e.data.get(i.dataId).values;
   for (let x = 0; x < h.length; ++x) {
     const g = x * f;
     let C = m[g], I = 0;
     for (let b = 0; b < f; ++b) {
-      const k = m[g + b];
-      k < C && (C = k, I = b);
+      const y = m[g + b];
+      y < C && (C = y, I = b);
     }
     h[x] = I;
   }
@@ -513,12 +513,12 @@ const Cp = ae(Fs, (a) => Math.asinh(a)), bp = {
   backendName: "cpu",
   kernelFunc: Cp
 };
-const Ip = ae(Ps, (a) => Math.atan(a)), kp = {
+const Ip = ae(Ps, (a) => Math.atan(a)), yp = {
   kernelName: Ps,
   backendName: "cpu",
   kernelFunc: Ip
 };
-const yp = ot((a, t) => Math.atan2(a, t)), $p = gt(Os, yp), vp = {
+const kp = ot((a, t) => Math.atan2(a, t)), $p = gt(Os, kp), vp = {
   kernelName: Os,
   backendName: "cpu",
   kernelFunc: $p
@@ -531,15 +531,15 @@ const Sp = ae(As, (a) => Math.atanh(a)), wp = {
 function mn(a, t, e, n, s, o) {
   const r = s.strideHeight, c = s.strideWidth, i = s.dilationHeight, l = s.dilationWidth, u = s.effectiveFilterHeight, p = s.effectiveFilterWidth, d = s.padInfo.top, h = s.padInfo.left, f = o === "max" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY, m = pe(s.outShape, e), x = m.values, g = s.outShape[1] * s.outShape[2] * s.outShape[3], C = s.outShape[2] * s.outShape[3], I = s.outShape[3];
   for (let b = 0; b < s.batchSize; ++b) {
-    const k = b * g, y = b * n[0];
+    const y = b * g, k = b * n[0];
     for (let $ = 0; $ < s.inChannels; ++$)
       for (let v = 0; v < s.outHeight; ++v) {
-        const w = v * r - d, S = Math.max(0, w), E = Math.min(s.inHeight, u + w), P = k + v * C;
+        const w = v * r - d, S = Math.max(0, w), E = Math.min(s.inHeight, u + w), P = y + v * C;
         for (let D = 0; D < s.outWidth; ++D) {
           const F = D * c - h, R = Math.max(0, F), T = Math.min(s.inWidth, p + F);
           let A = f, N = 0, O = 0;
           for (let L = S; L < E; L += i) {
-            const B = y + L * n[1];
+            const B = k + L * n[1];
             for (let W = R; W < T; W += l) {
               const z = B + W * n[2], M = a[z + $];
               o === "max" && M > A ? A = M : o === "avg" && (N += M, O++);
@@ -563,37 +563,37 @@ function oi(a, t, e, n, s = !1, o = !1) {
         let b = I;
         for (; b < 0; )
           b += l;
-        const k = Math.min(n.inHeight, p + I);
-        for (let y = 0; y < n.outWidth; ++y) {
-          const $ = y * i - f;
+        const y = Math.min(n.inHeight, p + I);
+        for (let k = 0; k < n.outWidth; ++k) {
+          const $ = k * i - f;
           let v = $;
           for (; v < 0; )
             v += u;
           const w = Math.min(n.inWidth, d + $);
           let S = Number.NEGATIVE_INFINITY, E = -1;
-          for (let P = b; P < k; P += l) {
+          for (let P = b; P < y; P += l) {
             const D = P - I;
             for (let F = v; F < w; F += u) {
               const R = F - $, T = m.get(x, P, F, g);
               T > S && (S = T, s ? E = o ? ((x * n.inHeight + P) * n.inWidth + F) * n.inChannels + g : (P * n.inWidth + F) * n.inChannels + g : E = D * d + R);
             }
           }
-          r.set(E, x, C, y, g);
+          r.set(E, x, C, k, g);
         }
       }
   return r;
 }
 function ai(a, t, e, n, s, o) {
-  const r = s.strideDepth, c = s.strideHeight, i = s.strideWidth, l = s.dilationDepth, u = s.dilationHeight, p = s.dilationWidth, d = s.effectiveFilterDepth, h = s.effectiveFilterHeight, f = s.effectiveFilterWidth, m = s.padInfo.front, x = s.padInfo.top, g = s.padInfo.left, C = o === "max" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY, I = pe(s.outShape, e), b = I.values, k = s.outShape[1] * s.outShape[2] * s.outShape[3] * s.outShape[4], y = s.outShape[2] * s.outShape[3] * s.outShape[4], $ = s.outShape[3] * s.outShape[4], v = s.outShape[4];
+  const r = s.strideDepth, c = s.strideHeight, i = s.strideWidth, l = s.dilationDepth, u = s.dilationHeight, p = s.dilationWidth, d = s.effectiveFilterDepth, h = s.effectiveFilterHeight, f = s.effectiveFilterWidth, m = s.padInfo.front, x = s.padInfo.top, g = s.padInfo.left, C = o === "max" ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY, I = pe(s.outShape, e), b = I.values, y = s.outShape[1] * s.outShape[2] * s.outShape[3] * s.outShape[4], k = s.outShape[2] * s.outShape[3] * s.outShape[4], $ = s.outShape[3] * s.outShape[4], v = s.outShape[4];
   for (let w = 0; w < s.batchSize; ++w) {
-    const S = w * k, E = w * n[0];
+    const S = w * y, E = w * n[0];
     for (let P = 0; P < s.inChannels; ++P)
       for (let D = 0; D < s.outDepth; ++D) {
         const F = D * r - m;
         let R = F;
         for (; R < 0; )
           R += l;
-        const T = Math.min(s.inDepth, d + F), A = S + D * y;
+        const T = Math.min(s.inDepth, d + F), A = S + D * k;
         for (let N = 0; N < s.outHeight; ++N) {
           const O = N * c - x;
           let V = O;
@@ -640,12 +640,12 @@ function Np(a, t) {
         for (; I < 0; )
           I += r;
         const b = Math.min(t.inDepth, l + C);
-        for (let k = 0; k < t.outHeight; ++k) {
-          const y = k * s - h;
-          let $ = y;
+        for (let y = 0; y < t.outHeight; ++y) {
+          const k = y * s - h;
+          let $ = k;
           for (; $ < 0; )
             $ += c;
-          const v = Math.min(t.inHeight, u + y);
+          const v = Math.min(t.inHeight, u + k);
           for (let w = 0; w < t.outWidth; ++w) {
             const S = w * o - f;
             let E = S;
@@ -656,14 +656,14 @@ function Np(a, t) {
             for (let R = I; R < b; R += r) {
               const T = R - C;
               for (let A = $; A < v; A += c) {
-                const N = A - y;
+                const N = A - k;
                 for (let O = E; O < P; O += i) {
                   const V = O - S, L = a.get(m, R, A, O, x);
                   L >= D && (D = L, F = T * u * p + N * u + V);
                 }
               }
             }
-            e.set(F, m, g, k, w, x);
+            e.set(F, m, g, y, w, x);
           }
         }
       }
@@ -703,7 +703,7 @@ const Dp = {
 function Fp(a) {
   const { inputs: t, backend: e, attrs: n } = a, { dy: s, input: o } = t, { filterSize: r, strides: c, pad: i, dimRoundingMode: l } = n;
   j([s, o], "avgPool3DGrad");
-  const u = Je(o.shape, r, c, 1, i, l), p = u.strideDepth, d = u.strideHeight, h = u.strideWidth, f = u.filterDepth, m = u.filterHeight, x = u.filterWidth, g = u.dilationDepth, C = u.dilationHeight, I = u.dilationWidth, b = u.effectiveFilterDepth, k = u.effectiveFilterHeight, y = u.effectiveFilterWidth, $ = b - 1 - u.padInfo.front, v = y - 1 - u.padInfo.left, w = k - 1 - u.padInfo.top, S = pe(o.shape, "float32"), E = 1 / (f * m * x), P = e.bufferSync(s);
+  const u = Je(o.shape, r, c, 1, i, l), p = u.strideDepth, d = u.strideHeight, h = u.strideWidth, f = u.filterDepth, m = u.filterHeight, x = u.filterWidth, g = u.dilationDepth, C = u.dilationHeight, I = u.dilationWidth, b = u.effectiveFilterDepth, y = u.effectiveFilterHeight, k = u.effectiveFilterWidth, $ = b - 1 - u.padInfo.front, v = k - 1 - u.padInfo.left, w = y - 1 - u.padInfo.top, S = pe(o.shape, "float32"), E = 1 / (f * m * x), P = e.bufferSync(s);
   for (let D = 0; D < u.batchSize; ++D)
     for (let F = 0; F < u.inChannels; ++F)
       for (let R = 0; R < u.inDepth; ++R)
@@ -714,10 +714,10 @@ function Fp(a) {
             for (let B = 0; B < b; B += g) {
               const W = (N + B) / p;
               if (!(W < 0 || W >= u.outDepth || Math.floor(W) !== W))
-                for (let z = 0; z < k; z += C) {
+                for (let z = 0; z < y; z += C) {
                   const M = (O + z) / d;
                   if (!(M < 0 || M >= u.outHeight || Math.floor(M) !== M))
-                    for (let H = 0; H < y; H += I) {
+                    for (let H = 0; H < k; H += I) {
                       const K = (V + H) / h;
                       if (K < 0 || K >= u.outWidth || Math.floor(K) !== K)
                         continue;
@@ -738,7 +738,7 @@ const Pp = {
 function Op(a) {
   const { inputs: t, backend: e, attrs: n } = a, { dy: s, input: o } = t, r = o;
   j([s, o], "avgPoolGrad");
-  const { filterSize: c, strides: i, pad: l } = n, u = Le(r.shape, c, i, 1, l), p = u.strideHeight, d = u.strideWidth, h = u.filterHeight, f = u.filterWidth, m = u.dilationHeight, x = u.dilationWidth, g = u.effectiveFilterHeight, C = u.effectiveFilterWidth, I = C - 1 - u.padInfo.left, b = g - 1 - u.padInfo.top, k = pe(r.shape, "float32"), y = 1 / (h * f), $ = e.data.get(s.dataId).values, v = pe(s.shape, "float32", $);
+  const { filterSize: c, strides: i, pad: l } = n, u = Le(r.shape, c, i, 1, l), p = u.strideHeight, d = u.strideWidth, h = u.filterHeight, f = u.filterWidth, m = u.dilationHeight, x = u.dilationWidth, g = u.effectiveFilterHeight, C = u.effectiveFilterWidth, I = C - 1 - u.padInfo.left, b = g - 1 - u.padInfo.top, y = pe(r.shape, "float32"), k = 1 / (h * f), $ = e.data.get(s.dataId).values, v = pe(s.shape, "float32", $);
   for (let w = 0; w < u.batchSize; ++w)
     for (let S = 0; S < u.inChannels; ++S)
       for (let E = 0; E < u.inHeight; ++E)
@@ -756,9 +756,9 @@ function Op(a) {
                 R += V;
               }
           }
-          k.set(R * y, w, E, P, S);
+          y.set(R * k, w, E, P, S);
         }
-  return e.makeTensorInfo(k.shape, k.dtype, k.values);
+  return e.makeTensorInfo(y.shape, y.dtype, y.values);
 }
 const Ap = {
   kernelName: Io,
@@ -771,13 +771,13 @@ function _p(a) {
   let { varianceEpsilon: l } = n;
   l == null && (l = 1e-3);
   const u = e.data.get(s.dataId).values, p = e.data.get(c.dataId).values, d = e.data.get(i.dataId).values, h = o ? e.data.get(o.dataId).values : new Float32Array([1]), f = r ? e.data.get(r.dataId).values : new Float32Array([0]), m = new Float32Array(u.length), x = f.length, g = h.length, C = d.length, I = p.length;
-  let b = 0, k = 0, y = 0, $ = 0;
+  let b = 0, y = 0, k = 0, $ = 0;
   for (let v = 0; v < u.length; ++v)
-    m[v] = f[b++] + (u[v] - p[k++]) * h[y++] / Math.sqrt(d[$++] + l), b >= x && (b = 0), k >= I && (k = 0), y >= g && (y = 0), $ >= C && ($ = 0);
+    m[v] = f[b++] + (u[v] - p[y++]) * h[k++] / Math.sqrt(d[$++] + l), b >= x && (b = 0), y >= I && (y = 0), k >= g && (k = 0), $ >= C && ($ = 0);
   return e.makeTensorInfo(s.shape, s.dtype, m);
 }
 const Lp = {
-  kernelName: ko,
+  kernelName: yo,
   backendName: "cpu",
   kernelFunc: _p
 };
@@ -792,7 +792,7 @@ function Vp(a) {
   return e.disposeIntermediateTensorInfo(h), e.disposeIntermediateTensorInfo(f), e.disposeIntermediateTensorInfo(m), x;
 }
 const Wp = {
-  kernelName: yo,
+  kernelName: ko,
   backendName: "cpu",
   kernelFunc: Vp
 };
@@ -876,7 +876,7 @@ const qp = {
 function ri(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s, filter: o } = t, { strides: r, pad: c, dataFormat: i, dilations: l, dimRoundingMode: u } = n;
   j([s, o], "conv2d");
-  const p = rt(i), d = Se(s.shape, o.shape, r, l, c, u, !1, p), h = d.filterHeight, f = d.filterWidth, m = d.dilationHeight, x = d.dilationWidth, g = d.padInfo.left, C = d.padInfo.top, I = d.dataFormat === "channelsLast", b = new $e(d.outShape, s.dtype), k = ee(s.shape), y = ee(o.shape), $ = k[0], v = I ? k[1] : k[2], w = I ? k[2] : 1, S = I ? 1 : k[1], E = b.strides[0], P = I ? b.strides[1] : b.strides[2], D = I ? b.strides[2] : 1, F = I ? 1 : b.strides[1], R = e.data.get(s.dataId).values, T = e.data.get(o.dataId).values, A = b.values;
+  const p = rt(i), d = Se(s.shape, o.shape, r, l, c, u, !1, p), h = d.filterHeight, f = d.filterWidth, m = d.dilationHeight, x = d.dilationWidth, g = d.padInfo.left, C = d.padInfo.top, I = d.dataFormat === "channelsLast", b = new $e(d.outShape, s.dtype), y = ee(s.shape), k = ee(o.shape), $ = y[0], v = I ? y[1] : y[2], w = I ? y[2] : 1, S = I ? 1 : y[1], E = b.strides[0], P = I ? b.strides[1] : b.strides[2], D = I ? b.strides[2] : 1, F = I ? 1 : b.strides[1], R = e.data.get(s.dataId).values, T = e.data.get(o.dataId).values, A = b.values;
   for (let N = 0; N < d.batchSize; ++N) {
     const O = N * $, V = N * E;
     for (let L = 0; L < d.outHeight; ++L) {
@@ -885,14 +885,14 @@ function ri(a) {
         const M = W + z * m;
         if (M < 0 || M >= d.inHeight)
           continue;
-        const H = z * y[0], K = O + M * v;
+        const H = z * k[0], K = O + M * v;
         for (let Q = 0; Q < d.outWidth; ++Q) {
           const q = B + Q * D, Z = Q * d.strideWidth - g;
           for (let J = 0; J < f; ++J) {
             const ne = Z + J * x;
             if (ne < 0 || ne >= d.inWidth)
               continue;
-            const re = H + J * y[1], fe = K + ne * w;
+            const re = H + J * k[1], fe = K + ne * w;
             let ie = re;
             for (let oe = 0; oe < d.inChannels; ++oe) {
               const de = R[fe + oe * S];
@@ -915,7 +915,7 @@ const Yp = {
 function Qp(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s, dy: o } = t, { strides: r, pad: c, dataFormat: i, dimRoundingMode: l, filterShape: u } = n;
   j([s, o], "conv2dBackpropFilter");
-  const p = rt(i), d = Se(s.shape, u, r, 1, c, l, !1, p), { strideHeight: h, strideWidth: f, filterHeight: m, filterWidth: x } = d, g = d.dataFormat === "channelsLast", C = new $e(d.filterShape, "float32"), I = d.padInfo.left, b = d.padInfo.top, k = e.data.get(s.dataId).values, y = e.data.get(o.dataId).values, $ = new $e(s.shape, s.dtype, k), v = new $e(o.shape, o.dtype, y);
+  const p = rt(i), d = Se(s.shape, u, r, 1, c, l, !1, p), { strideHeight: h, strideWidth: f, filterHeight: m, filterWidth: x } = d, g = d.dataFormat === "channelsLast", C = new $e(d.filterShape, "float32"), I = d.padInfo.left, b = d.padInfo.top, y = e.data.get(s.dataId).values, k = e.data.get(o.dataId).values, $ = new $e(s.shape, s.dtype, y), v = new $e(o.shape, o.dtype, k);
   for (let w = 0; w < m; ++w) {
     const S = Math.max(0, Math.ceil((b - w) / h)), E = Math.min(d.outHeight, (d.inHeight + b - w) / h);
     for (let P = 0; P < x; ++P) {
@@ -947,10 +947,10 @@ function Jp(a) {
   j([s, o], "conv2dBackpropInput");
   const p = ee(o.shape), d = ee(s.shape);
   let h = rt(l);
-  const f = Se(r, o.shape, c, 1, i, u, !1, h), m = new $e(f.inShape, "float32"), x = m.values, g = e.data.get(s.dataId).values, C = e.data.get(o.dataId).values, [I, b, k] = p, { batchSize: y, filterHeight: $, filterWidth: v, inChannels: w, inHeight: S, inWidth: E, outChannels: P, outHeight: D, outWidth: F, strideHeight: R, strideWidth: T } = f;
+  const f = Se(r, o.shape, c, 1, i, u, !1, h), m = new $e(f.inShape, "float32"), x = m.values, g = e.data.get(s.dataId).values, C = e.data.get(o.dataId).values, [I, b, y] = p, { batchSize: k, filterHeight: $, filterWidth: v, inChannels: w, inHeight: S, inWidth: E, outChannels: P, outHeight: D, outWidth: F, strideHeight: R, strideWidth: T } = f;
   h = f.dataFormat;
   const A = $ - 1 - f.padInfo.top, N = v - 1 - f.padInfo.left, O = h === "channelsLast", V = m.strides[0], L = O ? m.strides[1] : m.strides[2], B = O ? m.strides[2] : 1, W = O ? 1 : m.strides[1], z = d[0], M = O ? d[1] : d[2], H = O ? d[2] : 1, K = O ? 1 : d[1];
-  for (let Q = 0; Q < y; ++Q)
+  for (let Q = 0; Q < k; ++Q)
     for (let q = 0; q < w; ++q)
       for (let Z = 0; Z < S; ++Z) {
         const J = Z - A, ne = Math.max(0, Math.ceil(J / R)), re = Math.min(D, ($ + J) / R);
@@ -960,7 +960,7 @@ function Jp(a) {
           for (let me = ne; me < re; ++me) {
             const He = me * R - J;
             for (let we = oe; we < de; ++we) {
-              const et = we * T - ie, Ee = z * Q + M * me + H * we, Be = I * ($ - 1 - He) + b * (v - 1 - et) + k * q;
+              const et = we * T - ie, Ee = z * Q + M * me + H * we, Be = I * ($ - 1 - He) + b * (v - 1 - et) + y * q;
               for (let Xe = 0; Xe < P; ++Xe) {
                 const Ke = g[Ee + K * Xe], je = C[Be + Xe];
                 le += Ke * je;
@@ -981,7 +981,7 @@ const eh = {
 function th(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s, filter: o } = t, { strides: r, pad: c, dilations: i } = n;
   j([s, o], "conv3d");
-  const l = xt(s.shape, o.shape, r, i, c), { filterDepth: u, filterHeight: p, filterWidth: d, dilationDepth: h, dilationHeight: f, dilationWidth: m, padInfo: x } = l, g = x.front, C = x.left, I = x.top, b = new $e(l.outShape, s.dtype), k = e.data.get(s.dataId).values, y = e.data.get(o.dataId).values, $ = b.values, v = ee(s.shape), w = ee(o.shape);
+  const l = xt(s.shape, o.shape, r, i, c), { filterDepth: u, filterHeight: p, filterWidth: d, dilationDepth: h, dilationHeight: f, dilationWidth: m, padInfo: x } = l, g = x.front, C = x.left, I = x.top, b = new $e(l.outShape, s.dtype), y = e.data.get(s.dataId).values, k = e.data.get(o.dataId).values, $ = b.values, v = ee(s.shape), w = ee(o.shape);
   for (let S = 0; S < l.batchSize; ++S) {
     const E = S * v[0], P = S * b.strides[0];
     for (let D = 0; D < l.outDepth; ++D) {
@@ -1007,9 +1007,9 @@ function th(a) {
                 const ne = M + Z * w[2], re = H + J * l.inChannels;
                 let fe = ne;
                 for (let ie = 0; ie < l.inChannels; ++ie) {
-                  const oe = k[re + ie];
+                  const oe = y[re + ie];
                   for (let de = 0; de < l.outChannels; ++de)
-                    $[Q + de] += oe * y[fe + de];
+                    $[Q + de] += oe * k[fe + de];
                   fe += l.outChannels;
                 }
               }
@@ -1029,13 +1029,13 @@ const sh = {
 function nh(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s, dy: o } = t, { strides: r, pad: c, filterShape: i } = n;
   j([s, o], "conv3dBackpropFilterV2");
-  const l = ee(s.shape), u = ee(o.shape), p = xt(s.shape, i, r, 1, c), d = p.strideDepth, h = p.strideHeight, f = p.strideWidth, m = p.filterDepth, x = p.filterHeight, g = p.filterWidth, C = new $e(p.filterShape, "float32"), I = C.values, [b, k, y, $] = C.strides, v = e.data.get(o.dataId).values, [w, S, E, P] = u, D = e.data.get(s.dataId).values, [F, R, T, A] = l, N = p.padInfo.front, O = p.padInfo.left, V = p.padInfo.top;
+  const l = ee(s.shape), u = ee(o.shape), p = xt(s.shape, i, r, 1, c), d = p.strideDepth, h = p.strideHeight, f = p.strideWidth, m = p.filterDepth, x = p.filterHeight, g = p.filterWidth, C = new $e(p.filterShape, "float32"), I = C.values, [b, y, k, $] = C.strides, v = e.data.get(o.dataId).values, [w, S, E, P] = u, D = e.data.get(s.dataId).values, [F, R, T, A] = l, N = p.padInfo.front, O = p.padInfo.left, V = p.padInfo.top;
   for (let L = 0; L < m; ++L) {
     const B = Math.max(0, Math.ceil((N - L) / d)), W = Math.min(p.outDepth, (p.inDepth + N - L) / d), z = L * b;
     for (let M = 0; M < x; ++M) {
-      const H = Math.max(0, Math.ceil((V - M) / h)), K = Math.min(p.outHeight, (p.inHeight + V - M) / h), Q = M * k + z;
+      const H = Math.max(0, Math.ceil((V - M) / h)), K = Math.min(p.outHeight, (p.inHeight + V - M) / h), Q = M * y + z;
       for (let q = 0; q < g; ++q) {
-        const Z = Math.max(0, Math.ceil((O - q) / f)), J = Math.min(p.outWidth, (p.inWidth + O - q) / f), ne = q * y + Q;
+        const Z = Math.max(0, Math.ceil((O - q) / f)), J = Math.min(p.outWidth, (p.inWidth + O - q) / f), ne = q * k + Q;
         for (let re = 0; re < p.inChannels; ++re) {
           const fe = re * $ + ne;
           for (let ie = 0; ie < p.outChannels; ++ie) {
@@ -1069,7 +1069,7 @@ const oh = {
 function ah(a) {
   const { inputs: t, backend: e, attrs: n } = a, { dy: s, filter: o } = t, { pad: r, strides: c, inputShape: i } = n;
   j([s], "conv3dBackpropInputV2");
-  const l = ee(s.shape), u = ee(o.shape), p = xt(i, o.shape, c, 1, r), d = new $e(p.inShape, "float32"), h = d.values, [f, m, x, g] = d.strides, C = e.data.get(s.dataId).values, [I, b, k, y] = l, $ = e.data.get(o.dataId).values, [v, w, S, E] = u, { batchSize: P, filterDepth: D, filterHeight: F, filterWidth: R, inChannels: T, inDepth: A, inHeight: N, inWidth: O, outChannels: V, outDepth: L, outHeight: B, outWidth: W, strideDepth: z, strideHeight: M, strideWidth: H } = p, K = D - 1 - p.padInfo.front, Q = F - 1 - p.padInfo.top, q = R - 1 - p.padInfo.left;
+  const l = ee(s.shape), u = ee(o.shape), p = xt(i, o.shape, c, 1, r), d = new $e(p.inShape, "float32"), h = d.values, [f, m, x, g] = d.strides, C = e.data.get(s.dataId).values, [I, b, y, k] = l, $ = e.data.get(o.dataId).values, [v, w, S, E] = u, { batchSize: P, filterDepth: D, filterHeight: F, filterWidth: R, inChannels: T, inDepth: A, inHeight: N, inWidth: O, outChannels: V, outDepth: L, outHeight: B, outWidth: W, strideDepth: z, strideHeight: M, strideWidth: H } = p, K = D - 1 - p.padInfo.front, Q = F - 1 - p.padInfo.top, q = R - 1 - p.padInfo.left;
   for (let Z = 0; Z < P; ++Z)
     for (let J = 0; J < T; ++J)
       for (let ne = 0; ne < A; ++ne) {
@@ -1083,8 +1083,8 @@ function ah(a) {
               const Xe = Be * z - re;
               for (let Ke = le; Ke < Me; ++Ke) {
                 const je = Ke * M - de;
-                for (let yt = we; yt < et; ++yt) {
-                  const ps = yt * H - He, hs = I * Z + b * Be + k * Ke + y * yt, Bi = v * (D - 1 - Xe) + w * (F - 1 - je) + S * (R - 1 - ps) + E * J;
+                for (let kt = we; kt < et; ++kt) {
+                  const ps = kt * H - He, hs = I * Z + b * Be + y * Ke + k * kt, Bi = v * (D - 1 - Xe) + w * (F - 1 - je) + S * (R - 1 - ps) + E * J;
                   for (let Bt = 0; Bt < V; ++Bt) {
                     const Gi = C[hs + Bt], zi = $[Bi + Bt];
                     Ee += Gi * zi;
@@ -1114,7 +1114,7 @@ const lh = ae(Vs, (a) => Math.cosh(a)), uh = {
   kernelFunc: lh
 };
 function dh(a) {
-  const { inputs: t, backend: e, attrs: n } = a, { image: s, boxes: o, boxInd: r } = t, { cropSize: c, method: i, extrapolationValue: l } = n, [u, p, d, h] = s.shape, f = o.shape[0], [m, x] = c, g = pe([f, m, x, h], "float32"), C = e.data.get(o.dataId).values, I = e.data.get(r.dataId).values, b = e.data.get(s.dataId).values, k = ee(s.shape), y = ee(g.shape);
+  const { inputs: t, backend: e, attrs: n } = a, { image: s, boxes: o, boxInd: r } = t, { cropSize: c, method: i, extrapolationValue: l } = n, [u, p, d, h] = s.shape, f = o.shape[0], [m, x] = c, g = pe([f, m, x, h], "float32"), C = e.data.get(o.dataId).values, I = e.data.get(r.dataId).values, b = e.data.get(s.dataId).values, y = ee(s.shape), k = ee(g.shape);
   for (let $ = 0; $ < f; $++) {
     const v = $ * 4, w = C[v], S = C[v + 1], E = C[v + 2], P = C[v + 3], D = I[$];
     if (D >= u)
@@ -1125,7 +1125,7 @@ function dh(a) {
       if (A < 0 || A > p - 1) {
         for (let N = 0; N < x; N++)
           for (let O = 0; O < h; O++) {
-            const V = O + N * y[2] + T * y[1] + $ * y[0];
+            const V = O + N * k[2] + T * k[1] + $ * k[0];
             g.values[V] = l;
           }
         continue;
@@ -1136,22 +1136,22 @@ function dh(a) {
           const B = x > 1 ? S * (d - 1) + L * R : 0.5 * (S + P) * (d - 1);
           if (B < 0 || B > d - 1) {
             for (let H = 0; H < h; H++) {
-              const K = H + L * y[2] + T * y[1] + $ * y[0];
+              const K = H + L * k[2] + T * k[1] + $ * k[0];
               g.values[K] = l;
             }
             continue;
           }
           const W = Math.floor(B), z = Math.ceil(B), M = B - W;
           for (let H = 0; H < h; H++) {
-            let K = H + W * k[2] + N * k[1] + D * k[0];
+            let K = H + W * y[2] + N * y[1] + D * y[0];
             const Q = b[K];
-            K = H + z * k[2] + N * k[1] + D * k[0];
+            K = H + z * y[2] + N * y[1] + D * y[0];
             const q = b[K];
-            K = H + W * k[2] + O * k[1] + D * k[0];
+            K = H + W * y[2] + O * y[1] + D * y[0];
             const Z = b[K];
-            K = H + z * k[2] + O * k[1] + D * k[0];
+            K = H + z * y[2] + O * y[1] + D * y[0];
             const J = b[K], ne = Q + (q - Q) * M, re = Z + (J - Z) * M;
-            K = H + L * y[2] + T * y[1] + $ * y[0], g.values[K] = ne + (re - ne) * V;
+            K = H + L * k[2] + T * k[1] + $ * k[0], g.values[K] = ne + (re - ne) * V;
           }
         }
       } else
@@ -1159,14 +1159,14 @@ function dh(a) {
           const O = x > 1 ? S * (d - 1) + N * R : 0.5 * (S + P) * (d - 1);
           if (O < 0 || O > d - 1) {
             for (let B = 0; B < h; B++) {
-              const W = B + N * y[2] + T * y[1] + $ * y[0];
+              const W = B + N * k[2] + T * k[1] + $ * k[0];
               g.values[W] = l;
             }
             continue;
           }
           const V = Math.round(O), L = Math.round(A);
           for (let B = 0; B < h; B++) {
-            const W = B + V * k[2] + L * k[1] + D * k[0], z = B + N * y[2] + T * y[1] + $ * y[0];
+            const W = B + V * y[2] + L * y[1] + D * y[0], z = B + N * k[2] + T * k[1] + $ * k[0];
             g.values[z] = b[W];
           }
         }
@@ -1267,10 +1267,10 @@ function bh(a) {
   for (let g = 0; g < c; ++g)
     for (let C = 0; C < p; ++C) {
       const I = Math.floor(C / o), b = C % o;
-      for (let k = 0; k < d; ++k) {
-        const y = Math.floor(k / o), $ = k % o, v = (b * o + $) * h;
+      for (let y = 0; y < d; ++y) {
+        const k = Math.floor(y / o), $ = y % o, v = (b * o + $) * h;
         for (let w = 0; w < h; ++w) {
-          const E = w + v + u * (y + l * (I + i * g));
+          const E = w + v + u * (k + l * (I + i * g));
           m[x++] = f[E];
         }
       }
@@ -1297,18 +1297,18 @@ function ii(a) {
     l,
     !0
     /* depthwise */
-  ), { filterHeight: f, filterWidth: m, dilationHeight: x, dilationWidth: g, padInfo: C } = h, I = C.left, b = C.top, k = h.outChannels / h.inChannels, y = new $e(h.outShape, s.dtype), $ = e.data.get(s.dataId).values, v = e.data.get(o.dataId).values, w = y.values;
+  ), { filterHeight: f, filterWidth: m, dilationHeight: x, dilationWidth: g, padInfo: C } = h, I = C.left, b = C.top, y = h.outChannels / h.inChannels, k = new $e(h.outShape, s.dtype), $ = e.data.get(s.dataId).values, v = e.data.get(o.dataId).values, w = k.values;
   for (let S = 0; S < h.batchSize; ++S) {
-    const E = S * u[0], P = S * y.strides[0];
+    const E = S * u[0], P = S * k.strides[0];
     for (let D = 0; D < h.outHeight; ++D) {
-      const F = P + D * y.strides[1], R = D * h.strideHeight - b;
+      const F = P + D * k.strides[1], R = D * h.strideHeight - b;
       for (let T = 0; T < f; ++T) {
         const A = R + T * x;
         if (A < 0 || A >= h.inHeight)
           continue;
         const N = T * p[0], O = E + A * u[1];
         for (let V = 0; V < h.outWidth; ++V) {
-          const L = F + V * y.strides[2], B = V * h.strideWidth - I;
+          const L = F + V * k.strides[2], B = V * h.strideWidth - I;
           for (let W = 0; W < m; ++W) {
             const z = B + W * g;
             if (z < 0 || z >= h.inWidth)
@@ -1317,23 +1317,23 @@ function ii(a) {
             let K = L, Q = M;
             for (let q = 0; q < h.inChannels; ++q) {
               const Z = $[H + q];
-              for (let J = 0; J < k; ++J)
+              for (let J = 0; J < y; ++J)
                 w[K + J] += Z * v[Q + J];
-              K += k, Q += k;
+              K += y, Q += y;
             }
           }
         }
       }
     }
   }
-  return e.makeTensorInfo(y.shape, y.dtype, y.values);
+  return e.makeTensorInfo(k.shape, k.dtype, k.values);
 }
-const kh = {
+const yh = {
   kernelName: Wo,
   backendName: "cpu",
   kernelFunc: ii
 };
-function yh(a) {
+function kh(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s, dy: o } = t, { strides: r, dilations: c, pad: i, dimRoundingMode: l, filterShape: u } = n;
   j([s, o], "depthwiseConv2dNativeBackpropFilter");
   const p = Se(
@@ -1345,7 +1345,7 @@ function yh(a) {
     l,
     !0
     /* depthwise */
-  ), { strideHeight: d, strideWidth: h, filterHeight: f, filterWidth: m } = p, x = new $e(p.filterShape, "float32"), g = p.padInfo.left, C = p.padInfo.top, I = p.outChannels / p.inChannels, b = e.data.get(s.dataId).values, k = new $e(s.shape, s.dtype, b), y = e.data.get(o.dataId).values, $ = new $e(o.shape, o.dtype, y);
+  ), { strideHeight: d, strideWidth: h, filterHeight: f, filterWidth: m } = p, x = new $e(p.filterShape, "float32"), g = p.padInfo.left, C = p.padInfo.top, I = p.outChannels / p.inChannels, b = e.data.get(s.dataId).values, y = new $e(s.shape, s.dtype, b), k = e.data.get(o.dataId).values, $ = new $e(o.shape, o.dtype, k);
   for (let v = 0; v < f; ++v) {
     const w = Math.max(0, Math.ceil((C - v) / d)), S = Math.min(p.outHeight, (p.inHeight + C - v) / d);
     for (let E = 0; E < m; ++E) {
@@ -1358,7 +1358,7 @@ function yh(a) {
             const V = v + O * d - C;
             for (let L = P; L < D; ++L) {
               const B = E + L * h - g;
-              A += k.get(N, V, B, R) * $.get(N, O, L, F);
+              A += y.get(N, V, B, R) * $.get(N, O, L, F);
             }
           }
         x.set(A, v, E, R, T);
@@ -1370,7 +1370,7 @@ function yh(a) {
 const $h = {
   kernelName: Mo,
   backendName: "cpu",
-  kernelFunc: yh
+  kernelFunc: kh
 };
 function vh(a) {
   const { inputs: t, backend: e, attrs: n } = a, { dy: s, filter: o } = t, { strides: r, dilations: c, pad: i, dimRoundingMode: l, inputShape: u } = n;
@@ -1384,7 +1384,7 @@ function vh(a) {
     l,
     !0
     /* depthwise */
-  ), f = new $e(h.inShape, "float32"), m = f.values, [x, g, C] = f.strides, I = e.data.get(s.dataId).values, [b, k, y] = p, $ = e.data.get(o.dataId).values, [v, w, S] = d, { batchSize: E, filterHeight: P, filterWidth: D, inChannels: F, inHeight: R, inWidth: T, outChannels: A, outHeight: N, outWidth: O, strideHeight: V, strideWidth: L } = h, B = P - 1 - h.padInfo.top, W = D - 1 - h.padInfo.left, z = A / F;
+  ), f = new $e(h.inShape, "float32"), m = f.values, [x, g, C] = f.strides, I = e.data.get(s.dataId).values, [b, y, k] = p, $ = e.data.get(o.dataId).values, [v, w, S] = d, { batchSize: E, filterHeight: P, filterWidth: D, inChannels: F, inHeight: R, inWidth: T, outChannels: A, outHeight: N, outWidth: O, strideHeight: V, strideWidth: L } = h, B = P - 1 - h.padInfo.top, W = D - 1 - h.padInfo.left, z = A / F;
   for (let M = 0; M < E; ++M)
     for (let H = 0; H < F; ++H)
       for (let K = 0; K < R; ++K) {
@@ -1395,7 +1395,7 @@ function vh(a) {
           for (let oe = q; oe < Z; ++oe) {
             const de = oe * V - Q;
             for (let le = re; le < fe; ++le) {
-              const Me = le * L - ne, me = b * M + k * oe + y * le, He = v * (P - 1 - de) + w * (D - 1 - Me) + S * H;
+              const Me = le * L - ne, me = b * M + y * oe + k * le, He = v * (P - 1 - de) + w * (D - 1 - Me) + S * H;
               for (let we = 0; we < z; ++we) {
                 const et = H * z + we, Ee = I[me + et], Be = $[He + we];
                 ie += Ee * Be;
@@ -1428,15 +1428,15 @@ const Rh = {
   kernelName: zo,
   backendName: "cpu",
   kernelFunc: ({ inputs: a, backend: t, attrs: e }) => {
-    const { x: n, filter: s } = a, { strides: o, pad: r, dilations: c } = e, i = t, l = i.data.get(n.dataId).values, u = n.shape.length, p = i.data.get(s.dataId).values, d = s.shape.length, { batchSize: h, inHeight: f, inWidth: m, inChannels: x, outHeight: g, outWidth: C, padInfo: I, strideHeight: b, strideWidth: k, filterHeight: y, filterWidth: $, dilationHeight: v, dilationWidth: w, outShape: S } = as(n.shape, s.shape, o, r, "NHWC", c), E = G(S), P = S.length, D = ns(n.dtype, E);
+    const { x: n, filter: s } = a, { strides: o, pad: r, dilations: c } = e, i = t, l = i.data.get(n.dataId).values, u = n.shape.length, p = i.data.get(s.dataId).values, d = s.shape.length, { batchSize: h, inHeight: f, inWidth: m, inChannels: x, outHeight: g, outWidth: C, padInfo: I, strideHeight: b, strideWidth: y, filterHeight: k, filterWidth: $, dilationHeight: v, dilationWidth: w, outShape: S } = as(n.shape, s.shape, o, r, "NHWC", c), E = G(S), P = S.length, D = ns(n.dtype, E);
     for (let R = 0; R < h; ++R)
       for (let T = 0; T < g; ++T) {
         const A = T * b - I.top;
         for (let N = 0; N < C; ++N) {
-          const O = N * k - I.left;
+          const O = N * y - I.left;
           for (let V = 0; V < x; ++V) {
             let L = Number.MIN_SAFE_INTEGER;
-            for (let W = 0; W < y; ++W) {
+            for (let W = 0; W < k; ++W) {
               const z = A + W * v;
               if (z >= 0 && z < f)
                 for (let M = 0; M < $; ++M) {
@@ -1456,11 +1456,11 @@ const Rh = {
   }
 };
 const Th = {
-  kernelName: kn,
+  kernelName: yn,
   backendName: "cpu",
   kernelFunc: ({ inputs: a, backend: t, attrs: e }) => {
-    const { x: n, filter: s, dy: o } = a, { strides: r, pad: c, dilations: i } = e, l = t, u = ut(n.shape, l.data.get(n.dataId).values), p = ut(s.shape, l.data.get(s.dataId).values), { batchSize: d, inHeight: h, inWidth: f, inChannels: m, outHeight: x, outWidth: g, padInfo: C, strideHeight: I, strideWidth: b, filterHeight: k, filterWidth: y, dilationHeight: $, dilationWidth: v, outShape: w } = as(n.shape, s.shape, r, c, "NHWC", i);
-    te(o.rank === w.length, () => `Error in ${kn}, dy must have the same rank as output ${w.length}, but got ${o.rank}`);
+    const { x: n, filter: s, dy: o } = a, { strides: r, pad: c, dilations: i } = e, l = t, u = ut(n.shape, l.data.get(n.dataId).values), p = ut(s.shape, l.data.get(s.dataId).values), { batchSize: d, inHeight: h, inWidth: f, inChannels: m, outHeight: x, outWidth: g, padInfo: C, strideHeight: I, strideWidth: b, filterHeight: y, filterWidth: k, dilationHeight: $, dilationWidth: v, outShape: w } = as(n.shape, s.shape, r, c, "NHWC", i);
+    te(o.rank === w.length, () => `Error in ${yn}, dy must have the same rank as output ${w.length}, but got ${o.rank}`);
     const S = ut(w, l.data.get(o.dataId).values), E = Uo(s.shape, s.dtype);
     for (let D = 0; D < d; ++D)
       for (let F = 0; F < x; ++F) {
@@ -1469,10 +1469,10 @@ const Th = {
           const A = T * b - C.left;
           for (let N = 0; N < m; ++N) {
             let O = Number.MIN_SAFE_INTEGER, V = 0, L = 0;
-            for (let B = 0; B < k; ++B) {
+            for (let B = 0; B < y; ++B) {
               const W = R + B * $;
               if (W >= 0 && W < h)
-                for (let z = 0; z < y; ++z) {
+                for (let z = 0; z < k; ++z) {
                   const M = A + z * v;
                   if (M >= 0 && M < f) {
                     const H = u[D][W][M][N] + p[B][z][N];
@@ -1488,11 +1488,11 @@ const Th = {
   }
 };
 const Eh = {
-  kernelName: yn,
+  kernelName: kn,
   backendName: "cpu",
   kernelFunc: ({ inputs: a, backend: t, attrs: e }) => {
-    const { x: n, filter: s, dy: o } = a, { strides: r, pad: c, dilations: i } = e, l = t, u = ut(n.shape, l.data.get(n.dataId).values), p = ut(s.shape, l.data.get(s.dataId).values), { batchSize: d, inHeight: h, inWidth: f, inChannels: m, outHeight: x, outWidth: g, padInfo: C, strideHeight: I, strideWidth: b, filterHeight: k, filterWidth: y, dilationHeight: $, dilationWidth: v, outShape: w } = as(n.shape, s.shape, r, c, "NHWC", i);
-    te(o.rank === w.length, () => `Error in ${yn}, dy must have the same rank as output ${w.length}, but got ${o.rank}`);
+    const { x: n, filter: s, dy: o } = a, { strides: r, pad: c, dilations: i } = e, l = t, u = ut(n.shape, l.data.get(n.dataId).values), p = ut(s.shape, l.data.get(s.dataId).values), { batchSize: d, inHeight: h, inWidth: f, inChannels: m, outHeight: x, outWidth: g, padInfo: C, strideHeight: I, strideWidth: b, filterHeight: y, filterWidth: k, dilationHeight: $, dilationWidth: v, outShape: w } = as(n.shape, s.shape, r, c, "NHWC", i);
+    te(o.rank === w.length, () => `Error in ${kn}, dy must have the same rank as output ${w.length}, but got ${o.rank}`);
     const S = ut(w, l.data.get(o.dataId).values), E = Uo(n.shape, n.dtype);
     for (let D = 0; D < d; ++D)
       for (let F = 0; F < x; ++F) {
@@ -1501,10 +1501,10 @@ const Eh = {
           const A = T * b - C.left;
           for (let N = 0; N < m; ++N) {
             let O = Number.MIN_SAFE_INTEGER, V = R < 0 ? 0 : R, L = A < 0 ? 0 : A;
-            for (let B = 0; B < k; ++B) {
+            for (let B = 0; B < y; ++B) {
               const W = R + B * $;
               if (W >= 0 && W < h)
-                for (let z = 0; z < y; ++z) {
+                for (let z = 0; z < k; ++z) {
                   const M = A + z * v;
                   if (M >= 0 && M < f) {
                     const H = u[D][W][M][N] + p[B][z][N];
@@ -1529,17 +1529,17 @@ function Dh(a) {
   const [d, h] = s.shape.slice(0, 2), f = s.shape.length === 2 ? 1 : s.shape[2], m = e.data.get(s.dataId).values, x = s.dtype === "float32" ? 255 : 1, g = new Uint8ClampedArray(h * d * 4);
   for (let I = 0; I < d * h; ++I) {
     const b = [0, 0, 0, 255 * l];
-    for (let y = 0; y < f; y++) {
-      const $ = m[I * f + y];
+    for (let k = 0; k < f; k++) {
+      const $ = m[I * f + k];
       if (s.dtype === "float32") {
         if ($ < 0 || $ > 1)
           throw new Error(`Tensor values for a float32 Tensor must be in the range [0 - 1] but encountered ${$}.`);
       } else if (s.dtype === "int32" && ($ < 0 || $ > 255))
         throw new Error(`Tensor values for a int32 Tensor must be in the range [0 - 255] but encountered ${$}.`);
-      f === 1 ? (b[0] = $ * x, b[1] = $ * x, b[2] = $ * x) : b[y] = $ * x;
+      f === 1 ? (b[0] = $ * x, b[1] = $ * x, b[2] = $ * x) : b[k] = $ * x;
     }
-    const k = I * 4;
-    g[k + 0] = Math.round(b[0]), g[k + 1] = Math.round(b[1]), g[k + 2] = Math.round(b[2]), g[k + 3] = Math.round(b[3]);
+    const y = I * 4;
+    g[y + 0] = Math.round(b[0]), g[y + 1] = Math.round(b[1]), g[y + 2] = Math.round(b[2]), g[y + 3] = Math.round(b[3]);
   }
   o.width = h, o.height = d;
   const C = new ImageData(g, h, d);
@@ -1557,20 +1557,20 @@ function Lt(a) {
   s.dtype === "bool" ? c = cn({ inputs: { x: s }, backend: e, attrs: { dtype: "int32" } }) : c = at({ inputs: { x: s }, backend: e });
   const i = c.shape.length, l = ue(o, c.shape), u = ge(l, i);
   let p = l, d = c;
-  u != null && (d = Re({ inputs: { x: c }, backend: e, attrs: { perm: u } }), p = xe(p.length, i)), ye("sum", p, d.shape.length);
+  u != null && (d = Re({ inputs: { x: c }, backend: e, attrs: { perm: u } }), p = xe(p.length, i)), ke("sum", p, d.shape.length);
   const [h, f] = ve(d.shape, p), m = Qe(d.dtype, "int32");
   let x = Hc(e, h, m);
   const g = G(f), C = e.data.get(x.dataId).values, I = e.data.get(d.dataId).values;
   for (let b = 0; b < C.length; ++b) {
-    const k = b * g;
-    let y = 0;
+    const y = b * g;
+    let k = 0;
     for (let $ = 0; $ < g; ++$)
-      y += I[k + $];
-    C[b] = y;
+      k += I[y + $];
+    C[b] = k;
   }
   if (r) {
-    const b = Te(x.shape, l), k = x;
-    x = ce({ inputs: { x }, backend: e, attrs: { shape: b } }), e.disposeIntermediateTensorInfo(k);
+    const b = Te(x.shape, l), y = x;
+    x = ce({ inputs: { x }, backend: e, attrs: { shape: b } }), e.disposeIntermediateTensorInfo(y);
   }
   return e.disposeIntermediateTensorInfo(c), u != null && e.disposeIntermediateTensorInfo(d), x;
 }
@@ -1591,8 +1591,8 @@ function Oh(a) {
       let I;
       br(g) ? I = o[x] : (I = Re({ inputs: { x: o[x] }, backend: e, attrs: { perm: g } }), f.push(I));
       const b = I.shape.slice();
-      for (let k = 0; k < C.length; ++k)
-        b.splice(C[k], 0, 1);
+      for (let y = 0; y < C.length; ++y)
+        b.splice(C[y], 0, 1);
       nt(I.shape, b) || (I = ce({ inputs: { x: I }, backend: e, attrs: { shape: b } }), f.push(I)), d === null ? d = I : (d = ln({ inputs: { a: I, b: d }, backend: e }), f.push(d));
     }
     m < p - 1 && (l[m] >= 0 && (d = Lt({
@@ -1628,7 +1628,7 @@ const Lh = {
   backendName: "cpu",
   kernelFunc: _h
 };
-const Vh = Sr, Wh = vr, Mh = $r, Bh = yr, Gh = kr, zh = Ir, Uh = ae(Ms, (a) => {
+const Vh = Sr, Wh = vr, Mh = $r, Bh = kr, Gh = yr, zh = Ir, Uh = ae(Ms, (a) => {
   const t = Math.sign(a), e = Math.abs(a), n = 1 / (1 + Vh * e);
   return t * (1 - ((((zh * n + Gh) * n + Bh) * n + Mh) * n + Wh) * n * Math.exp(-e * e));
 }), Hh = {
@@ -1662,9 +1662,9 @@ function ci(a, t, e) {
       inputs: { x: i },
       backend: e,
       attrs: { begin: [x, 0], size: [1, o] }
-    }), I = Ae({ inputs: { real: g, imag: C }, backend: e }), { real: b, imag: k } = jh(I, t, e), y = pt(b, k);
+    }), I = Ae({ inputs: { real: g, imag: C }, backend: e }), { real: b, imag: y } = jh(I, t, e), k = pt(b, y);
     for (let $ = 0; $ < o; $++) {
-      const v = pr(y, $);
+      const v = pr(k, $);
       p[x * o + $] = v.real, d[x * o + $] = v.imag;
     }
     e.disposeIntermediateTensorInfo(g), e.disposeIntermediateTensorInfo(C), e.disposeIntermediateTensorInfo(I);
@@ -1675,7 +1675,7 @@ function ci(a, t, e) {
 function jh(a, t, e) {
   const n = G(a.shape), s = e.data.get(a.dataId), o = e.data.get(s.complexTensorInfos.real.dataId).values, r = e.data.get(s.complexTensorInfos.imag.dataId).values;
   if (qh(n)) {
-    const c = ks(o, r, n, t, e), i = [a.shape[0], a.shape[1]];
+    const c = ys(o, r, n, t, e), i = [a.shape[0], a.shape[1]];
     if (t) {
       const l = e.makeTensorInfo(i, "float32", c.real), u = e.makeTensorInfo(i, "float32", c.imag), p = e.makeTensorInfo([], "float32", mt(n, "float32")), d = at({ inputs: { x: p }, backend: e }), h = Is.kernelFunc({ inputs: { a: l, b: p }, backend: e }), f = Is.kernelFunc({ inputs: { a: u, b: d }, backend: e }), m = e.data.get(h.dataId).values, x = e.data.get(f.dataId).values;
       return e.disposeIntermediateTensorInfo(l), e.disposeIntermediateTensorInfo(u), e.disposeIntermediateTensorInfo(p), e.disposeIntermediateTensorInfo(d), e.disposeIntermediateTensorInfo(h), e.disposeIntermediateTensorInfo(f), { real: m, imag: x };
@@ -1689,13 +1689,13 @@ function jh(a, t, e) {
 function qh(a) {
   return (a & a - 1) === 0;
 }
-function ks(a, t, e, n, s) {
+function ys(a, t, e, n, s) {
   if (e === 1)
     return { real: a, imag: t };
-  const o = pt(a, t), r = e / 2, c = Hl(o), i = c.real, l = c.imag, u = [i.length], p = s.makeTensorInfo(u, "float32", i), d = s.makeTensorInfo(u, "float32", l), h = Ae({ inputs: { real: p, imag: d }, backend: s }), f = Xl(o), m = f.real, x = f.imag, g = [m.length], C = s.makeTensorInfo(g, "float32", m), I = s.makeTensorInfo(g, "float32", x), b = Ae({ inputs: { real: C, imag: I }, backend: s }), k = ks(i, l, r, n, s), y = k.real, $ = k.imag, v = [y.length], w = s.makeTensorInfo(v, "float32", y), S = s.makeTensorInfo(v, "float32", $), E = Ae({
+  const o = pt(a, t), r = e / 2, c = Hl(o), i = c.real, l = c.imag, u = [i.length], p = s.makeTensorInfo(u, "float32", i), d = s.makeTensorInfo(u, "float32", l), h = Ae({ inputs: { real: p, imag: d }, backend: s }), f = Xl(o), m = f.real, x = f.imag, g = [m.length], C = s.makeTensorInfo(g, "float32", m), I = s.makeTensorInfo(g, "float32", x), b = Ae({ inputs: { real: C, imag: I }, backend: s }), y = ys(i, l, r, n, s), k = y.real, $ = y.imag, v = [k.length], w = s.makeTensorInfo(v, "float32", k), S = s.makeTensorInfo(v, "float32", $), E = Ae({
     inputs: { real: w, imag: S },
     backend: s
-  }), P = ks(m, x, r, n, s), D = P.real, F = P.imag, R = [D.length], T = s.makeTensorInfo(R, "float32", D), A = s.makeTensorInfo(R, "float32", F), N = Ae({ inputs: { real: T, imag: A }, backend: s }), O = Kl(e, n), V = [O.real.length], L = s.makeTensorInfo(V, "float32", O.real), B = s.makeTensorInfo(V, "float32", O.imag), W = Ae({ inputs: { real: L, imag: B }, backend: s }), z = ln({ inputs: { a: W, b: N }, backend: s }), M = wt({
+  }), P = ys(m, x, r, n, s), D = P.real, F = P.imag, R = [D.length], T = s.makeTensorInfo(R, "float32", D), A = s.makeTensorInfo(R, "float32", F), N = Ae({ inputs: { real: T, imag: A }, backend: s }), O = Kl(e, n), V = [O.real.length], L = s.makeTensorInfo(V, "float32", O.real), B = s.makeTensorInfo(V, "float32", O.imag), W = Ae({ inputs: { real: L, imag: B }, backend: s }), z = ln({ inputs: { a: W, b: N }, backend: s }), M = wt({
     inputs: { a: E, b: z },
     backend: s
   }), H = ur({
@@ -1762,12 +1762,12 @@ const tf = {
           const g = x * l;
           for (let C = 0; C < l; C++) {
             const I = Math.round(i - x - 1), b = h + m + g + C;
-            let k = u[b];
+            let y = u[b];
             if (I >= 0 && I < i) {
-              const y = I * l, $ = h + m + y + C;
-              k = u[$];
+              const k = I * l, $ = h + m + k + C;
+              y = u[$];
             }
-            o[b] = k;
+            o[b] = y;
           }
         }
       }
@@ -1850,8 +1850,8 @@ function lf(a) {
   j([s, o], "gatherV2");
   const i = ue(r, s.shape)[0], l = e.data.get(o.dataId).values, u = s.shape[i];
   for (let b = 0; b < l.length; ++b) {
-    const k = l[b];
-    te(k <= u - 1 && k >= 0, () => `GatherV2: the index value ${k} is not in [0, ${u - 1}]`);
+    const y = l[b];
+    te(y <= u - 1 && y >= 0, () => `GatherV2: the index value ${y} is not in [0, ${u - 1}]`);
   }
   let p = c;
   c == null && (p = 0);
@@ -1920,10 +1920,10 @@ const If = {
   backendName: "cpu",
   kernelFunc: bf
 };
-const kf = ae(Us, (a) => Math.log1p(a)), yf = {
+const yf = ae(Us, (a) => Math.log1p(a)), kf = {
   kernelName: Us,
   backendName: "cpu",
-  kernelFunc: kf
+  kernelFunc: yf
 };
 const $f = ot((a, t) => a && t), vf = gt(Hs, $f, null, "bool"), Sf = {
   kernelName: Hs,
@@ -1971,14 +1971,14 @@ function Pf(a) {
   j(r, "LRNGrad");
   const p = G(r.shape), d = r.shape[3], h = e.data.get(r.dataId).values, f = e.data.get(s.dataId).values, m = e.data.get(o.dataId).values, x = new Float32Array(p), g = p;
   for (let C = 0; C < g; C++) {
-    const I = C % d, b = C - I + Math.max(0, I - c), k = C - I + Math.min(d, I + c + 1);
-    let y = 0;
-    for (let $ = b; $ < k; $++)
-      y += Math.pow(f[$], 2);
-    y = l * y + i;
-    for (let $ = b; $ < k; $++) {
-      let v = -2 * l * u * f[$] * m[C] / y;
-      C === $ && (v += Math.pow(y, -u)), v *= h[C], x[$] += v;
+    const I = C % d, b = C - I + Math.max(0, I - c), y = C - I + Math.min(d, I + c + 1);
+    let k = 0;
+    for (let $ = b; $ < y; $++)
+      k += Math.pow(f[$], 2);
+    k = l * k + i;
+    for (let $ = b; $ < y; $++) {
+      let v = -2 * l * u * f[$] * m[C] / k;
+      C === $ && (v += Math.pow(k, -u)), v *= h[C], x[$] += v;
     }
   }
   return e.makeTensorInfo(r.shape, s.dtype, x);
@@ -1997,11 +1997,11 @@ function li(a) {
   let h = c.data.get(s.dataId).values;
   if (d != null) {
     const b = new Array(l);
-    for (let k = 0; k < b.length; k++)
-      b[k] = i[d[k]];
+    for (let y = 0; y < b.length; y++)
+      b[y] = i[d[y]];
     h = qc(h, i, s.dtype, d, b), p = xe(p.length, l), i = b;
   }
-  j(s, "max"), ye("max", p, l);
+  j(s, "max"), ke("max", p, l);
   const [f, m] = ve(i, p), x = G(m), g = Yc(h, x, f, s.dtype), C = c.write(g, f, s.dtype);
   let I = f;
   return r && (I = Te(f, u)), { dataId: C, shape: I, dtype: s.dtype };
@@ -2045,13 +2045,13 @@ const Wf = {
 function Mf(a) {
   const { inputs: t, backend: e, attrs: n } = a, { dy: s, input: o } = t, { filterSize: r, strides: c, pad: i, dimRoundingMode: l } = n;
   j([s, o], "maxPool3DGrad");
-  const u = Je(o.shape, r, c, 1, i, l), p = e.bufferSync(o), d = Np(p, u), h = u.strideDepth, f = u.strideHeight, m = u.strideWidth, x = u.dilationDepth, g = u.dilationHeight, C = u.dilationWidth, I = u.effectiveFilterDepth, b = u.effectiveFilterHeight, k = u.effectiveFilterWidth, y = I - 1 - u.padInfo.front, $ = k - 1 - u.padInfo.left, v = b - 1 - u.padInfo.top, w = pe(o.shape, "float32"), S = e.bufferSync(s);
+  const u = Je(o.shape, r, c, 1, i, l), p = e.bufferSync(o), d = Np(p, u), h = u.strideDepth, f = u.strideHeight, m = u.strideWidth, x = u.dilationDepth, g = u.dilationHeight, C = u.dilationWidth, I = u.effectiveFilterDepth, b = u.effectiveFilterHeight, y = u.effectiveFilterWidth, k = I - 1 - u.padInfo.front, $ = y - 1 - u.padInfo.left, v = b - 1 - u.padInfo.top, w = pe(o.shape, "float32"), S = e.bufferSync(s);
   for (let E = 0; E < u.batchSize; ++E)
     for (let P = 0; P < u.inChannels; ++P)
       for (let D = 0; D < u.inDepth; ++D)
         for (let F = 0; F < u.inHeight; ++F)
           for (let R = 0; R < u.inWidth; ++R) {
-            const T = D - y, A = F - v, N = R - $;
+            const T = D - k, A = F - v, N = R - $;
             let O = 0;
             for (let V = 0; V < I; V += x) {
               const L = (T + V) / h;
@@ -2059,11 +2059,11 @@ function Mf(a) {
                 for (let B = 0; B < b; B += g) {
                   const W = (A + B) / f;
                   if (!(W < 0 || W >= u.outHeight || Math.floor(W) !== W))
-                    for (let z = 0; z < k; z += C) {
+                    for (let z = 0; z < y; z += C) {
                       const M = (N + z) / m;
                       if (M < 0 || M >= u.outWidth || Math.floor(M) !== M)
                         continue;
-                      const H = I * b * k - 1 - d.get(E, L, W, M, P), K = V * b * k + B * k + z, Q = H === K ? 1 : 0;
+                      const H = I * b * y - 1 - d.get(E, L, W, M, P), K = V * b * y + B * y + z, Q = H === K ? 1 : 0;
                       if (Q === 0)
                         continue;
                       const q = S.get(E, L, W, M, P);
@@ -2083,12 +2083,12 @@ const Bf = {
 function Gf(a) {
   const { inputs: t, backend: e, attrs: n } = a, { dy: s, input: o, output: r } = t, c = o;
   j([o, r], "maxPoolGrad");
-  const { filterSize: i, strides: l, pad: u, dimRoundingMode: p } = n, d = Le(c.shape, i, l, 1, u, p), h = e.data.get(c.dataId).values, f = pe(d.outShape, c.dtype, oi(h, c.shape, c.dtype, d).values), m = d.strideHeight, x = d.strideWidth, g = d.dilationHeight, C = d.dilationWidth, I = d.effectiveFilterHeight, b = d.effectiveFilterWidth, k = b - 1 - d.padInfo.left, y = I - 1 - d.padInfo.top, $ = pe(c.shape, "float32"), v = e.data.get(s.dataId).values, w = pe(s.shape, "float32", v);
+  const { filterSize: i, strides: l, pad: u, dimRoundingMode: p } = n, d = Le(c.shape, i, l, 1, u, p), h = e.data.get(c.dataId).values, f = pe(d.outShape, c.dtype, oi(h, c.shape, c.dtype, d).values), m = d.strideHeight, x = d.strideWidth, g = d.dilationHeight, C = d.dilationWidth, I = d.effectiveFilterHeight, b = d.effectiveFilterWidth, y = b - 1 - d.padInfo.left, k = I - 1 - d.padInfo.top, $ = pe(c.shape, "float32"), v = e.data.get(s.dataId).values, w = pe(s.shape, "float32", v);
   for (let S = 0; S < d.batchSize; ++S)
     for (let E = 0; E < d.inChannels; ++E)
       for (let P = 0; P < d.inHeight; ++P)
         for (let D = 0; D < d.inWidth; ++D) {
-          const F = P - y, R = D - k;
+          const F = P - k, R = D - y;
           let T = 0;
           for (let A = 0; A < I; A += g) {
             const N = (F + A) / m;
@@ -2152,14 +2152,14 @@ function jf(a) {
   let i = c;
   const l = ge(i, s.shape.length);
   let u = s;
-  l != null && (u = Re({ inputs: { x: s }, backend: e, attrs: { perm: l } }), i = xe(i.length, s.shape.length)), ye("min", i, u.shape.length);
+  l != null && (u = Re({ inputs: { x: s }, backend: e, attrs: { perm: l } }), i = xe(i.length, s.shape.length)), ke("min", i, u.shape.length);
   const [p, d] = ve(u.shape, i), h = G(d), f = Ye(G(p), u.dtype), m = e.data.get(u.dataId).values;
   for (let g = 0; g < f.length; ++g) {
     const C = g * h;
     let I = m[C];
     for (let b = 0; b < h; ++b) {
-      const k = m[C + b];
-      (Number.isNaN(k) || k < I) && (I = k);
+      const y = m[C + b];
+      (Number.isNaN(y) || y < I) && (I = y);
     }
     f[g] = I;
   }
@@ -2185,11 +2185,11 @@ function Yf(a) {
   ), i = o.map((I) => I[0]), l = o.map((I, b) => I[0] + s.shape[b]), u = r === "reflect" ? 0 : 1, p = e.data.get(s.dataId).values, d = s.shape.length, h = ee(s.shape), f = G(c), m = c.length, x = ee(c), g = _e(s.dtype, f);
   for (let I = 0; I < f; I++) {
     let b = ma(I, m, x);
-    for (let y = 0; y < m; y++)
-      b[y] < i[y] ? b[y] = i[y] * 2 - b[y] - u : b[y] >= l[y] && (b[y] = (l[y] - 1) * 2 - b[y] + u);
-    b = b.map((y, $) => y - i[$]);
-    const k = St(b, d, h);
-    g[I] = p[k];
+    for (let k = 0; k < m; k++)
+      b[k] < i[k] ? b[k] = i[k] * 2 - b[k] - u : b[k] >= l[k] && (b[k] = (l[k] - 1) * 2 - b[k] + u);
+    b = b.map((k, $) => k - i[$]);
+    const y = St(b, d, h);
+    g[I] = p[y];
   }
   return { dataId: e.write(g, c, s.dtype), shape: c, dtype: s.dtype };
 }
@@ -2236,9 +2236,9 @@ function sm(a) {
     for (let I = 0; I < o; ++I) {
       const b = g();
       h[C + I] = x.length;
-      for (let k = 0; k < x.length; k++)
-        if (b < x[k]) {
-          h[C + I] = k;
+      for (let y = 0; y < x.length; y++)
+        if (b < x[y]) {
+          h[C + I] = y;
           break;
         }
     }
@@ -2318,7 +2318,7 @@ function Jt(a) {
     return xn({ backend: e, attrs: { shape: n.shape, value: 0, dtype: n.dtype } });
 }
 const mm = {
-  kernelName: ka,
+  kernelName: ya,
   backendName: "cpu",
   kernelFunc: Jt
 };
@@ -2333,7 +2333,7 @@ function di(a) {
     return xn({ backend: e, attrs: { shape: n.shape, value: 1, dtype: n.dtype } });
 }
 const gm = {
-  kernelName: ya,
+  kernelName: ka,
   backendName: "cpu",
   kernelFunc: di
 };
@@ -2365,8 +2365,8 @@ function Cm(a) {
   ), i = o.map((C) => C[0]), l = e.data.get(s.dataId).values, u = G(s.shape), p = s.shape.length, d = ee(s.shape), h = G(c), f = c.length, m = ee(c), x = _e(s.dtype, h);
   r !== 0 && x.fill(r);
   for (let C = 0; C < u; C++) {
-    const b = ma(C, p, d).map((y, $) => y + i[$]), k = St(b, f, m);
-    x[k] = l[C];
+    const b = ma(C, p, d).map((k, $) => k + i[$]), y = St(b, f, m);
+    x[y] = l[C];
   }
   return { dataId: e.write(x, c, s.dtype), shape: c, dtype: s.dtype };
 }
@@ -2375,19 +2375,19 @@ const hi = {
   backendName: "cpu",
   kernelFunc: Cm
 };
-const bm = ot((a, t) => Math.pow(a, t)), Im = gt(qs, bm), km = {
+const bm = ot((a, t) => Math.pow(a, t)), Im = gt(qs, bm), ym = {
   kernelName: qs,
   backendName: "cpu",
   kernelFunc: Im
 };
-function ym(a) {
+function km(a) {
   const { inputs: t, backend: e, attrs: n } = a, { paramsNestedSplits: s, paramsDenseValues: o, indices: r } = t, { outputRaggedRank: c } = n, i = s.map((g) => e.data.get(g.dataId).values), l = s.map((g) => g.shape), u = e.data.get(o.dataId).values, p = e.data.get(r.dataId).values, [d, h, f] = Zc(i, l, u, o.shape, o.dtype, p, r.shape), m = d.map((g) => e.makeTensorInfo([g.length], "int32", g)), x = e.makeTensorInfo(f, o.dtype, h);
   return m.concat([x]);
 }
 const $m = {
   kernelName: wa,
   backendName: "cpu",
-  kernelFunc: ym
+  kernelFunc: km
 };
 function vm(a) {
   const { inputs: t, backend: e } = a, { starts: n, limits: s, deltas: o } = t, r = e.data.get(n.dataId).values, c = e.data.get(s.dataId).values, i = e.data.get(o.dataId).values, [l, u] = Jc(r, n.shape, n.dtype, c, s.shape, i, o.shape), p = e.makeTensorInfo([l.length], "int32", l), d = e.makeTensorInfo([u.length], n.dtype, u);
@@ -2432,15 +2432,15 @@ function Fm(a) {
     o && u > 1 ? u - 1 : u
   ];
   let I = 0;
-  const b = g[0] / C[0], k = g[1] / C[1];
-  for (let y = 0; y < p; y++)
+  const b = g[0] / C[0], y = g[1] / C[1];
+  for (let k = 0; k < p; k++)
     for (let $ = 0; $ < l; $++) {
       let v;
       r ? v = b * ($ + 0.5) - 0.5 : v = b * $;
-      const w = Math.max(0, Math.floor(v)), S = v - w, E = Math.min(d - 1, Math.ceil(v)), P = y * i[0] + w * i[1], D = y * i[0] + E * i[1];
+      const w = Math.max(0, Math.floor(v)), S = v - w, E = Math.min(d - 1, Math.ceil(v)), P = k * i[0] + w * i[1], D = k * i[0] + E * i[1];
       for (let F = 0; F < u; F++) {
         let R;
-        r ? R = k * (F + 0.5) - 0.5 : R = k * F;
+        r ? R = y * (F + 0.5) - 0.5 : R = y * F;
         const T = Math.max(0, Math.floor(R)), A = R - T, N = Math.min(h - 1, Math.ceil(R)), O = P + T * i[2], V = D + T * i[2], L = P + N * i[2], B = D + N * i[2];
         for (let W = 0; W < f; W++) {
           const z = m[O + W], M = m[V + W], H = m[L + W], K = m[B + W], Q = z + (H - z) * A, q = M + (K - M) * A, Z = Q + (q - Q) * S;
@@ -2466,10 +2466,10 @@ function Om(a) {
     r && h > 1 ? h - 1 : h
   ], g = m[0] / x[0], C = m[1] / x[1], I = e.data.get(o.dataId).values;
   let b = 0;
-  for (let k = 0; k < i; k++) {
-    const y = k * c[0];
+  for (let y = 0; y < i; y++) {
+    const k = y * c[0];
     for (let $ = 0; $ < d; $++) {
-      const v = $ * g, w = Math.floor(v), S = Math.min(Math.ceil(v), l - 1), E = y + w * c[1], P = y + S * c[1], D = v - w, F = 1 - D;
+      const v = $ * g, w = Math.floor(v), S = Math.min(Math.ceil(v), l - 1), E = k + w * c[1], P = k + S * c[1], D = v - w, F = 1 - D;
       for (let R = 0; R < h; R++) {
         const T = R * C, A = Math.floor(T), N = Math.min(Math.ceil(T), u - 1), O = T - A, V = 1 - O, L = E + A * c[2], B = E + N * c[2], W = P + A * c[2], z = P + N * c[2], M = F * V, H = F * O, K = D * V, Q = D * O;
         for (let q = 0; q < p; q++) {
@@ -2496,9 +2496,9 @@ function _m(a) {
     o && l > 1 ? l - 1 : l,
     o && u > 1 ? u - 1 : u
   ], I = g[0] / C[0], b = g[1] / C[1];
-  let k = 0;
-  for (let y = 0; y < p; y++) {
-    const $ = y * i[0];
+  let y = 0;
+  for (let k = 0; k < p; k++) {
+    const $ = k * i[0];
     for (let v = 0; v < l; v++) {
       const w = r ? I * (v + 0.5) : I * v;
       let S = Math.min(d - 1, o ? Math.round(w) : Math.floor(w));
@@ -2511,7 +2511,7 @@ function _m(a) {
         const R = E + F * i[2];
         for (let T = 0; T < f; T++) {
           const A = m[R + T];
-          x[k++] = A;
+          x[y++] = A;
         }
       }
     }
@@ -2532,13 +2532,13 @@ function Vm(a) {
   ], C = [
     r && h > 1 ? h - 1 : h,
     r && f > 1 ? f - 1 : f
-  ], I = g[0] / C[0], b = g[1] / C[1], k = 1 / I, y = 1 / b, $ = Math.ceil(k) * 2 + 2, v = Math.ceil(y) * 2 + 2;
+  ], I = g[0] / C[0], b = g[1] / C[1], y = 1 / I, k = 1 / b, $ = Math.ceil(y) * 2 + 2, v = Math.ceil(k) * 2 + 2;
   for (let w = 0; w < l; w++) {
     const S = w * c[0];
     for (let E = 0; E < u; E++) {
-      const P = S + E * c[1], D = Math.floor(E * k), F = Math.floor(D - $ / 2);
+      const P = S + E * c[1], D = Math.floor(E * y), F = Math.floor(D - $ / 2);
       for (let R = 0; R < p; R++) {
-        const T = P + R * c[2], A = Math.floor(R * y), N = Math.floor(A - v / 2);
+        const T = P + R * c[2], A = Math.floor(R * k), N = Math.floor(A - v / 2);
         for (let O = 0; O < d; O++) {
           let V = 0;
           for (let L = 0; L < $; L++) {
@@ -2591,21 +2591,21 @@ const Gm = {
   kernelFunc: ({ inputs: a, attrs: t, backend: e }) => {
     const { image: n } = a, { radians: s, fillValue: o, center: r } = t, c = e, i = _e(n.dtype, G(n.shape)), [l, u, p, d] = n.shape, [h, f] = Rr(r, u, p), m = 255, x = Math.sin(s), g = Math.cos(s), C = c.data.get(n.dataId).values;
     for (let b = 0; b < l; b++) {
-      const k = b * p * u * d;
-      for (let y = 0; y < u; y++) {
-        const $ = y * (p * d);
+      const y = b * p * u * d;
+      for (let k = 0; k < u; k++) {
+        const $ = k * (p * d);
         for (let v = 0; v < p; v++) {
           const w = v * d;
           for (let S = 0; S < d; S++) {
-            const E = [l, y, v, S], P = E[2], D = E[1];
+            const E = [l, k, v, S], P = E[2], D = E[1];
             let F = (P - h) * g - (D - f) * x, R = (P - h) * x + (D - f) * g;
             F = Math.round(F + h), R = Math.round(R + f);
             let T = o;
             if (typeof o != "number" && (S === 3 ? T = m : T = o[S]), F >= 0 && F < p && R >= 0 && R < u) {
-              const N = R * (p * d), O = F * d, V = k + N + O + S;
+              const N = R * (p * d), O = F * d, V = y + N + O + S;
               T = C[V];
             }
-            const A = k + $ + w + S;
+            const A = y + $ + w + S;
             i[A] = T;
           }
         }
@@ -2711,14 +2711,14 @@ function hg(a) {
   j([s], "spaceToBatchND");
   const c = G(o), i = [[0, 0]];
   i.push(...r);
-  for (let y = 1 + o.length; y < s.shape.length; ++y)
+  for (let k = 1 + o.length; k < s.shape.length; ++k)
     i.push([0, 0]);
   const l = hi.kernelFunc({
     inputs: { x: s },
     backend: e,
     attrs: { paddings: i, constantValue: 0 }
-  }), u = rs(l.shape, o, c, !1), p = is(u.length, o.length, !1), d = cs(l.shape, o, c, !1), m = ce({ inputs: { x: l }, backend: e, attrs: { shape: u } }), C = Re({ inputs: { x: m }, backend: e, attrs: { perm: p } }), k = ce({ inputs: { x: C }, backend: e, attrs: { shape: d } });
-  return e.disposeIntermediateTensorInfo(l), e.disposeIntermediateTensorInfo(m), e.disposeIntermediateTensorInfo(C), k;
+  }), u = rs(l.shape, o, c, !1), p = is(u.length, o.length, !1), d = cs(l.shape, o, c, !1), m = ce({ inputs: { x: l }, backend: e, attrs: { shape: u } }), C = Re({ inputs: { x: m }, backend: e, attrs: { perm: p } }), y = ce({ inputs: { x: C }, backend: e, attrs: { shape: d } });
+  return e.disposeIntermediateTensorInfo(l), e.disposeIntermediateTensorInfo(m), e.disposeIntermediateTensorInfo(C), y;
 }
 const fg = {
   kernelName: Wa,
@@ -2793,7 +2793,7 @@ const Ig = {
   backendName: "cpu",
   kernelFunc: bg
 };
-function kg(a) {
+function yg(a) {
   const { inputs: t, backend: e } = a, { data: n, indices: s, segmentIds: o } = t;
   if (n.shape.length < 1)
     throw new Error("Data should be at least 1 dimensional but received scalar");
@@ -2808,10 +2808,10 @@ function kg(a) {
   const r = e.data.get(n.dataId).values, c = e.data.get(s.dataId).values, i = e.data.get(o.dataId).values, [l, u] = dr(r, n.shape, n.dtype, c, i);
   return e.makeTensorInfo(u, n.dtype, l);
 }
-const yg = {
+const kg = {
   kernelName: za,
   backendName: "cpu",
-  kernelFunc: kg
+  kernelFunc: yg
 };
 function $g(a) {
   const { inputs: t, backend: e, attrs: n } = a, { sparseIndices: s, sparseValues: o, defaultValue: r } = t, { outputShape: c } = n, { sliceRank: i, numUpdates: l, sliceSize: u, strides: p, outputSize: d } = Ct(o, s, c), h = !1, f = e.bufferSync(s);
@@ -2887,18 +2887,18 @@ function Eg(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s } = t, { begin: o, end: r, strides: c, beginMask: i, endMask: l, ellipsisMask: u, newAxisMask: p, shrinkAxisMask: d } = n;
   j(s, "stridedSlice");
   const { finalShapeSparse: h, finalShape: f, isIdentity: m, sliceDim0: x, isSimpleSlice: g, begin: C, end: I, strides: b } = Lr(s.shape, o, r, c, i, l, u, p, d);
-  let k;
+  let y;
   if (m)
-    k = ce({ inputs: { x: s }, backend: e, attrs: { shape: f } });
+    y = ce({ inputs: { x: s }, backend: e, attrs: { shape: f } });
   else if (x || g) {
     te(s.shape.length >= 1, () => `Input must have rank at least 1, got: ${s.shape.length}`);
-    const y = Vr(C, I, b), $ = dt({ inputs: { x: s }, backend: e, attrs: { begin: C, size: y } });
-    k = ce({ inputs: { x: $ }, backend: e, attrs: { shape: f } }), e.disposeIntermediateTensorInfo($);
+    const k = Vr(C, I, b), $ = dt({ inputs: { x: s }, backend: e, attrs: { begin: C, size: k } });
+    y = ce({ inputs: { x: $ }, backend: e, attrs: { shape: f } }), e.disposeIntermediateTensorInfo($);
   } else {
-    const y = e.bufferSync(s), $ = ol(h, y, b, C);
-    k = e.makeTensorInfo(f, $.dtype, $.values);
+    const k = e.bufferSync(s), $ = ol(h, k, b, C);
+    y = e.makeTensorInfo(f, $.dtype, $.values);
   }
-  return k;
+  return y;
 }
 const Dg = {
   kernelName: Ka,
@@ -2996,7 +2996,7 @@ const Kg = {
   kernelFunc: Xg
 };
 function jg(a) {
-  const { inputs: t, attrs: e, backend: n } = a, { image: s, transforms: o } = t, { interpolation: r, fillMode: c, fillValue: i, outputShape: l } = e, [u, p, d, h] = s.shape, [f, m] = l ?? [p, d], x = [u, f, m, h], g = ee(s.shape), C = g[0], I = g[1], b = g[2], k = ee(x), y = k[0], $ = k[1], v = k[2], w = _e(s.dtype, G(x));
+  const { inputs: t, attrs: e, backend: n } = a, { image: s, transforms: o } = t, { interpolation: r, fillMode: c, fillValue: i, outputShape: l } = e, [u, p, d, h] = s.shape, [f, m] = l ?? [p, d], x = [u, f, m, h], g = ee(s.shape), C = g[0], I = g[1], b = g[2], y = ee(x), k = y[0], $ = y[1], v = y[2], w = _e(s.dtype, G(x));
   w.fill(i);
   const S = n.data.get(s.dataId).values, E = n.data.get(o.dataId).values;
   for (let D = 0; D < u; ++D) {
@@ -3019,7 +3019,7 @@ function jg(a) {
             default:
               throw new Error(`Error in Transform: Expect 'nearest' or 'bilinear', but got ${r}`);
           }
-          const z = D * y + R * $ + T * v + A;
+          const z = D * k + R * $ + T * v + A;
           w[z] = N;
         }
     return n.makeTensorInfo(x, s.dtype, w);
@@ -3168,7 +3168,7 @@ const cx = [
   mp,
   xp,
   bp,
-  kp,
+  yp,
   vp,
   wp,
   Tp,
@@ -3200,7 +3200,7 @@ const cx = [
   gh,
   Ch,
   Ih,
-  kh,
+  yh,
   $h,
   Sh,
   Nh,
@@ -3219,8 +3219,8 @@ const cx = [
   Zh,
   Jh,
   tf,
-  kl,
   yl,
+  kl,
   nf,
   af,
   cf,
@@ -3238,7 +3238,7 @@ const cx = [
   Nl,
   If,
   Rl,
-  yf,
+  kf,
   Sf,
   Nf,
   Ef,
@@ -3267,7 +3267,7 @@ const cx = [
   gm,
   xm,
   hi,
-  km,
+  ym,
   qd,
   Ol,
   $m,
@@ -3303,7 +3303,7 @@ const cx = [
   gg,
   Cg,
   Ig,
-  yg,
+  kg,
   vg,
   wg,
   Wl,
@@ -3620,14 +3620,14 @@ function Ix(a, t, e, n) {
 function xi(a) {
   return a.internalFormatPackedFloat;
 }
-function kx(a, t, e, n) {
+function yx(a, t, e, n) {
   const [s, o] = Ot(t, e);
   return Vt(a, s, o, xi(n), a.RGBA, a.FLOAT);
 }
 function Ci(a) {
   return a.internalFormatPackedHalfFloat;
 }
-function yx(a, t, e, n) {
+function kx(a, t, e, n) {
   const [s, o] = Ot(t, e);
   return Vt(a, s, o, Ci(n), a.RGBA, n.textureTypeHalfFloat);
 }
@@ -3723,10 +3723,10 @@ class xs {
     this.throwIfDisposed(), vx(this.gl, t, e, n, s, this.textureConfig);
   }
   createFloat16PackedMatrixTexture(t, e) {
-    return this.throwIfDisposed(), yx(this.gl, t, e, this.textureConfig);
+    return this.throwIfDisposed(), kx(this.gl, t, e, this.textureConfig);
   }
   createPackedMatrixTexture(t, e) {
-    return this.throwIfDisposed(), kx(this.gl, t, e, this.textureConfig);
+    return this.throwIfDisposed(), yx(this.gl, t, e, this.textureConfig);
   }
   deleteMatrixTexture(t) {
     this.throwIfDisposed(), this.outputTexture === t && (Nn(this.gl, this.framebuffer), this.outputTexture = null), Y(this.gl, () => this.gl.deleteTexture(t));
@@ -3784,7 +3784,7 @@ class xs {
     this.throwIfDisposed(), this.program = t, this.program != null && this.debug && fs(this.gl, this.program), Y(this.gl, () => this.gl.useProgram(t));
   }
   getUniformLocation(t, e, n = !0) {
-    return this.throwIfDisposed(), n ? ku(this.gl, t, e) : yu(this.gl, t, e);
+    return this.throwIfDisposed(), n ? yu(this.gl, t, e) : ku(this.gl, t, e);
   }
   getAttributeLocation(t, e) {
     return this.throwIfDisposed(), Y(this.gl, () => this.gl.getAttribLocation(t, e));
@@ -3940,7 +3940,7 @@ class Fx {
         }
       `;
     else {
-      const e = ke("rc", this.rank), n = he(this.rank), s = this.getOutOfBoundsCondition(e), o = this.getSetup(e), r = this.getOutput(e);
+      const e = ye("rc", this.rank), n = he(this.rank), s = this.getOutOfBoundsCondition(e), o = this.getSetup(e), r = this.getOutput(e);
       this.userCode = `
         void main() {
           ${n} rc = getOutputCoords();
@@ -4122,7 +4122,7 @@ function Mn(a, t, e) {
 class Lx {
   constructor(t) {
     this.variableNames = ["A"], this.packedInputs = !0, this.packedOutput = !1, this.outputShape = t, this.enableShapeUniforms = Pe(this.outputShape.length);
-    const e = t.length, n = ke("rc", e), s = he(e), o = yd(e, n), r = n.slice(-2), c = e <= 1 ? "rc" : `vec2(${r.join(",")})`;
+    const e = t.length, n = ye("rc", e), s = he(e), o = kd(e, n), r = n.slice(-2), c = e <= 1 ? "rc" : `vec2(${r.join(",")})`;
     this.userCode = `
       void main() {
         ${s} rc = getOutputCoords();
@@ -4577,8 +4577,8 @@ class us extends oo {
       (i || !x) && ([f, m] = Ot(p[0], p[1])), i ? h = new fx(d, x) : h = new Ln(d, x);
       const g = x ? [m, f] : p, C = this.makeTensorInfo(g, s), I = this.texData.get(C.dataId);
       x ? I.usage = De.PIXELS : I.usage = De.UPLOAD, I.texShape = g, this.gpgpu.uploadDenseMatrixToTexture(this.getTexture(C.dataId), f, m, o);
-      const b = [[m, f]], y = this.runWebGLProgram(h, [C], s, b, !0), $ = this.texData.get(y.dataId);
-      e.texShape = $.texShape, e.isPacked = $.isPacked, e.usage = $.usage, _().get("ENGINE_COMPILE_ONLY") ? this.disposeData(y.dataId) : (e.texture = $.texture, e.values = null, this.texData.delete(y.dataId)), this.disposeIntermediateTensorInfo(C), l && (this.uploadWaitMs += Ge() - u);
+      const b = [[m, f]], k = this.runWebGLProgram(h, [C], s, b, !0), $ = this.texData.get(k.dataId);
+      e.texShape = $.texShape, e.isPacked = $.isPacked, e.usage = $.usage, _().get("ENGINE_COMPILE_ONLY") ? this.disposeData(k.dataId) : (e.texture = $.texture, e.values = null, this.texData.delete(k.dataId)), this.disposeIntermediateTensorInfo(C), l && (this.uploadWaitMs += Ge() - u);
     } else {
       const d = this.acquireTexture(p, c, s, i);
       e.texture = d;
@@ -4753,7 +4753,7 @@ const bi = 1e3;
 function es({ a, b: t, transposeA: e, transposeB: n, backend: s, bias: o = null, preluActivationWeights: r = null, leakyreluAlpha: c = 0, activation: i = null }) {
   const l = a.shape.length, u = t.shape.length, p = e ? a.shape[l - 2] : a.shape[l - 1], d = n ? t.shape[u - 1] : t.shape[u - 2], h = e ? a.shape[l - 1] : a.shape[l - 2], f = n ? t.shape[u - 2] : t.shape[u - 1], m = a.shape.slice(0, -2), x = t.shape.slice(0, -2), g = G(m), C = G(x), b = Ne(a.shape.slice(0, -2), t.shape.slice(0, -2)).concat([h, f]);
   te(p === d, () => `Error in matMul: inner shapes (${p}) and (${d}) of Tensors with shapes ${a.shape} and ${t.shape} and transposeA=${e} and transposeB=${n} must match.`);
-  const k = e ? [g, p, h] : [g, h, p], y = n ? [C, f, d] : [C, d, f], $ = U({ inputs: { x: a }, backend: s, attrs: { shape: k } }), v = U({ inputs: { x: t }, backend: s, attrs: { shape: y } }), w = [$, v], S = Math.max(g, C), E = e ? $.shape[1] : $.shape[2], P = o != null, D = r != null, F = i === "leakyrelu", R = i != null ? Rt(i, !0) : null, T = P || D || F || R != null;
+  const y = e ? [g, p, h] : [g, h, p], k = n ? [C, f, d] : [C, d, f], $ = U({ inputs: { x: a }, backend: s, attrs: { shape: y } }), v = U({ inputs: { x: t }, backend: s, attrs: { shape: k } }), w = [$, v], S = Math.max(g, C), E = e ? $.shape[1] : $.shape[2], P = o != null, D = r != null, F = i === "leakyrelu", R = i != null ? Rt(i, !0) : null, T = P || D || F || R != null;
   let A;
   if ((h === 1 || f === 1) && E > bi && T === !1) {
     let O = $, V = v;
@@ -4775,7 +4775,7 @@ function es({ a, b: t, transposeA: e, transposeB: n, backend: s, bias: o = null,
     const H = Cn({ inputs: { a: W, b: M }, backend: s });
     A = fn({ inputs: { x: H }, backend: s, attrs: { axis: z, keepDims: !0 } }), w.push(H);
   } else {
-    const O = Qe(a.dtype, t.dtype), V = new qr(k, y, [S, h, f], e, n, P, R, D, F), L = [$, v];
+    const O = Qe(a.dtype, t.dtype), V = new qr(y, k, [S, h, f], e, n, P, R, D, F), L = [$, v];
     if (o != null && L.push(o), D && L.push(r), F) {
       const B = s.makeTensorInfo([], "float32", mt(c, "float32"));
       L.push(B), w.push(B);
@@ -4908,7 +4908,7 @@ function lC(a) {
   let l = i;
   const u = ge(l, c);
   let p = s;
-  u != null && (p = Ie({ inputs: { x: s }, backend: e, attrs: { perm: u } }), l = xe(l.length, c)), ye("all", l, c);
+  u != null && (p = Ie({ inputs: { x: s }, backend: e, attrs: { perm: u } }), l = xe(l.length, c)), ke("all", l, c);
   const [d, h] = ve(p.shape, l), f = G(h), m = U({ inputs: { x: p }, backend: e, attrs: { shape: [-1, f] } }), x = _t(m, m.dtype, "all", e);
   let g;
   if (r) {
@@ -4928,7 +4928,7 @@ function dC(a) {
   let l = i;
   const u = ge(l, c);
   let p = s;
-  u != null && (p = Ie({ inputs: { x: s }, backend: e, attrs: { perm: u } }), l = xe(l.length, c)), ye("any", l, c);
+  u != null && (p = Ie({ inputs: { x: s }, backend: e, attrs: { perm: u } }), l = xe(l.length, c)), ke("any", l, c);
   const [d, h] = ve(p.shape, l), f = G(h), m = U({ inputs: { x: p }, backend: e, attrs: { shape: [-1, f] } }), x = _t(m, m.dtype, "any", e);
   let g;
   if (r) {
@@ -4977,7 +4977,7 @@ class fC {
     this.variableNames = ["A"], this.packedInputs = !0, this.packedOutput = !0, te(t.length > 2, () => `Packed arg${n.charAt(0).toUpperCase() + n.slice(1)} supports only inputs with rank above 2.`);
     const o = t[t.length - 1], r = Math.ceil(o / e);
     this.outputShape = t.slice(0, -1), r > 1 && this.outputShape.push(r), s || this.variableNames.push("bestIndicesA");
-    const c = this.outputShape, i = c.length, l = he(i), u = ke("coords", i);
+    const c = this.outputShape, i = c.length, l = he(i), u = ye("coords", i);
     let p, d;
     if (r === 1) {
       d = i + 1;
@@ -5001,11 +5001,11 @@ class fC {
         --${u[i - 1]};
         ${l} sourceLocB = coords;
         --${u[i - 2]};`;
-    const h = ["x", "y", "z", "w", "u", "v"].slice(0, d), f = "." + h[d - 1], m = h.map((v) => "int " + v), x = ke("sourceLocR", d - 1).concat("inIdx.r"), g = ke("sourceLocG", d - 1).concat("inIdx.g"), C = ke("sourceLocB", d - 1).concat("inIdx.b"), I = ke("sourceLocA", d - 1).concat("inIdx.a"), b = n === "max" ? "greaterThan" : "lessThan", k = s ? "" : `
+    const h = ["x", "y", "z", "w", "u", "v"].slice(0, d), f = "." + h[d - 1], m = h.map((v) => "int " + v), x = ye("sourceLocR", d - 1).concat("inIdx.r"), g = ye("sourceLocG", d - 1).concat("inIdx.g"), C = ye("sourceLocB", d - 1).concat("inIdx.b"), I = ye("sourceLocA", d - 1).concat("inIdx.a"), b = n === "max" ? "greaterThan" : "lessThan", y = s ? "" : `
           inIdx = round(vec4(getBestIndicesAChannel(${x.join()}),
                              getBestIndicesAChannel(${g.join()}),
                              getBestIndicesAChannel(${C.join()}),
-                             getBestIndicesAChannel(${I.join()})));`, y = `vec4(
+                             getBestIndicesAChannel(${I.join()})));`, k = `vec4(
             getAChannel(${x.join()}),
             hasNextCol ? getAChannel(${g.join()}) : 0.,
             hasNextRow ? getAChannel(${C.join()}) : 0.,
@@ -5029,12 +5029,12 @@ class fC {
           sourceLocB${f}, sourceLocA${f}) * ${e};
         ivec4 inIdx = srcIdx;
         vec4 bestIndex = vec4(inIdx);
-        vec4 bestValue = ${y};
+        vec4 bestValue = ${k};
 
         for (int i = 0; i < ${e}; i++) {
           inIdx = srcIdx;
-          ${k}
-          vec4 candidate = ${y};
+          ${y}
+          vec4 candidate = ${k};
           bvec4 nan = isnan(candidate);
           bvec4 replace = bvec4(
             vec4(${b}(candidate, bestValue)) * (vec4(1.0) - vec4(nan)));
@@ -5062,17 +5062,17 @@ function Ii(a, t, e, n = null) {
   const p = Ii(a, t, e, u);
   return a.disposeIntermediateTensorInfo(u), p;
 }
-function ki(a, t, e, n = null) {
+function yi(a, t, e, n = null) {
   const s = n != null ? n.shape : t.shape, o = s[s.length - 1], r = Er(o), c = new fC(s, r, e, n == null), i = n == null ? [t] : [t, n], l = a.runWebGLProgram(c, i, "int32");
   if (l.shape.length === t.shape.length) {
-    const u = ki(a, t, e, l);
+    const u = yi(a, t, e, l);
     return a.disposeIntermediateTensorInfo(l), u;
   }
   return l;
 }
-function yi(a, t, e, n) {
+function ki(a, t, e, n) {
   const s = [e];
-  if (ye("arg" + n.charAt(0).toUpperCase() + n.slice(1), s, t.shape.length), !_().getBool("WEBGL_PACK_REDUCE") || t.shape.length <= 2) {
+  if (ke("arg" + n.charAt(0).toUpperCase() + n.slice(1), s, t.shape.length), !_().getBool("WEBGL_PACK_REDUCE") || t.shape.length <= 2) {
     const o = [], r = a.texData.get(t.dataId), c = r !== null && r.isPacked;
     let i = t;
     c && (i = a.unpackTensor(t), o.push(i));
@@ -5083,7 +5083,7 @@ function yi(a, t, e, n) {
     const f = U({ inputs: { x: h }, backend: a, attrs: { shape: l } });
     return o.forEach((m) => a.disposeIntermediateTensorInfo(m)), f;
   }
-  return ki(a, t, n);
+  return yi(a, t, n);
 }
 function mC(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s } = t, { axis: o } = n;
@@ -5091,8 +5091,8 @@ function mC(a) {
   const c = ge(r, s.shape.length);
   let i = s;
   const l = [];
-  c != null && (i = Ie({ inputs: { x: s }, backend: e, attrs: { perm: c } }), l.push(i), r = xe(r.length, i.shape.length)), ye("argMax", [r[0]], i.shape.length);
-  const u = yi(e, i, r[0], "max");
+  c != null && (i = Ie({ inputs: { x: s }, backend: e, attrs: { perm: c } }), l.push(i), r = xe(r.length, i.shape.length)), ke("argMax", [r[0]], i.shape.length);
+  const u = ki(e, i, r[0], "max");
   return l.forEach((p) => e.disposeIntermediateTensorInfo(p)), u;
 }
 const gC = {
@@ -5106,8 +5106,8 @@ function xC(a) {
   const c = ge(r, s.shape.length);
   let i = s;
   const l = [];
-  c != null && (i = Ie({ inputs: { x: s }, backend: e, attrs: { perm: c } }), l.push(i), r = xe(r.length, i.shape.length)), ye("argMin", [r[0]], i.shape.length);
-  const u = yi(e, i, r[0], "min");
+  c != null && (i = Ie({ inputs: { x: s }, backend: e, attrs: { perm: c } }), l.push(i), r = xe(r.length, i.shape.length)), ke("argMin", [r[0]], i.shape.length);
+  const u = ki(e, i, r[0], "min");
   return l.forEach((p) => e.disposeIntermediateTensorInfo(p)), u;
 }
 const CC = {
@@ -5120,12 +5120,12 @@ const bC = We + `
     return NAN;
   }
   return asin(x);
-`, IC = se({ opSnippet: bC }), kC = {
+`, IC = se({ opSnippet: bC }), yC = {
   kernelName: Ds,
   backendName: "webgl",
   kernelFunc: IC
 };
-const yC = We + "return log(x + sqrt(x * x + 1.0));", $C = se({ opSnippet: yC }), vC = {
+const kC = We + "return log(x + sqrt(x * x + 1.0));", $C = se({ opSnippet: kC }), vC = {
   kernelName: Fs,
   backendName: "webgl",
   kernelFunc: $C
@@ -5224,7 +5224,7 @@ class Tt {
     const I = "max";
     let b = `${e}(${e}(${e}(minMaxValue[0], minMaxValue[1]), minMaxValue[2]), minMaxValue[3])`;
     e === "avg" && (b = "avgValue / max(count, 1.0)");
-    const k = Math.floor(r / 4) * 4, y = r % 4, $ = `
+    const y = Math.floor(r / 4) * 4, k = r % 4, $ = `
       if (${m}) {
         avgValue += dot(values, ones);
       } else {
@@ -5270,7 +5270,7 @@ class Tt {
             continue;
           }
 
-          for (int wC = 0; wC < ${k}; wC += 4) {
+          for (int wC = 0; wC < ${y}; wC += 4) {
             int xC = xCCorner + wC * ${u};
 
             vec4 values = vec4(
@@ -5283,8 +5283,8 @@ class Tt {
             ${$}
           }
 
-          int xC = xCCorner + ${k};
-          if (${y === 1}) {
+          int xC = xCCorner + ${y};
+          if (${k === 1}) {
             vec4 values = vec4(
               getValue(batch, xR, xC, d),
               initializationValue,
@@ -5293,7 +5293,7 @@ class Tt {
             );
 
             ${$}
-          } else if (${y === 2}) {
+          } else if (${k === 2}) {
             vec4 values = vec4(
               getValue(batch, xR, xC, d),
               getValue(batch, xR, xC + ${u}, d),
@@ -5302,7 +5302,7 @@ class Tt {
             );
 
             ${$}
-          } else if (${y === 3}) {
+          } else if (${k === 3}) {
             vec4 values = vec4(
               getValue(batch, xR, xC, d),
               getValue(batch, xR, xC + ${u}, d),
@@ -5392,14 +5392,14 @@ class bn {
       `;
       return;
     }
-    const k = "max";
-    let y = `${e}(${e}(${e}(minMaxValue[0], minMaxValue[1]), minMaxValue[2]), minMaxValue[3])`;
-    e === "avg" && (y = "avgValue / max(count, 1.0)");
+    const y = "max";
+    let k = `${e}(${e}(${e}(minMaxValue[0], minMaxValue[1]), minMaxValue[2]), minMaxValue[3])`;
+    e === "avg" && (k = "avgValue / max(count, 1.0)");
     const $ = Math.floor(r / 4) * 4, v = r % 4, w = `
       if (${I}) {
         avgValue += dot(values, ones);
       } else {
-        minMaxValue = ${k}(values, minMaxValue);
+        minMaxValue = ${y}(values, minMaxValue);
       }
     `;
     this.userCode = `
@@ -5495,7 +5495,7 @@ class bn {
             }
           }
         }
-        setOutput(${y});
+        setOutput(${k});
       }
     `;
   }
@@ -5720,7 +5720,7 @@ const qC = ({ inputs: a, backend: t, attrs: e }) => {
   const d = _().getBool("WEBGL_PACK_NORMALIZATION") ? new jC(n.shape, s.shape, o.shape, u, p, i) : new KC(n.shape, s.shape, o.shape, u, p, i);
   return t.runWebGLProgram(d, l, l[0].dtype);
 }, YC = {
-  kernelName: ko,
+  kernelName: yo,
   backendName: "webgl",
   kernelFunc: qC
 };
@@ -5731,7 +5731,7 @@ class QC {
     this.customUniforms = [{ name: "start", arrayIndex: this.rank, type: "int" }];
     const n = ZC(this.rank);
     let s;
-    const o = t.map((r, c) => `sourceLoc.${ys[c]} = start[${c}] + coords.${ys[c]};`);
+    const o = t.map((r, c) => `sourceLoc.${ks[c]} = start[${c}] + coords.${ks[c]};`);
     s = `
         ${e} sourceLoc;
         ${e} coords = getOutputCoords();
@@ -5745,18 +5745,18 @@ class QC {
     `;
   }
 }
-const ys = ["x", "y", "z", "w", "u", "v"];
+const ks = ["x", "y", "z", "w", "u", "v"];
 function ZC(a) {
   if (a === 1)
     return "sourceLoc";
   if (a <= 6)
-    return ys.slice(0, a).map((t) => "sourceLoc." + t).join(",");
+    return ks.slice(0, a).map((t) => "sourceLoc." + t).join(",");
   throw Error(`Slicing for rank ${a} is not yet supported`);
 }
 class JC {
   constructor(t) {
     this.variableNames = ["source"], this.packedInputs = !0, this.packedOutput = !0, this.outputShape = t, this.rank = t.length, this.customUniforms = [{ name: "start", arrayIndex: this.rank, type: "int" }];
-    const e = he(this.rank), n = ke("coords", this.rank), s = ke("sourceLoc", this.rank), o = this.rank === 1 ? "sourceLoc" : `vec2(${s.slice(-2).join()})`, r = `getChannel(getSource(${s.join()}), ${o})`, c = `
+    const e = he(this.rank), n = ye("coords", this.rank), s = ye("sourceLoc", this.rank), o = this.rank === 1 ? "sourceLoc" : `vec2(${s.slice(-2).join()})`, r = `getChannel(getSource(${s.join()}), ${o})`, c = `
       result.x = ${r};
       if (++${n[this.rank - 1]} < ${t[this.rank - 1]}) {
         ++${s[this.rank - 1]};
@@ -5801,7 +5801,7 @@ function eb(a, t, e, n) {
   const i = n.dataRefCount.get(r.slice.origDataId) || 1;
   return n.dataRefCount.set(r.slice.origDataId, i + 1), o;
 }
-function kt(a) {
+function yt(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s } = t, { begin: o, size: r } = n, [c, i] = eu(s, o, r);
   if (tu(s, c, i), G(i) === 0)
     return e.makeTensorInfo(i, s.dtype, []);
@@ -5819,7 +5819,7 @@ function kt(a) {
 const tb = {
   kernelName: dc,
   backendName: "webgl",
-  kernelFunc: kt
+  kernelFunc: yt
 };
 const sb = (a) => {
   const { inputs: t, backend: e, attrs: n } = a, { x: s } = t, { blockShape: o, crops: r } = n;
@@ -5828,14 +5828,14 @@ const sb = (a) => {
     inputs: { x: m },
     backend: e,
     attrs: { shape: u }
-  }), g = kt({
+  }), g = yt({
     inputs: { x },
     backend: e,
     attrs: { begin: p, size: d }
   });
   return h.push(f), h.push(m), h.push(x), h.forEach((C) => e.disposeIntermediateTensorInfo(C)), g;
 }, nb = {
-  kernelName: yo,
+  kernelName: ko,
   backendName: "webgl",
   kernelFunc: sb
 };
@@ -5956,7 +5956,7 @@ class Ib {
     `;
   }
 }
-class kb {
+class yb {
   constructor(t) {
     this.variableNames = ["A"], this.packedInputs = !0, this.packedOutput = !0, this.customUniforms = [
       { name: "minVal", type: "float" },
@@ -5975,17 +5975,17 @@ class kb {
     `;
   }
 }
-function yb(a) {
+function kb(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s } = t, { clipValueMin: o, clipValueMax: r } = n;
   let c;
-  _().getBool("WEBGL_PACK_CLIP") ? c = new kb(s.shape) : c = new Ib(s.shape);
+  _().getBool("WEBGL_PACK_CLIP") ? c = new yb(s.shape) : c = new Ib(s.shape);
   const i = [[o], [r]];
   return e.runWebGLProgram(c, [s], s.dtype, i);
 }
 const $b = {
   kernelName: _s,
   backendName: "webgl",
-  kernelFunc: yb
+  kernelFunc: kb
 };
 class vb {
   constructor(t) {
@@ -6057,7 +6057,7 @@ class Nb {
 class Rb {
   constructor(t, e) {
     this.packedInputs = !0, this.packedOutput = !0, this.outputShape = [], this.outputShape = Ue(t, e);
-    const n = this.outputShape, s = n.length, o = he(s), r = ke("coords", s), c = ["x", "y", "z", "w", "u", "v"].slice(0, s);
+    const n = this.outputShape, s = n.length, o = he(s), r = ye("coords", s), c = ["x", "y", "z", "w", "u", "v"].slice(0, s);
     this.variableNames = t.map((m, x) => `T${x}`);
     const i = new Array(t.length - 1);
     i[0] = t[0][e];
@@ -6132,8 +6132,8 @@ function vt(a, t, e) {
   let s = e.shouldExecuteOnCPU(a);
   if (n === "string" && (s = !0), s) {
     const h = a.map((b) => {
-      const y = [-1, G(b.shape.slice(t))];
-      return U({ inputs: { x: b }, backend: e, attrs: { shape: y } });
+      const k = [-1, G(b.shape.slice(t))];
+      return U({ inputs: { x: b }, backend: e, attrs: { shape: k } });
     }), f = h.map((b) => ({ vals: e.readSync(b.dataId), shape: b.shape })), m = Ue(
       h.map((b) => b.shape),
       1
@@ -6193,7 +6193,7 @@ class Si {
   constructor(t, e = !1, n = null, s = !1, o = !1) {
     this.variableNames = ["x", "W"], this.outputShape = t.outShape;
     const r = t.padInfo.top, c = t.padInfo.left, i = t.strideHeight, l = t.strideWidth, u = t.dilationHeight, p = t.dilationWidth, d = t.filterHeight, h = t.filterWidth, f = Math.floor(t.inChannels / 4) * 4, m = t.inChannels % 4, x = t.dataFormat === "channelsLast", g = x ? 1 : 2, C = x ? 2 : 3, I = x ? 3 : 1;
-    let b = "", k = "";
+    let b = "", y = "";
     n && (s ? b = `float activation(float a) {
           float b = getPreluActivationWeightsAtOutCoords();
           ${n}
@@ -6204,8 +6204,8 @@ class Si {
           float activation(float x) {
             ${n}
           }
-        `, k = "result = activation(result);");
-    const y = e ? "result += getBiasAtOutCoords();" : "";
+        `, y = "result = activation(result);");
+    const k = e ? "result += getBiasAtOutCoords();" : "";
     e && this.variableNames.push("bias"), s && this.variableNames.push("preluActivationWeights"), o && this.variableNames.push("leakyreluAlpha"), this.userCode = `
       ${b}
 
@@ -6326,8 +6326,8 @@ class Si {
         }
 
         float result = dotProd;
-        ${y}
         ${k}
+        ${y}
         setOutput(result);
       }
     `;
@@ -6755,12 +6755,12 @@ function Ni({ x: a, filter: t, convInfo: e, backend: n, bias: s = null, preluAct
     b != null && (s = U({ inputs: { x: s }, backend: n, attrs: { shape: b } }), g.push(s));
   }
   if (!((p === 1 || d === 1) && u > bi) && l.isPacked && h && l.texture != null && i[2] % 2 !== 0 && nt(l.shape.slice(-3), i.slice(-3))) {
-    const b = i[0] * i[1] * (i[2] + 1), k = {
+    const b = i[0] * i[1] * (i[2] + 1), y = {
       dataId: a.dataId,
       shape: [1, b, e.inChannels],
       dtype: a.dtype
-    }, y = l.shape;
-    l.shape = l.shape.slice(), l.shape[l.shape.length - 2]++, te(Ur(l.shape, k.shape), () => `packed reshape ${l.shape} to ${k.shape} isn't free`);
+    }, k = l.shape;
+    l.shape = l.shape.slice(), l.shape[l.shape.length - 2]++, te(Ur(l.shape, y.shape), () => `packed reshape ${l.shape} to ${y.shape} isn't free`);
     const $ = U({
       inputs: { x: t },
       backend: n,
@@ -6768,7 +6768,7 @@ function Ni({ x: a, filter: t, convInfo: e, backend: n, bias: s = null, preluAct
     });
     g.push($);
     const v = es({
-      a: k,
+      a: y,
       b: $,
       backend: n,
       transposeA: f,
@@ -6778,21 +6778,21 @@ function Ni({ x: a, filter: t, convInfo: e, backend: n, bias: s = null, preluAct
       preluActivationWeights: o,
       leakyreluAlpha: r
     }), w = n.texData.get(v.dataId);
-    te(w.isPacked, () => "batchMatMul result is expected to be packed"), l.shape = y, w.shape = e.outShape, x = Fe({ inputs: { x: v }, backend: n }), x.shape = e.outShape, g.push(v);
+    te(w.isPacked, () => "batchMatMul result is expected to be packed"), l.shape = k, w.shape = e.outShape, x = Fe({ inputs: { x: v }, backend: n }), x.shape = e.outShape, g.push(v);
   } else {
-    const b = e.outHeight * e.outWidth, k = U({
+    const b = e.outHeight * e.outWidth, y = U({
       inputs: { x: a },
       backend: n,
       attrs: {
         shape: h ? [e.batchSize, b, e.inChannels] : [e.batchSize, e.inChannels, b]
       }
-    }), y = U({
+    }), k = U({
       inputs: { x: t },
       backend: n,
       attrs: { shape: [1, e.inChannels, e.outChannels] }
     }), $ = es({
-      a: h ? k : y,
-      b: h ? y : k,
+      a: h ? y : k,
+      b: h ? k : y,
       transposeA: !h,
       transposeB: m,
       backend: n,
@@ -6801,7 +6801,7 @@ function Ni({ x: a, filter: t, convInfo: e, backend: n, bias: s = null, preluAct
       preluActivationWeights: o,
       leakyreluAlpha: r
     });
-    x = U({ inputs: { x: $ }, backend: n, attrs: { shape: e.outShape } }), g.push(k), g.push(y), g.push($);
+    x = U({ inputs: { x: $ }, backend: n, attrs: { shape: e.outShape } }), g.push(y), g.push(k), g.push($);
   }
   for (const b of g)
     n.disposeIntermediateTensorInfo(b);
@@ -6821,13 +6821,13 @@ function Ri({ x: a, filter: t, convInfo: e, backend: n, bias: s = null, preluAct
     const N = ts(s.shape, f);
     N != null && (s = U({ inputs: { x: s }, backend: n, attrs: { shape: N } }), b.push(s));
   }
-  const k = U({
+  const y = U({
     inputs: { x: t },
     backend: n,
     attrs: { shape: [1, m, G(t.shape) / m] }
   });
-  b.push(k);
-  const y = new Pb(g, e), $ = [
+  b.push(y);
+  const k = new Pb(g, e), $ = [
     a.shape,
     [e.padInfo.top, e.padInfo.left],
     [e.strideHeight, e.strideWidth],
@@ -6835,9 +6835,9 @@ function Ri({ x: a, filter: t, convInfo: e, backend: n, bias: s = null, preluAct
     [e.inChannels],
     [e.filterWidth * e.inChannels],
     [e.outWidth]
-  ], v = n.runWebGLProgram(y, [a], "float32", $), w = U({ inputs: { x: v }, backend: n, attrs: { shape: g } });
+  ], v = n.runWebGLProgram(k, [a], "float32", $), w = U({ inputs: { x: v }, backend: n, attrs: { shape: g } });
   b.push(v), b.push(w);
-  const S = s != null, E = o != null, P = c === "leakyrelu", D = c ? Rt(c, !0) : null, F = new qr(f ? w.shape : k.shape, f ? k.shape : w.shape, f ? [e.batchSize, x, e.outChannels] : [e.batchSize, e.outChannels, x], C, I, S, D, E, P), R = f ? [w, k] : [k, w];
+  const S = s != null, E = o != null, P = c === "leakyrelu", D = c ? Rt(c, !0) : null, F = new qr(f ? w.shape : y.shape, f ? y.shape : w.shape, f ? [e.batchSize, x, e.outChannels] : [e.batchSize, e.outChannels, x], C, I, S, D, E, P), R = f ? [w, y] : [y, w];
   if (s && R.push(s), E && R.push(o), P) {
     const N = n.makeTensorInfo([], "float32", mt(r, "float32"));
     R.push(N), b.push(N);
@@ -7261,7 +7261,7 @@ class o1 {
       "0.0",
       "0.0",
       `0.5 * (y1+y2) * ${f}`
-    ], [I, b, k] = d > 1 ? [
+    ], [I, b, y] = d > 1 ? [
       `${(i - 1) / (d - 1)}`,
       "(x2-x1) * width_ratio",
       `x1*${m} + float(x)*(width_scale)`
@@ -7300,7 +7300,7 @@ class o1 {
           setOutput(float(${o}));
           return;
         }
-        float in_x = ${k};
+        float in_x = ${y};
         if( in_x < 0.0 || in_x > ${m} ) {
           setOutput(float(${o}));
           return;
@@ -7921,12 +7921,12 @@ function I1(a) {
   ), d = new C1(p);
   return e.runWebGLProgram(d, [s, o], "float32");
 }
-const k1 = {
+const y1 = {
   kernelName: Mo,
   backendName: "webgl",
   kernelFunc: I1
 };
-function y1(a) {
+function k1(a) {
   const { inputs: t, backend: e, attrs: n } = a, { dy: s, filter: o } = t, { strides: r, dilations: c, pad: i, dimRoundingMode: l, inputShape: u } = n, p = Se(
     u,
     o.shape,
@@ -7942,7 +7942,7 @@ function y1(a) {
 const $1 = {
   kernelName: Bo,
   backendName: "webgl",
-  kernelFunc: y1
+  kernelFunc: k1
 };
 class v1 {
   constructor(t) {
@@ -8034,8 +8034,8 @@ function E1(a) {
       let I;
       br(g) ? I = o[x] : (I = Ie({ inputs: { x: o[x] }, backend: e, attrs: { perm: g } }), f.push(I));
       const b = I.shape.slice();
-      for (let k = 0; k < C.length; ++k)
-        b.splice(C[k], 0, 1);
+      for (let y = 0; y < C.length; ++y)
+        b.splice(C[y], 0, 1);
       nt(I.shape, b) || (I = U({ inputs: { x: I }, backend: e, attrs: { shape: b } }), f.push(I)), d === null ? d = I : (d = Cn({ inputs: { a: I, b: d }, backend: e }), f.push(d));
     }
     m < p - 1 && (l[m] >= 0 && (d = fn({
@@ -8100,8 +8100,8 @@ const U1 = `
   float p = ${Sr};
   float a1 = ${vr};
   float a2 = ${$r};
-  float a3 = ${yr};
-  float a4 = ${kr};
+  float a3 = ${kr};
+  float a4 = ${yr};
   float a5 = ${Ir};
 
   float sign = sign(x);
@@ -8280,7 +8280,7 @@ const o0 = {
   }
 };
 const Jn = "return floor(x);", a0 = se({ opSnippet: Jn, packedOpSnippet: Jn, cpuKernelImpl: Uu }), r0 = {
-  kernelName: kc,
+  kernelName: yc,
   backendName: "webgl",
   kernelFunc: a0
 };
@@ -8316,7 +8316,7 @@ const i0 = `
   }
   return vec4(result);
 `, l0 = Ce({ opSnippet: i0, packedOpSnippet: c0, dtype: "int32" }), u0 = {
-  kernelName: yc,
+  kernelName: kc,
   backendName: "webgl",
   kernelFunc: l0
 };
@@ -8415,7 +8415,7 @@ function f0(a) {
 function m0(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s, filter: o, bias: r, preluActivationWeights: c } = t, { strides: i, pad: l, dataFormat: u, dilations: p, dimRoundingMode: d, activation: h, leakyreluAlpha: f } = n, m = rt(u), x = Se(s.shape, o.shape, i, p, l, d, !1, m);
   let g;
-  const C = [], I = r != null, b = c != null, k = h === "leakyrelu", y = () => {
+  const C = [], I = r != null, b = c != null, y = h === "leakyrelu", k = () => {
     const v = [s, o], w = (S, E) => {
       if (E === "NCHW" && S.shape.length === 1 && S.shape[0] !== 1) {
         const P = U({
@@ -8427,7 +8427,7 @@ function m0(a) {
       }
       return S;
     };
-    if (I && v.push(w(r, u)), b && v.push(w(c, u)), k) {
+    if (I && v.push(w(r, u)), b && v.push(w(c, u)), y) {
       const S = e.makeTensorInfo([], "float32", mt(f, "float32"));
       v.push(S), C.push(S);
     }
@@ -8445,12 +8445,12 @@ function m0(a) {
       leakyreluAlpha: f
     });
   else if (x.strideWidth <= 2 && m === "channelsLast" && _().getBool("WEBGL_EXP_CONV")) {
-    const v = h ? Rt(h, !0) : null, w = new wi(x, I, v, b, k), S = [
+    const v = h ? Rt(h, !0) : null, w = new wi(x, I, v, b, y), S = [
       [x.padInfo.top, x.padInfo.left],
       [x.strideHeight, x.strideWidth],
       [x.dilationHeight, x.dilationWidth],
       [x.inHeight, x.inWidth]
-    ], E = y();
+    ], E = k();
     g = e.runWebGLProgram(w, E, "float32", S);
   } else if (_().getBool("WEBGL_CONV_IM2COL"))
     g = Ri({
@@ -8464,7 +8464,7 @@ function m0(a) {
       leakyreluAlpha: f
     });
   else {
-    const v = h ? Rt(h, !1) : null, w = new Si(x, I, v, b, k), S = y();
+    const v = h ? Rt(h, !1) : null, w = new Si(x, I, v, b, y), S = k();
     g = e.runWebGLProgram(w, S, "float32");
   }
   const $ = U({ inputs: { x: g }, backend: e, attrs: { shape: x.outShape } });
@@ -8488,13 +8488,13 @@ function x0(a) {
     p,
     !0
     /* depthwise */
-  ), g = _().getBool("WEBGL_PACK_DEPTHWISECONV") && x.strideWidth <= 2 && x.outChannels / x.inChannels === 1, C = d ? Rt(d, g) : null, I = [s, o], b = r != null, k = c != null, y = d === "leakyrelu";
-  if (b && I.push(r), k && I.push(c), y) {
+  ), g = _().getBool("WEBGL_PACK_DEPTHWISECONV") && x.strideWidth <= 2 && x.outChannels / x.inChannels === 1, C = d ? Rt(d, g) : null, I = [s, o], b = r != null, y = c != null, k = d === "leakyrelu";
+  if (b && I.push(r), y && I.push(c), k) {
     const S = e.makeTensorInfo([], "float32", mt(h, "float32"));
     I.push(S), f.push(S);
   }
   let $;
-  g ? $ = new Di(x, b, C, k, y) : $ = new Ei(x, b, C, k, y);
+  g ? $ = new Di(x, b, C, y, k) : $ = new Ei(x, b, C, y, k);
   const v = [
     [x.padInfo.top, x.padInfo.left],
     [x.strideHeight, x.strideWidth],
@@ -8546,12 +8546,12 @@ function I0(a) {
   const f = new b0(r, p, [l, u], n.shape), m = e.runWebGLProgram(f, [h, d], h.dtype), x = U({ inputs: { x: m }, backend: e, attrs: { shape: i } });
   return e.disposeIntermediateTensorInfo(d), e.disposeIntermediateTensorInfo(h), e.disposeIntermediateTensorInfo(m), x;
 }
-const k0 = {
+const y0 = {
   kernelName: ta,
   backendName: "webgl",
   kernelFunc: I0
 };
-class y0 {
+class k0 {
   constructor(t, e) {
     this.variableNames = ["A", "indices"], this.outputShape = e, this.rank = e.length;
     const n = he(this.rank), s = $0(t);
@@ -8576,8 +8576,8 @@ function Oi(a) {
   if (_().get("DEBUG")) {
     const C = e.readSync(o.dataId), I = s.shape[i];
     for (let b = 0; b < C.length; ++b) {
-      const k = C[b];
-      te(k <= I - 1 && k >= 0, () => `GatherV2: the index value ${k} is not in [0, ${I - 1}]`);
+      const y = C[b];
+      te(y <= I - 1 && y >= 0, () => `GatherV2: the index value ${y} is not in [0, ${I - 1}]`);
     }
   }
   const l = Nr(s, o, i, c), u = G(o.shape), p = [], d = U({
@@ -8605,9 +8605,9 @@ function Oi(a) {
   ];
   if (e.shouldExecuteOnCPU([s, o]) || s.dtype === "string") {
     const C = e.bufferSync(h), I = e.bufferSync(d), b = Xu(I, C, f);
-    return p.forEach((k) => e.disposeIntermediateTensorInfo(k)), e.makeTensorInfo(l.outputShape, b.dtype, b.values);
+    return p.forEach((y) => e.disposeIntermediateTensorInfo(y)), e.makeTensorInfo(l.outputShape, b.dtype, b.values);
   }
-  const m = new y0(d.shape, f), x = e.runWebGLProgram(m, [d, h], d.dtype);
+  const m = new k0(d.shape, f), x = e.runWebGLProgram(m, [d, h], d.dtype);
   p.push(x);
   const g = U({ inputs: { x }, backend: e, attrs: { shape: l.outputShape } });
   return p.forEach((C) => e.disposeIntermediateTensorInfo(C)), g;
@@ -8852,12 +8852,12 @@ class bI {
 const II = (a) => {
   const { inputs: t, backend: e, attrs: n } = a, { x: s } = t, { depthRadius: o, bias: r, alpha: c, beta: i } = n, l = _().getBool("WEBGL_PACK_NORMALIZATION") ? new bI(s.shape, o, r, c, i) : new CI(s.shape, o, r, c, i);
   return e.runWebGLProgram(l, [s], s.dtype);
-}, kI = {
+}, yI = {
   kernelName: aa,
   backendName: "webgl",
   kernelFunc: II
 };
-class yI {
+class kI {
   constructor(t, e, n, s, o) {
     this.variableNames = ["inputImage", "outputImage", "dy"], this.outputShape = [], this.outputShape = t, this.depth = t[3], this.depthRadius = e, this.bias = n, this.alpha = s, this.beta = o, this.userCode = `
       void main() {
@@ -8918,7 +8918,7 @@ class yI {
   }
 }
 const $I = (a) => {
-  const { inputs: t, backend: e, attrs: n } = a, { x: s, y: o, dy: r } = t, { depthRadius: c, bias: i, alpha: l, beta: u } = n, p = new yI(s.shape, c, i, l, u);
+  const { inputs: t, backend: e, attrs: n } = a, { x: s, y: o, dy: r } = t, { depthRadius: c, bias: i, alpha: l, beta: u } = n, p = new kI(s.shape, c, i, l, u);
   return e.runWebGLProgram(p, [s, o, r], s.dtype);
 }, vI = {
   kernelName: ra,
@@ -9150,18 +9150,18 @@ const GI = {
     let f = n;
     if (p) {
       if (d) {
-        const b = r.texData.get(f.dataId).values, k = new Array(c);
-        for (let v = 0; v < k.length; v++)
-          k[v] = n.shape[u[v]];
-        const y = Xr(b, n.shape, n.dtype, u, k);
-        f = r.makeTensorInfo(k, n.dtype);
+        const b = r.texData.get(f.dataId).values, y = new Array(c);
+        for (let v = 0; v < y.length; v++)
+          y[v] = n.shape[u[v]];
+        const k = Xr(b, n.shape, n.dtype, u, y);
+        f = r.makeTensorInfo(y, n.dtype);
         const $ = r.texData.get(f.dataId);
-        $.values = y;
+        $.values = k;
       } else
         f = Yr(n, u, r);
       h.push(f), l = xe(l.length, c);
     }
-    ye("sum", l, c);
+    ke("sum", l, c);
     const [m, x] = ve(f.shape, l);
     let g = m;
     s && (g = Te(m, i));
@@ -9176,7 +9176,7 @@ function zI(a) {
   let l = i;
   const u = ge(l, c);
   let p = s;
-  u != null && (p = Ie({ inputs: { x: s }, backend: e, attrs: { perm: u } }), l = xe(l.length, s.shape.length)), ye("min", l, c);
+  u != null && (p = Ie({ inputs: { x: s }, backend: e, attrs: { perm: u } }), l = xe(l.length, s.shape.length)), ke("min", l, c);
   const [d, h] = ve(p.shape, l), f = G(h), m = U({ inputs: { x: p }, backend: e, attrs: { shape: [-1, f] } }), x = _t(m, m.dtype, "min", e);
   let g;
   if (r) {
@@ -9258,7 +9258,7 @@ class YI {
       (f, m) => f[0] + t[m] + f[1]
       /* afterPad */
     );
-    const s = t.length, o = he(s), r = e.map((f) => f[0]).join(","), c = e.map((f, m) => f[0] + t[m]).join(","), i = ke("rc", s), l = ke("source", s), u = `${i[s - 1]} < ${this.outputShape[s - 1]}`, p = s === 1 ? "source" : `vec2(${l.slice(-2).join()})`, d = n === "reflect" ? 0 : 1;
+    const s = t.length, o = he(s), r = e.map((f) => f[0]).join(","), c = e.map((f, m) => f[0] + t[m]).join(","), i = ye("rc", s), l = ye("source", s), u = `${i[s - 1]} < ${this.outputShape[s - 1]}`, p = s === 1 ? "source" : `vec2(${l.slice(-2).join()})`, d = n === "reflect" ? 0 : 1;
     let h = "";
     if (s === 1) {
       const f = `
@@ -9335,20 +9335,20 @@ const QI = ({ inputs: a, backend: t, attrs: e }) => {
   kernelFunc: QI
 };
 const JI = `if (b == 0.0) return NAN;
-  return mod(a, b);`, ek = `
+  return mod(a, b);`, ey = `
   vec4 result = mod(a, b);
   bvec4 isNaN = equal(b, vec4(0.0));
   ` + it + `
   return result;
-`, tk = Ce({
+`, ty = Ce({
   opSnippet: JI,
-  packedOpSnippet: ek
-}), sk = {
+  packedOpSnippet: ey
+}), sy = {
   kernelName: js,
   backendName: "webgl",
-  kernelFunc: tk
+  kernelFunc: ty
 };
-class nk {
+class ny {
   constructor(t, e, n) {
     this.variableNames = ["probs"], this.customUniforms = [{ name: "seed", type: "float" }], this.outputShape = [t, n], this.userCode = `
       void main() {
@@ -9378,7 +9378,7 @@ const eo = "return a - b;", Ai = Ce({
   packedOpSnippet: eo,
   supportsComplex: !0,
   cpuKernelImpl: td
-}), ok = {
+}), oy = {
   kernelName: Dc,
   backendName: "webgl",
   kernelFunc: Ai
@@ -9391,23 +9391,23 @@ function _i(a) {
   }), i = Te(c.shape, r), l = U({ inputs: { x: c }, backend: e, attrs: { shape: i } }), u = Ai({ inputs: { a: s, b: l }, backend: e }), p = Fi({ inputs: { x: u }, backend: e }), d = fn({ inputs: { x: p }, backend: e, attrs: { axis: r, keepDims: !1 } }), h = U({ inputs: { x: d }, backend: e, attrs: { shape: i } }), f = Ed({ inputs: { a: p, b: h }, backend: e });
   return e.disposeIntermediateTensorInfo(c), e.disposeIntermediateTensorInfo(l), e.disposeIntermediateTensorInfo(u), e.disposeIntermediateTensorInfo(p), e.disposeIntermediateTensorInfo(d), e.disposeIntermediateTensorInfo(h), f;
 }
-const ak = {
+const ay = {
   kernelName: ga,
   backendName: "webgl",
   kernelFunc: _i
 };
-function rk(a) {
-  const { inputs: t, backend: e, attrs: n } = a, { logits: s } = t, { numSamples: o, seed: r, normalized: c } = n, i = c ? s : _i({ inputs: { logits: s }, backend: e, attrs: { dim: s.shape.length - 1 } }), l = i.shape[0], u = i.shape[1], p = new nk(l, u, o), d = [[r]], h = e.runWebGLProgram(p, [i], "int32", d);
+function ry(a) {
+  const { inputs: t, backend: e, attrs: n } = a, { logits: s } = t, { numSamples: o, seed: r, normalized: c } = n, i = c ? s : _i({ inputs: { logits: s }, backend: e, attrs: { dim: s.shape.length - 1 } }), l = i.shape[0], u = i.shape[1], p = new ny(l, u, o), d = [[r]], h = e.runWebGLProgram(p, [i], "int32", d);
   return c || e.disposeIntermediateTensorInfo(i), h;
 }
-const ik = {
+const iy = {
   kernelName: Ss,
   backendName: "webgl",
-  kernelFunc: rk
+  kernelFunc: ry
 };
-const ck = We + `
+const cy = We + `
   return -x;
-`, lk = `
+`, ly = `
   vec4 result = -x;
   bvec4 isNaN = isnan(x);
 
@@ -9418,60 +9418,60 @@ const ck = We + `
 
   return result;
 `;
-function uk(a) {
+function uy(a) {
   const { inputs: t, backend: e } = a, { x: n } = t;
   if (e.shouldExecuteOnCPU([n])) {
     const o = e.texData.get(n.dataId), [r, c] = sd(o.values, n.shape, n.dtype);
     return e.makeTensorInfo(c, n.dtype, r);
   }
   let s;
-  return _().getBool("WEBGL_PACK_UNARY_OPERATIONS") ? s = new st(n.shape, lk) : s = new ze(n.shape, ck), e.runWebGLProgram(s, [n], n.dtype);
+  return _().getBool("WEBGL_PACK_UNARY_OPERATIONS") ? s = new st(n.shape, ly) : s = new ze(n.shape, cy), e.runWebGLProgram(s, [n], n.dtype);
 }
-const dk = {
+const dy = {
   kernelName: Fc,
   backendName: "webgl",
-  kernelFunc: uk
+  kernelFunc: uy
 };
-const pk = Fr;
-function hk(a) {
+const py = Fr;
+function hy(a) {
   Dt("tf.nonMaxSuppression() in webgl locks the UI thread. Call tf.nonMaxSuppressionAsync() instead");
-  const { inputs: t, backend: e, attrs: n } = a, { boxes: s, scores: o } = t, { maxOutputSize: r, iouThreshold: c, scoreThreshold: i } = n, l = e.readSync(s.dataId), u = e.readSync(o.dataId), { selectedIndices: p } = pk(l, u, r, c, i);
+  const { inputs: t, backend: e, attrs: n } = a, { boxes: s, scores: o } = t, { maxOutputSize: r, iouThreshold: c, scoreThreshold: i } = n, l = e.readSync(s.dataId), u = e.readSync(o.dataId), { selectedIndices: p } = py(l, u, r, c, i);
   return e.makeTensorInfo([p.length], "int32", new Int32Array(p));
 }
-const fk = {
+const fy = {
   kernelName: xa,
   backendName: "webgl",
-  kernelFunc: hk
+  kernelFunc: hy
 };
-const mk = Pr;
-function gk(a) {
+const my = Pr;
+function gy(a) {
   Dt("tf.nonMaxSuppression() in webgl locks the UI thread. Call tf.nonMaxSuppressionAsync() instead");
-  const { inputs: t, backend: e, attrs: n } = a, { boxes: s, scores: o } = t, { maxOutputSize: r, iouThreshold: c, scoreThreshold: i, padToMaxOutputSize: l } = n, u = e.readSync(s.dataId), p = e.readSync(o.dataId), { selectedIndices: d, validOutputs: h } = mk(u, p, r, c, i, l);
+  const { inputs: t, backend: e, attrs: n } = a, { boxes: s, scores: o } = t, { maxOutputSize: r, iouThreshold: c, scoreThreshold: i, padToMaxOutputSize: l } = n, u = e.readSync(s.dataId), p = e.readSync(o.dataId), { selectedIndices: d, validOutputs: h } = my(u, p, r, c, i, l);
   return [
     e.makeTensorInfo([d.length], "int32", new Int32Array(d)),
     e.makeTensorInfo([], "int32", new Int32Array([h]))
   ];
 }
-const xk = {
+const xy = {
   kernelName: Ca,
   backendName: "webgl",
-  kernelFunc: gk
+  kernelFunc: gy
 };
-const Ck = Or;
-function bk(a) {
+const Cy = Or;
+function by(a) {
   Dt("tf.nonMaxSuppression() in webgl locks the UI thread. Call tf.nonMaxSuppressionAsync() instead");
-  const { inputs: t, backend: e, attrs: n } = a, { boxes: s, scores: o } = t, { maxOutputSize: r, iouThreshold: c, scoreThreshold: i, softNmsSigma: l } = n, u = e.readSync(s.dataId), p = e.readSync(o.dataId), d = r, h = c, f = i, m = l, { selectedIndices: x, selectedScores: g } = Ck(u, p, d, h, f, m);
+  const { inputs: t, backend: e, attrs: n } = a, { boxes: s, scores: o } = t, { maxOutputSize: r, iouThreshold: c, scoreThreshold: i, softNmsSigma: l } = n, u = e.readSync(s.dataId), p = e.readSync(o.dataId), d = r, h = c, f = i, m = l, { selectedIndices: x, selectedScores: g } = Cy(u, p, d, h, f, m);
   return [
     e.makeTensorInfo([x.length], "int32", new Int32Array(x)),
     e.makeTensorInfo([g.length], "float32", new Float32Array(g))
   ];
 }
-const Ik = {
+const Iy = {
   kernelName: ba,
   backendName: "webgl",
-  kernelFunc: bk
+  kernelFunc: by
 };
-class kk {
+class yy {
   constructor(t, e, n, s) {
     this.variableNames = ["indices"], this.outputShape = [t, e], this.userCode = `
       void main() {
@@ -9483,15 +9483,15 @@ class kk {
     `;
   }
 }
-const yk = (a) => {
-  const { inputs: t, backend: e, attrs: n } = a, { indices: s } = t, { dtype: o, depth: r, onValue: c, offValue: i } = n, l = G(s.shape), u = new kk(l, r, c, i), p = U({ inputs: { x: s }, backend: e, attrs: { shape: [l] } }), d = e.runWebGLProgram(u, [p], o);
+const ky = (a) => {
+  const { inputs: t, backend: e, attrs: n } = a, { indices: s } = t, { dtype: o, depth: r, onValue: c, offValue: i } = n, l = G(s.shape), u = new yy(l, r, c, i), p = U({ inputs: { x: s }, backend: e, attrs: { shape: [l] } }), d = e.runWebGLProgram(u, [p], o);
   e.disposeIntermediateTensorInfo(p);
   const h = [...s.shape, r], f = U({ inputs: { x: d }, backend: e, attrs: { shape: h } });
   return e.disposeIntermediateTensorInfo(d), f;
-}, $k = {
+}, $y = {
   kernelName: Ia,
   backendName: "webgl",
-  kernelFunc: yk
+  kernelFunc: ky
 };
 function ss(a) {
   const { inputs: t, backend: e } = a, { x: n } = t;
@@ -9508,8 +9508,8 @@ function ss(a) {
       backend: e
     });
 }
-const vk = {
-  kernelName: ka,
+const vy = {
+  kernelName: ya,
   backendName: "webgl",
   kernelFunc: ss
 };
@@ -9523,12 +9523,12 @@ function Li(a) {
   } else
     return Mt({ attrs: { shape: n.shape, dtype: n.dtype, value: 1 }, backend: e });
 }
-const Sk = {
-  kernelName: ya,
+const Sy = {
+  kernelName: ka,
   backendName: "webgl",
   kernelFunc: Li
 };
-function wk(a) {
+function wy(a) {
   const { inputs: t, backend: e, attrs: n } = a, { axis: s } = n;
   if (t.length === 1)
     return vs({ inputs: { input: t[0] }, backend: e, attrs: { dim: s } });
@@ -9542,12 +9542,12 @@ function wk(a) {
   }), l = vi({ inputs: i, backend: e, attrs: { axis: s } });
   return c.forEach((u) => e.disposeIntermediateTensorInfo(u)), l;
 }
-const Nk = {
+const Ny = {
   kernelName: $a,
   backendName: "webgl",
-  kernelFunc: wk
+  kernelFunc: wy
 };
-class Rk {
+class Ry {
   constructor(t, e, n) {
     this.variableNames = ["x"], this.customUniforms = [{ name: "value", type: "float" }], this.outputShape = e.map(
       (l, u) => l[0] + t[u] + l[1]
@@ -9586,13 +9586,13 @@ class Rk {
     `;
   }
 }
-class Tk {
+class Ty {
   constructor(t, e, n) {
     this.variableNames = ["x"], this.packedInputs = !0, this.packedOutput = !0, this.customUniforms = [{ name: "value", type: "float" }], this.outputShape = e.map(
       (m, x) => m[0] + t[x] + m[1]
       /* afterPad */
     );
-    const s = t.length, o = he(s), r = e.map((m) => m[0]).join(","), c = e.map((m, x) => m[0] + t[x]).join(","), i = ke("rc", s), l = ke("source", s), u = `${i[s - 1]} < ${this.outputShape[s - 1]}`, p = s === 1 ? "source" : `vec2(${l.slice(-2).join()})`, d = [
+    const s = t.length, o = he(s), r = e.map((m) => m[0]).join(","), c = e.map((m, x) => m[0] + t[x]).join(","), i = ye("rc", s), l = ye("source", s), u = `${i[s - 1]} < ${this.outputShape[s - 1]}`, p = s === 1 ? "source" : `vec2(${l.slice(-2).join()})`, d = [
       `${o} rc = outputLoc;`,
       `${i[s - 1]} += 1;
        if(${u}) {
@@ -9640,14 +9640,14 @@ const Vi = (a) => {
       attrs: { shape: l, value: r, dtype: s.dtype }
     });
   }
-  const c = _().getBool("WEBGL_PACK_ARRAY_OPERATIONS") ? new Tk(s.shape, o, r) : new Rk(s.shape, o, r), i = [[r]];
+  const c = _().getBool("WEBGL_PACK_ARRAY_OPERATIONS") ? new Ty(s.shape, o, r) : new Ry(s.shape, o, r), i = [[r]];
   return e.runWebGLProgram(c, [s], s.dtype, i);
-}, Ek = {
+}, Ey = {
   kernelName: Sa,
   backendName: "webgl",
   kernelFunc: Vi
 };
-const Dk = `
+const Dy = `
   if(a < 0.0 && floor(b) < b){
     return NAN;
   }
@@ -9656,7 +9656,7 @@ const Dk = `
   }
   return (round(mod(b, 2.0)) != 1) ?
       pow(abs(a), b) : sign(a) * pow(abs(a), b);
-`, Fk = `
+`, Fy = `
   // isModRound1 has 1 for components with round(mod(b, 2.0)) == 1, 0 otherwise.
   vec4 isModRound1 = vec4(equal(round(mod(b, 2.0)), ivec4(1)));
   vec4 multiplier = sign(a) * isModRound1 + (vec4(1.0) - isModRound1);
@@ -9674,17 +9674,17 @@ const Dk = `
   bvec4 isNaN = bvec4(isNaN1.x && isNaN2.x, isNaN1.y && isNaN2.y, isNaN1.z && isNaN2.z, isNaN1.w && isNaN2.w);
   ` + it + `
   return result;
-`, Pk = Ce({ opSnippet: Dk, packedOpSnippet: Fk }), Ok = {
+`, Py = Ce({ opSnippet: Dy, packedOpSnippet: Fy }), Oy = {
   kernelName: qs,
   backendName: "webgl",
-  kernelFunc: Pk
+  kernelFunc: Py
 };
-function Ak(a) {
+function Ay(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s } = t, { axis: o, keepDims: r } = n, c = s.shape.length, i = [], l = ue(o, s.shape);
   let u = l;
   const p = ge(u, c);
   let d = s;
-  p != null && (d = Ie({ inputs: { x: s }, backend: e, attrs: { perm: p } }), u = xe(u.length, c), i.push(d)), ye("prod", u, c);
+  p != null && (d = Ie({ inputs: { x: s }, backend: e, attrs: { perm: p } }), u = xe(u.length, c), i.push(d)), ke("prod", u, c);
   let h;
   if (e.shouldExecuteOnCPU([d])) {
     const f = e.texData.get(d.dataId).values, { outVals: m, outShape: x, outDtype: g } = nd(d.shape, d.dtype, f, u);
@@ -9700,54 +9700,54 @@ function Ak(a) {
   }
   return i.forEach((f) => e.disposeIntermediateTensorInfo(f)), h;
 }
-const _k = {
+const _y = {
   kernelName: Pc,
   backendName: "webgl",
-  kernelFunc: Ak
+  kernelFunc: Ay
 };
-function Lk(a) {
+function Ly(a) {
   const { inputs: t, backend: e, attrs: n } = a, { paramsNestedSplits: s, paramsDenseValues: o, indices: r } = t, { outputRaggedRank: c } = n, i = s.map((g) => e.readSync(g.dataId)), l = s.map((g) => g.shape), u = e.readSync(o.dataId), p = e.readSync(r.dataId), [d, h, f] = od(i, l, u, o.shape, o.dtype, p, r.shape, c), m = d.map((g) => e.makeTensorInfo([g.length], "int32", g)), x = e.makeTensorInfo(f, o.dtype, h);
   return m.concat([x]);
 }
-const Vk = {
+const Vy = {
   kernelName: wa,
   backendName: "webgl",
-  kernelFunc: Lk
+  kernelFunc: Ly
 };
-function Wk(a) {
+function Wy(a) {
   const { inputs: t, backend: e } = a, { starts: n, limits: s, deltas: o } = t, r = e.readSync(n.dataId), c = e.readSync(s.dataId), i = e.readSync(o.dataId), [l, u] = ad(r, n.shape, n.dtype, c, s.shape, i, o.shape), p = e.makeTensorInfo([l.length], "int32", l), d = e.makeTensorInfo([u.length], n.dtype, u);
   return [p, d];
 }
-const Mk = {
+const My = {
   kernelName: Na,
   backendName: "webgl",
-  kernelFunc: Wk
+  kernelFunc: Wy
 };
-function Bk(a) {
+function By(a) {
   const { inputs: t, backend: e, attrs: n } = a, { shape: s, values: o, defaultValue: r, rowPartitionTensors: c } = t, { rowPartitionTypes: i } = n, l = e.readSync(s.dataId), u = e.readSync(o.dataId), p = e.readSync(r.dataId), d = c.map((x) => e.readSync(x.dataId)), h = c.map((x) => x.shape), [f, m] = rd(l, s.shape, u, o.shape, o.dtype, p, r.shape, d, h, i);
   return e.makeTensorInfo(f, o.dtype, m);
 }
-const Gk = {
+const Gy = {
   kernelName: Ra,
   backendName: "webgl",
-  kernelFunc: Bk
+  kernelFunc: By
 };
 const Wi = (a) => {
   const { backend: t, attrs: e } = a, { start: n, stop: s, step: o, dtype: r } = e, c = id(n, s, o, r);
   return t.makeTensorInfo([c.length], r, c);
-}, zk = {
+}, zy = {
   kernelName: Ta,
   backendName: "webgl",
   kernelFunc: Wi
 };
-const Uk = "return 1.0 / x;", Hk = se({ opSnippet: Uk }), Xk = {
+const Uy = "return 1.0 / x;", Hy = se({ opSnippet: Uy }), Xy = {
   kernelName: Ys,
   backendName: "webgl",
-  kernelFunc: Hk
+  kernelFunc: Hy
 };
-const Kk = We + `
+const Ky = We + `
   return (x < 0.0) ? 0.0 : x;
-`, jk = `
+`, jy = `
   vec4 result = x * vec4(greaterThanEqual(x, vec4(0.0)));
   bvec4 isNaN = isnan(x);
 
@@ -9757,14 +9757,14 @@ const Kk = We + `
   result.a = isNaN.a ? x.a : result.a;
 
   return result;
-`, qk = se({ opSnippet: Kk, packedOpSnippet: jk }), Yk = {
+`, qy = se({ opSnippet: Ky, packedOpSnippet: jy }), Yy = {
   kernelName: Ns,
   backendName: "webgl",
-  kernelFunc: qk
+  kernelFunc: qy
 };
-const Qk = We + `
+const Qy = We + `
   return (x < 0.0) ? 0.0 : min(6.0, x);
-`, Zk = `
+`, Zy = `
   vec4 result = min(x, vec4(6.)) * vec4(greaterThanEqual(x, vec4(0.0)));
   bvec4 isNaN = isnan(x);
 
@@ -9774,12 +9774,12 @@ const Qk = We + `
   result.a = isNaN.a ? x.a : result.a;
 
   return result;
-`, Jk = se({ opSnippet: Qk, packedOpSnippet: Zk }), ey = {
+`, Jy = se({ opSnippet: Qy, packedOpSnippet: Zy }), ek = {
   kernelName: Rs,
   backendName: "webgl",
-  kernelFunc: Jk
+  kernelFunc: Jy
 };
-class ty {
+class tk {
   constructor(t, e, n, s, o) {
     this.variableNames = ["A"], this.outputShape = [];
     const [r, c, i, l] = t;
@@ -9828,7 +9828,7 @@ class ty {
     `;
   }
 }
-class sy {
+class sk {
   constructor(t, e, n, s, o) {
     this.variableNames = ["A"], this.packedInputs = !0, this.packedOutput = !0, this.outputShape = [];
     const [r, c, i, l] = t;
@@ -9921,16 +9921,16 @@ class sy {
     `;
   }
 }
-function ny(a) {
-  const { inputs: t, backend: e, attrs: n } = a, { images: s } = t, { alignCorners: o, halfPixelCenters: r, size: c } = n, [i, l] = c, u = _().getBool("WEBGL_PACK_IMAGE_OPERATIONS") ? new sy(s.shape, i, l, o, r) : new ty(s.shape, i, l, o, r);
+function nk(a) {
+  const { inputs: t, backend: e, attrs: n } = a, { images: s } = t, { alignCorners: o, halfPixelCenters: r, size: c } = n, [i, l] = c, u = _().getBool("WEBGL_PACK_IMAGE_OPERATIONS") ? new sk(s.shape, i, l, o, r) : new tk(s.shape, i, l, o, r);
   return e.runWebGLProgram(u, [s], "float32");
 }
-const oy = {
+const ok = {
   kernelName: Ea,
   backendName: "webgl",
-  kernelFunc: ny
+  kernelFunc: nk
 };
-class ay {
+class ak {
   constructor(t, e, n) {
     this.variableNames = ["dy"], this.outputShape = [], this.outputShape = e;
     const [, s, o] = e, [, r, c] = t, i = [
@@ -10024,16 +10024,16 @@ class ay {
     `;
   }
 }
-function ry(a) {
-  const { inputs: t, backend: e, attrs: n } = a, { images: s, dy: o } = t, { alignCorners: r } = n, c = new ay(o.shape, s.shape, r);
+function rk(a) {
+  const { inputs: t, backend: e, attrs: n } = a, { images: s, dy: o } = t, { alignCorners: r } = n, c = new ak(o.shape, s.shape, r);
   return e.runWebGLProgram(c, [o], o.dtype);
 }
-const iy = {
+const ik = {
   kernelName: Da,
   backendName: "webgl",
-  kernelFunc: ry
+  kernelFunc: rk
 };
-class cy {
+class ck {
   constructor(t, e, n, s, o) {
     this.variableNames = ["A"], this.outputShape = [];
     const [r, c, i, l] = t;
@@ -10071,7 +10071,7 @@ class cy {
     `;
   }
 }
-class ly {
+class lk {
   constructor(t, e, n, s, o) {
     this.variableNames = ["A"], this.packedInputs = !0, this.packedOutput = !0, this.outputShape = [];
     const [r, c, i, l] = t;
@@ -10128,16 +10128,16 @@ class ly {
     `;
   }
 }
-function uy(a) {
-  const { inputs: t, backend: e, attrs: n } = a, { images: s } = t, { alignCorners: o, halfPixelCenters: r, size: c } = n, [i, l] = c, u = _().getBool("WEBGL_PACK_IMAGE_OPERATIONS") ? new ly(s.shape, i, l, o, r) : new cy(s.shape, i, l, o, r);
+function uk(a) {
+  const { inputs: t, backend: e, attrs: n } = a, { images: s } = t, { alignCorners: o, halfPixelCenters: r, size: c } = n, [i, l] = c, u = _().getBool("WEBGL_PACK_IMAGE_OPERATIONS") ? new lk(s.shape, i, l, o, r) : new ck(s.shape, i, l, o, r);
   return e.runWebGLProgram(u, [s], s.dtype);
 }
-const dy = {
+const dk = {
   kernelName: Fa,
   backendName: "webgl",
-  kernelFunc: uy
+  kernelFunc: uk
 };
-class py {
+class pk {
   constructor(t, e, n) {
     this.variableNames = ["dy"], this.outputShape = [], this.outputShape = e;
     const [, s, o] = e, [, r, c] = t, i = [
@@ -10220,16 +10220,16 @@ class py {
     `;
   }
 }
-function hy(a) {
-  const { inputs: t, backend: e, attrs: n } = a, { images: s, dy: o } = t, { alignCorners: r } = n, c = new py(o.shape, s.shape, r);
+function hk(a) {
+  const { inputs: t, backend: e, attrs: n } = a, { images: s, dy: o } = t, { alignCorners: r } = n, c = new pk(o.shape, s.shape, r);
   return e.runWebGLProgram(c, [o], o.dtype);
 }
-const fy = {
+const fk = {
   kernelName: Pa,
   backendName: "webgl",
-  kernelFunc: hy
+  kernelFunc: hk
 };
-class my {
+class mk {
   constructor(t, e) {
     this.variableNames = ["x"];
     const n = t.length;
@@ -10253,14 +10253,14 @@ class my {
     `;
   }
 }
-class gy {
+class gk {
   constructor(t, e) {
     this.variableNames = ["x"], this.packedInputs = !0, this.packedOutput = !0;
     const n = t.length;
     if (n > 4)
       throw new Error(`WebGL backend: Reverse of rank-${n} tensor is not yet supported`);
     this.outputShape = t;
-    const s = ke("rc", n), o = `${s[n - 1]} + 1 < ${this.outputShape[n - 1]}`, r = `${s[n - 2]} + 1 < ${this.outputShape[n - 2]}`, c = he(n);
+    const s = ye("rc", n), o = `${s[n - 1]} + 1 < ${this.outputShape[n - 1]}`, r = `${s[n - 2]} + 1 < ${this.outputShape[n - 2]}`, c = he(n);
     n === 1 ? this.userCode = `
         void main(){
           int rc = getOutputCoords();
@@ -10311,19 +10311,19 @@ class gy {
     }
   }
 }
-function xy(a) {
+function xk(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s } = t, { dims: o } = n, r = s.shape.length, c = ue(o, s.shape);
   if (r === 0)
     return Fe({ inputs: { x: s }, backend: e });
-  const i = _().getBool("WEBGL_PACK_ARRAY_OPERATIONS") ? new gy(s.shape, c) : new my(s.shape, c);
+  const i = _().getBool("WEBGL_PACK_ARRAY_OPERATIONS") ? new gk(s.shape, c) : new mk(s.shape, c);
   return e.runWebGLProgram(i, [s], s.dtype);
 }
-const Cy = {
+const Ck = {
   kernelName: Oa,
   backendName: "webgl",
-  kernelFunc: xy
+  kernelFunc: xk
 };
-class by {
+class bk {
   constructor(t, e) {
     this.variableNames = ["Image"], this.outputShape = [], this.customUniforms = [{ name: "params", type: "vec4" }];
     const n = t[1], s = t[2];
@@ -10351,15 +10351,15 @@ class by {
     `;
   }
 }
-const Iy = {
+const Ik = {
   kernelName: Aa,
   backendName: "webgl",
   kernelFunc: ({ inputs: a, attrs: t, backend: e }) => {
-    const { image: n } = a, { radians: s, fillValue: o, center: r } = t, c = e, i = new by(n.shape, o), [l, u] = Rr(r, n.shape[1], n.shape[2]), p = [[l, u, Math.sin(s), Math.cos(s)]];
+    const { image: n } = a, { radians: s, fillValue: o, center: r } = t, c = e, i = new bk(n.shape, o), [l, u] = Rr(r, n.shape[1], n.shape[2]), p = [[l, u, Math.sin(s), Math.cos(s)]];
     return c.runWebGLProgram(i, [n], n.dtype, p);
   }
 };
-const ky = `
+const yk = `
   // OpenGL ES does not support round function.
   // The algorithm is based on banker's rounding.
   float base = floor(x);
@@ -10374,15 +10374,15 @@ const ky = `
       return base + 1.0;
     }
   }
-`, yy = se({ opSnippet: ky }), $y = {
+`, kk = se({ opSnippet: yk }), $k = {
   kernelName: Qs,
   backendName: "webgl",
-  kernelFunc: yy
+  kernelFunc: kk
 };
-const vy = "return inversesqrt(x);", Sy = se({ opSnippet: vy, cpuKernelImpl: cd }), wy = {
+const vk = "return inversesqrt(x);", Sk = se({ opSnippet: vk, cpuKernelImpl: cd }), wk = {
   kernelName: Oc,
   backendName: "webgl",
-  kernelFunc: Sy
+  kernelFunc: Sk
 };
 class In {
   constructor(t, e, n, s, o, r, c = !0, i = !1) {
@@ -10420,7 +10420,7 @@ class In {
       `;
   }
 }
-class Ny {
+class Nk {
   constructor(t, e, n, s, o, r, c = !0, i = !1) {
     this.variableNames = ["updates", "indices", "defaultValue"], this.packedInputs = !0, this.packedOutput = !0, this.outputShape = r;
     const l = he(o.length), u = he(r.length);
@@ -10473,22 +10473,22 @@ class Ny {
       `;
   }
 }
-function Ry(a) {
+function Rk(a) {
   const { inputs: t, backend: e, attrs: n } = a, { indices: s, updates: o } = t, { shape: r } = n, { sliceRank: c, numUpdates: i, sliceSize: l, strides: u, outputSize: p } = Ct(o, s, r), d = [p / l, l];
   if (p === 0)
     return e.makeTensorInfo(r, s.dtype);
   const h = U({ inputs: { x: s }, backend: e, attrs: { shape: [i, c] } }), f = U({ inputs: { x: o }, backend: e, attrs: { shape: [i, l] } }), m = e.makeTensorInfo([], "float32", new Float32Array([0]));
   let x;
-  _().getBool("WEBGL_PACK") ? x = new Ny(i, c, h.shape.length, f.shape.length, u, d) : x = new In(i, c, h.shape.length, f.shape.length, u, d);
+  _().getBool("WEBGL_PACK") ? x = new Nk(i, c, h.shape.length, f.shape.length, u, d) : x = new In(i, c, h.shape.length, f.shape.length, u, d);
   const g = e.runWebGLProgram(x, [f, h, m], f.dtype), C = U({ inputs: { x: g }, backend: e, attrs: { shape: r } });
   return e.disposeIntermediateTensorInfo(h), e.disposeIntermediateTensorInfo(f), e.disposeIntermediateTensorInfo(g), e.disposeIntermediateTensorInfo(m), C;
 }
-const Ty = {
+const Tk = {
   kernelName: _a,
   backendName: "webgl",
-  kernelFunc: Ry
+  kernelFunc: Rk
 };
-class Ey {
+class Ek {
   constructor(t, e, n, s) {
     this.variableNames = ["sortedSequence", "values"], this.customUniforms = [{ name: "numInputs", type: "int" }], this.outputShape = [t, n];
     const o = "while (left < right) {", r = `for (int i = 0; i < ${Math.ceil(Math.log2(e + 1))}; ++i) { if (left >= right) break;`, c = _().getNumber("WEBGL_VERSION") === 2 ? o : r, i = s === "left" ? "<" : "<=";
@@ -10520,16 +10520,16 @@ class Ey {
      `;
   }
 }
-function Dy(a) {
-  const { inputs: t, backend: e, attrs: n } = a, { sortedSequence: s, values: o } = t, { side: r } = n, c = new Ey(s.shape[0], s.shape[1], o.shape[1], r), i = [[s.shape[1]]];
+function Dk(a) {
+  const { inputs: t, backend: e, attrs: n } = a, { sortedSequence: s, values: o } = t, { side: r } = n, c = new Ek(s.shape[0], s.shape[1], o.shape[1], r), i = [[s.shape[1]]];
   return e.runWebGLProgram(c, [s, o], "int32", i);
 }
-const Fy = {
+const Fk = {
   kernelName: La,
   backendName: "webgl",
-  kernelFunc: Dy
+  kernelFunc: Dk
 };
-class Py {
+class Pk {
   constructor(t, e, n) {
     this.variableNames = ["c", "a", "b"], this.outputShape = e;
     let s, o;
@@ -10557,29 +10557,29 @@ class Py {
     `;
   }
 }
-function Oy(a) {
-  const { inputs: t, backend: e } = a, { condition: n, t: s, e: o } = t, r = new Py(n.shape.length, s.shape, s.shape.length);
+function Ok(a) {
+  const { inputs: t, backend: e } = a, { condition: n, t: s, e: o } = t, r = new Pk(n.shape.length, s.shape, s.shape.length);
   return e.runWebGLProgram(r, [n, s, o], Qe(s.dtype, o.dtype));
 }
-const Ay = {
+const Ak = {
   kernelName: Va,
   backendName: "webgl",
-  kernelFunc: Oy
+  kernelFunc: Ok
 };
-const _y = `
+const _k = `
   // Stable and Attracting Fixed Point (0, 1) for Normalized Weights.
   // see: https://arxiv.org/abs/1706.02515
   float scaleAlpha = ${_r};
   float scale = ${Ar};
   return (x >= 0.0) ? scale * x : scaleAlpha * (exp(x) - 1.0);
-`, Ly = se({ opSnippet: _y }), Vy = {
+`, Lk = se({ opSnippet: _k }), Vk = {
   kernelName: Zs,
   backendName: "webgl",
-  kernelFunc: Ly
+  kernelFunc: Lk
 };
-const Wy = It + `
+const Wk = It + `
   return 1.0 / (1.0 + exp(-1.0 * x));
-`, My = `
+`, Mk = `
   vec4 result = 1.0 / (1.0 + exp(-1.0 * x));
   bvec4 isNaN = isnan(x);
 
@@ -10589,44 +10589,44 @@ const Wy = It + `
   result.a = isNaN.a ? x.a : result.a;
 
   return result;
-`, By = se({
-  opSnippet: Wy,
-  packedOpSnippet: My,
+`, Bk = se({
+  opSnippet: Wk,
+  packedOpSnippet: Mk,
   cpuKernelImpl: ld
-}), Gy = {
+}), Gk = {
   kernelName: Ac,
   backendName: "webgl",
-  kernelFunc: By
+  kernelFunc: Bk
 };
-const zy = `
+const zk = `
   if (isnan(x)) { return 0.0; }
   return sign(x);
-`, Uy = se({ opSnippet: zy }), Hy = {
+`, Uk = se({ opSnippet: zk }), Hk = {
   kernelName: Js,
   backendName: "webgl",
-  kernelFunc: Uy
+  kernelFunc: Uk
 };
-const Xy = It + `
+const Xk = It + `
   return sin(x);
-`, Ky = `
+`, Kk = `
   vec4 result = sin(x);
   bvec4 isNaN = isnan(x);
   ${it}
   return result;
-`, jy = se({ opSnippet: Xy, packedOpSnippet: Ky }), qy = {
+`, jk = se({ opSnippet: Xk, packedOpSnippet: Kk }), qk = {
   kernelName: en,
   backendName: "webgl",
-  kernelFunc: jy
+  kernelFunc: jk
 };
-const Yy = `
+const Yk = `
   float e2x = exp(x);
   return (e2x - 1.0 / e2x) / 2.0;
-`, Qy = se({ opSnippet: Yy }), Zy = {
+`, Qk = se({ opSnippet: Yk }), Zk = {
   kernelName: tn,
   backendName: "webgl",
-  kernelFunc: Qy
+  kernelFunc: Qk
 };
-const Jy = `
+const Jk = `
   float epsilon = 1.1920928955078125e-7;
   float threshold = log(epsilon) + 2.0;
 
@@ -10646,7 +10646,7 @@ const Jy = `
     result = log(exp_x + 1.0);
   }
   return result;
-`, e$ = se({ opSnippet: Jy }), t$ = {
+`, e$ = se({ opSnippet: Jk }), t$ = {
   kernelName: sn,
   backendName: "webgl",
   kernelFunc: e$
@@ -10774,7 +10774,7 @@ function f$(a) {
   return i.map((d) => {
     const h = [...p];
     h[c] = d;
-    const f = kt({ inputs: { x: s }, backend: e, attrs: { begin: u, size: h } });
+    const f = yt({ inputs: { x: s }, backend: e, attrs: { begin: u, size: h } });
     return u[c] += d, f;
   });
 }
@@ -10793,10 +10793,10 @@ const C$ = "return x * x;", b$ = se({ opSnippet: C$ }), I$ = {
   backendName: "webgl",
   kernelFunc: b$
 };
-const so = "return (a - b) * (a - b);", k$ = Ce({ opSnippet: so, packedOpSnippet: so }), y$ = {
+const so = "return (a - b) * (a - b);", y$ = Ce({ opSnippet: so, packedOpSnippet: so }), k$ = {
   kernelName: Lc,
   backendName: "webgl",
-  kernelFunc: k$
+  kernelFunc: y$
 };
 function $$(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s } = t;
@@ -10845,22 +10845,22 @@ class N$ {
 }
 function R$(a) {
   const { inputs: t, backend: e, attrs: n } = a, { x: s } = t, { begin: o, end: r, strides: c, beginMask: i, endMask: l, ellipsisMask: u, newAxisMask: p, shrinkAxisMask: d } = n, { finalShapeSparse: h, finalShape: f, isIdentity: m, sliceDim0: x, isSimpleSlice: g, begin: C, end: I, strides: b } = Lr(s.shape, o, r, c, i, l, u, p, d);
-  let k;
+  let y;
   if (m)
-    k = U({ inputs: { x: s }, backend: e, attrs: { shape: f } });
+    y = U({ inputs: { x: s }, backend: e, attrs: { shape: f } });
   else if (x || g) {
     te(s.shape.length >= 1, () => `Input must have rank at least 1, got: ${s.shape.length}`);
-    const $ = Vr(C, I, b), v = kt({ inputs: { x: s }, backend: e, attrs: { begin: C, size: $ } });
-    k = U({ inputs: { x: v }, backend: e, attrs: { shape: f } }), e.disposeIntermediateTensorInfo(v);
+    const $ = Vr(C, I, b), v = yt({ inputs: { x: s }, backend: e, attrs: { begin: C, size: $ } });
+    y = U({ inputs: { x: v }, backend: e, attrs: { shape: f } }), e.disposeIntermediateTensorInfo(v);
   } else if (e.shouldExecuteOnCPU([s])) {
     const v = e.readSync(s.dataId), w = pe(s.shape, s.dtype, v), S = md(h, w, b, C);
-    k = e.makeTensorInfo(f, s.dtype, S.values);
+    y = e.makeTensorInfo(f, s.dtype, S.values);
   } else {
     const v = new N$(C, b, h);
-    k = e.runWebGLProgram(v, [s], s.dtype);
+    y = e.runWebGLProgram(v, [s], s.dtype);
   }
-  const y = U({ inputs: { x: k }, backend: e, attrs: { shape: f } });
-  return e.disposeIntermediateTensorInfo(k), y;
+  const k = U({ inputs: { x: y }, backend: e, attrs: { shape: f } });
+  return e.disposeIntermediateTensorInfo(y), k;
 }
 const T$ = {
   kernelName: Ka,
@@ -11112,28 +11112,28 @@ function q$(a) {
   d && tt(e, h);
   const g = no(o), C = no(u);
   let I = null;
-  const b = () => I === null ? [x, x] : [x, I], k = (S, E, P) => {
+  const b = () => I === null ? [x, x] : [x, I], y = (S, E, P) => {
     const D = b(), F = new K$(P), T = [[u], [I === null ? 1 : 0], [Number.NEGATIVE_INFINITY], [S], [E]], A = I;
     I = e.runWebGLProgram(F, D, "int32", T), tt(e, A);
   };
   for (let S = 1; S < g; S *= 2) {
     const E = S * 2;
     for (let P = S; P >= 1; P /= 2)
-      k(E, P, [m, C]);
+      y(E, P, [m, C]);
   }
   for (let S = C; S > g; S /= 2) {
     const E = b(), P = new j$([m, S / 2]), F = [[u], [I === null ? 1 : 0], [g]], R = I;
     I = e.runWebGLProgram(P, E, "int32", F), tt(e, R);
     const T = g / 2, A = T * 2;
     for (let N = T; N >= 1; N /= 2)
-      k(A, N, I.shape);
+      y(A, N, I.shape);
   }
-  let y = I;
-  I = kt({ inputs: { x: I }, backend: e, attrs: { begin: 0, size: [m, o] } }), tt(e, y);
+  let k = I;
+  I = yt({ inputs: { x: I }, backend: e, attrs: { begin: 0, size: [m, o] } }), tt(e, k);
   let $ = Oi({ inputs: { x, indices: I }, backend: e, attrs: { axis: 1, batchDims: 1 } });
   tt(e, x);
   const v = l.slice(0, -1);
-  v.push(o), y = I, I = U({ inputs: { x: I }, attrs: { shape: v }, backend: e }), tt(e, y);
+  v.push(o), k = I, I = U({ inputs: { x: I }, attrs: { shape: v }, backend: e }), tt(e, k);
   const w = $;
   return $ = U({ inputs: { x: $ }, attrs: { shape: v }, backend: e }), tt(e, w), [$, I];
 }
@@ -11296,7 +11296,7 @@ const J$ = {
 function ev(a) {
   const { inputs: t, attrs: e, backend: n } = a, { axis: s } = e, { x: o } = t;
   At(o, "unique"), console.warn("WARNING: ", "UI might be locked temporarily as data is being downloaded");
-  const r = n.readSync(o.dataId), { outputValues: c, outputShape: i, indices: l } = kd(r, s, o.shape, o.dtype);
+  const r = n.readSync(o.dataId), { outputValues: c, outputShape: i, indices: l } = yd(r, s, o.shape, o.dtype);
   return [
     n.makeTensorInfo(i, o.dtype, c),
     n.makeTensorInfo([l.length], "int32", l)
@@ -11320,7 +11320,7 @@ function sv(a) {
   const f = new Array(i);
   for (let m = 0; m < f.length; m++) {
     d[o] = m;
-    const x = kt({ inputs: { x: r }, backend: e, attrs: { begin: d, size: h } }), g = U({ inputs: { x }, backend: e, attrs: { shape: l } });
+    const x = yt({ inputs: { x: r }, backend: e, attrs: { begin: d, size: h } }), g = U({ inputs: { x }, backend: e, attrs: { shape: l } });
     f[m] = g, p.push(x);
   }
   return p.forEach((m) => e.disposeIntermediateTensorInfo(m)), f;
@@ -11456,8 +11456,8 @@ function av(a) {
   u != null && (p = Ie({ inputs: { x: s }, backend: e, attrs: { perm: u } }), i.push(p), l = xe(1, c)[0]);
   const d = Ql(p.shape, l, r), h = G([p.shape[l]]), f = U({ inputs: { x: p }, backend: e, attrs: { shape: [-1, h] } });
   i.push(f);
-  const m = cr(s.dtype), x = (b, k, y, $, v) => {
-    const w = b.shape[0], S = b.shape[1], E = Zl(S, v), P = { windowSize: E, inSize: S, batchSize: w, numSegments: v }, D = new ov(P, k), F = e.compileAndRun(D, [b, y], $);
+  const m = cr(s.dtype), x = (b, y, k, $, v) => {
+    const w = b.shape[0], S = b.shape[1], E = Zl(S, v), P = { windowSize: E, inSize: S, batchSize: w, numSegments: v }, D = new ov(P, y), F = e.compileAndRun(D, [b, k], $);
     if (i.push(F), F.shape[1] === v)
       return F;
     const R = Wi({
@@ -11468,7 +11468,7 @@ function av(a) {
       backend: e,
       attrs: { reps: [S / E] }
     });
-    return i.push(R), i.push(T), x(F, k, T, $, v);
+    return i.push(R), i.push(T), x(F, y, T, $, v);
   }, g = x(f, "unsortedSegmentSum", o, m, r), C = U({ inputs: { x: g }, backend: e, attrs: { shape: d } });
   let I = C;
   if (u != null) {
@@ -11494,7 +11494,7 @@ const iv = [
   pC,
   gC,
   CC,
-  kC,
+  yC,
   vC,
   NC,
   DC,
@@ -11529,7 +11529,7 @@ const iv = [
   p1,
   m1,
   x1,
-  k1,
+  y1,
   $1,
   w1,
   T1,
@@ -11549,7 +11549,7 @@ const iv = [
   h0,
   g0,
   C0,
-  k0,
+  y0,
   v0,
   R0,
   F0,
@@ -11568,7 +11568,7 @@ const iv = [
   uI,
   hI,
   xI,
-  kI,
+  yI,
   vI,
   Dd,
   RI,
@@ -11581,49 +11581,49 @@ const iv = [
   UI,
   jI,
   ZI,
-  sk,
-  ik,
-  Xx,
-  dk,
-  fk,
-  xk,
-  Ik,
-  hb,
-  $k,
-  Sk,
-  Nk,
-  Ek,
-  Ok,
-  wd,
-  _k,
-  Vk,
-  Mk,
-  Gk,
-  zk,
-  fb,
-  Fd,
-  Xk,
-  Yk,
-  ey,
-  Rd,
-  oy,
+  sy,
   iy,
+  Xx,
   dy,
   fy,
-  Cy,
+  xy,
   Iy,
+  hb,
   $y,
-  wy,
-  Ty,
-  Fy,
-  Ay,
+  Sy,
+  Ny,
+  Ey,
+  Oy,
+  wd,
+  _y,
   Vy,
+  My,
   Gy,
-  Hy,
-  qy,
-  Zy,
+  zy,
+  fb,
+  Fd,
+  Xy,
+  Yy,
+  ek,
+  Rd,
+  ok,
+  ik,
+  dk,
+  fk,
+  Ck,
+  Ik,
+  $k,
+  wk,
+  Tk,
+  Fk,
+  Ak,
+  Vk,
+  Gk,
+  Hk,
+  qk,
+  Zk,
   tb,
-  ak,
+  ay,
   t$,
   n$,
   a$,
@@ -11634,14 +11634,14 @@ const iv = [
   m$,
   x$,
   I$,
-  y$,
+  k$,
   v$,
   w$,
   T$,
   D$,
   P$,
   A$,
-  ok,
+  oy,
   Pd,
   V$,
   B$,
@@ -11653,7 +11653,7 @@ const iv = [
   tv,
   nv,
   rv,
-  vk
+  vy
 ];
 for (const a of iv)
   or(a);
@@ -11729,20 +11729,20 @@ class FS extends Ui {
       ), C = c ? this.model.config.blockSize - g.shape[1] : 0, I = C > 0 ? Md(g, [
         [0, 0],
         [0, C]
-      ]) : g, b = this.model.forward(i, I), k = b.shape[1] - 1 - C, y = b.slice([0, k, 0], [b.shape[0], 1, b.shape[2]]);
+      ]) : g, b = this.model.forward(i, I), y = b.shape[1] - 1 - C, k = b.slice([0, y, 0], [b.shape[0], 1, b.shape[2]]);
       let $;
       if (n?.targets) {
         const w = n.targets.shift();
         if (w !== void 0) {
-          const S = Kt([[w]], [1, 1], "int32"), E = Ld(y, S);
+          const S = Kt([[w]], [1, 1], "int32"), E = Ld(k, S);
           $ = E.mean(), S.dispose(), E.dispose();
         }
       }
       return i.attentionScores?.attentionOut && i.attentionScores.attentionOut.forEach((w, S) => {
         w.shape[1] !== 1 && (i.attentionScores.attentionOut[S] = Wc(
-          w.slice([0, k, 0], [w.shape[0], 1, w.shape[2]])
+          w.slice([0, y, 0], [w.shape[0], 1, w.shape[2]])
         ), w.dispose());
-      }), b.dispose(), [y.div(s).squeeze([1]), $];
+      }), b.dispose(), [k.div(s).squeeze([1]), $];
     });
     let p, d;
     if (r) {
@@ -11761,18 +11761,18 @@ class FS extends Ui {
       const x = (n?.embeddings === "all" ? i.embeddings : i.embeddings.filter((C) => C.name.startsWith("block_output_"))).map(async (C) => {
         const I = C.tensor.shape[1], b = C.tensor.slice([0, I - 1, 0], [C.tensor.shape[0], 1, C.tensor.shape[2]]);
         C.tensor.dispose();
-        const k = b.squeeze([1]);
+        const y = b.squeeze([1]);
         if (b.dispose(), n?.embeddings === "softmax") {
-          const y = this.model.project(k);
-          k.dispose();
-          const $ = gs(y, -1);
-          return y.dispose(), { name: C.name, tensor: await $.array() };
+          const k = this.model.project(y);
+          y.dispose();
+          const $ = gs(k, -1);
+          return k.dispose(), { name: C.name, tensor: await $.array() };
         } else if (n?.embeddings === "logits") {
-          const y = this.model.project(k);
-          return k.dispose(), { name: C.name, tensor: await y.array() };
+          const k = this.model.project(y);
+          return y.dispose(), { name: C.name, tensor: await k.array() };
         } else {
-          const y = await k.array();
-          return k.dispose(), { name: C.name, tensor: y };
+          const k = await y.array();
+          return y.dispose(), { name: C.name, tensor: k };
         }
       }), g = await Promise.all(x);
       this.embeddingsData.push(g);
@@ -11830,7 +11830,7 @@ class FS extends Ui {
     this.reset();
   }
   initialise(t, e) {
-    if (this.cache && e?.noCache && this.reset(), this.initialPrompt = t || null, this.lastToken === -1 ? (this.outputConversation = (this.initialPrompt || []).slice(), console.log("Setting conversation in generator.", t)) : t && t.length > this.outputConversation.length && (this.outputConversation = (this.initialPrompt || []).slice(), this.resetCache()), !this.cache && !e?.noCache && this.model.config.useRope) {
+    if (this.cache && e?.noCache && this.reset(), this.initialPrompt = t || null, this.lastToken === -1 ? (this.outputConversation = (this.initialPrompt || []).slice(), console.log("Setting conversation in generator.", t)) : t && t.length > this.outputConversation.length && (this.outputConversation = (this.initialPrompt || []).slice(), this.resetCache()), !this.cache && !e?.noCache && (this.model.config.modelType !== "GenAI_NanoGPT_v1" || this.model.config.useRope)) {
       const s = new Array(this.model.config.nLayer);
       for (let o = 0; o < this.model.config.nLayer; o++)
         s[o] = { k: void 0, v: void 0, length: 0, cumulativeLength: 0 };