import { o as u, n as h, E as d, c7 as st, c8 as rt, c9 as nt, ca as et, cb as it, cc as pt, z as B, cd as at, ce as ht, bY as ut, v as D, cf as ct, cg as ft, d as H, a3 as C, bZ as lt, ch as dt, ci as mt, cj as Dt, aE as yt, ck as It, a2 as wt, m as M, _ as F, cl as xt, cm as gt, J as $, c1 as $t, cn as bt, co as vt, cp as kt, cq as Nt, b as _t, cr as Tt, cs as Et, ct as St, cu as qt, cv as r, a_ as Kt, h as zt, ag as W, cw as Pt, cx as Ct, p as Mt, i as Ot, j as At, a1 as Bt } from "./index-DSGwv2Yx.js";
import { e as j, a as R, l as X, b as G, d as V, f as Z, m as J, r as E, g as Ht, h as Ft, i as Wt, j as jt, k as Rt, n as Xt, o as Gt, c as Vt, p as Zt, q as Jt, t as Ut, u as Yt, v as Qt, w as Lt, x as to, y as oo, z as so, A as ro, B as no, C as eo, s as io, D as po, E as ao, F as ho } from "./unsorted_segment_sum-BfFVV9Zm.js";
import { r as l } from "./reshape-BIN71H3p.js";
import { b as uo } from "./broadcast_to-C_EJTVTZ.js";
import { c as co } from "./clip_by_value-CLAD4h_I.js";
import { c as _ } from "./concat-Dqk7Xk7h.js";
import { w as U, e as fo, l as lo, b as mo, m as Do, a as yo, n as Io } from "./not_equal-CkQKkKZy.js";
import { m as k } from "./mat_mul-DP86qZtZ.js";
import { s as Y, k as wo, h as xo, e as go, l as $o, p as bo, r as vo, a as ko } from "./step-DQY6_ABw.js";
import { n as Q, b as S, c as No, g as _o, l as To, a as Eo, d as So, h as qo, m as Ko, f as zo, e as Po, r as Co, s as Mo, u as Oo } from "./resize_nearest_neighbor-C6_0dAnK.js";
import { e as Ao } from "./expand_dims-D0rBtgT1.js";
import { f as Bo } from "./floor-CymuCmTO.js";
import { g as Ho } from "./gather-DEyjXNb1.js";
import { c as q } from "./complex-3DpPEG9B.js";
import { n as N, r as K, i as L, t as Fo } from "./transpose-Qxz-4os3.js";
import { s as T } from "./slice-BvItlgXu.js";
import { m as Wo } from "./mod-BXjLYwvM.js";
import { r as jo } from "./relu-DTvZKBsZ.js";
import { s as z } from "./split-BN9LkEgS.js";
import { z as Ro } from "./zeros-Bw0puq_w.js";
import { s as Xo } from "./softmax-BLGJqdwx.js";
import { s as Go } from "./squeeze-O_YWJpw_.js";
import { s as Vo } from "./stack-z6QE7kmP.js";
import { s as Zo } from "./sum-D39FeU5h.js";
import { t as Jo } from "./tile-CsWlVKKz.js";
function Uo(t) {
  const s = { x: h(t, "x", "acos") };
  return d.runKernel(st, s);
}
const Yo = /* @__PURE__ */ u({ acos_: Uo });
function Qo(t) {
  const s = { x: h(t, "x", "acosh") };
  return d.runKernel(rt, s);
}
const Lo = /* @__PURE__ */ u({ acosh_: Qo });
function ts(t, o = 0) {
  const n = { x: h(t, "x", "argMin") }, e = { axis: o };
  return d.runKernel(nt, n, e);
}
const os = /* @__PURE__ */ u({ argMin_: ts });
function ss(t) {
  const s = { x: h(t, "x", "asin") };
  return d.runKernel(et, s);
}
const rs = /* @__PURE__ */ u({ asin_: ss });
function ns(t) {
  const s = { x: h(t, "x", "asinh") };
  return d.runKernel(it, s);
}
const es = /* @__PURE__ */ u({ asinh_: ns });
function is(t) {
  const s = { x: h(t, "x", "atan") };
  return d.runKernel(pt, s);
}
const ps = /* @__PURE__ */ u({ atan_: is });
function as(t, o) {
  let s = h(t, "a", "atan2"), n = h(o, "b", "atan2");
  [s, n] = B(s, n);
  const e = { a: s, b: n };
  return d.runKernel(at, e);
}
const hs = /* @__PURE__ */ u({ atan2_: as });
function us(t) {
  const s = { x: h(t, "x", "atanh") };
  return d.runKernel(ht, s);
}
const cs = /* @__PURE__ */ u({ atanh_: us });
function fs(t) {
  const s = { x: h(t, "x", "ceil", "float32") };
  return d.runKernel(ut, s);
}
const ls = /* @__PURE__ */ u({ ceil_: fs });
function ds(t, o, s = "NHWC") {
  const n = h(t, "x", "depthToSpace", "float32"), e = s === "NHWC" ? n.shape[1] : n.shape[2], i = s === "NHWC" ? n.shape[2] : n.shape[3], p = s === "NHWC" ? n.shape[3] : n.shape[1];
  D(o > 1, () => `blockSize should be > 1 for depthToSpace, but was: ${o}`), D(e * o >= 0, () => `Negative dimension size caused by overflow when multiplying
    ${e} and ${o}  for depthToSpace with input shape
    ${n.shape}`), D(i * o >= 0, () => `Negative dimension size caused by overflow when multiplying
    ${i} and ${o} for depthToSpace with input shape
        ${n.shape}`), D(p % (o * o) === 0, () => `Dimension size must be evenly divisible by ${o * o} but is ${p} for depthToSpace with input shape ${n.shape}`);
  const a = { x: n }, f = { blockSize: o, dataFormat: s };
  return d.runKernel(ct, a, f);
}
const ms = /* @__PURE__ */ u({ depthToSpace_: ds });
function Ds(t, o, s, n, e = [1, 1], i = "NHWC") {
  const p = h(t, "x", "dilation2d"), a = h(o, "filter", "dilation2d");
  D(p.rank === 3 || p.rank === 4, () => `Error in dilation2d: input must be rank 3 or 4, but got rank ${p.rank}.`), D(a.rank === 3, () => `Error in dilation2d: filter must be rank 3, but got rank ${a.rank}.`), D(i === "NHWC", () => `Error in dilation2d: Only NHWC is currently supported, but got dataFormat of ${i}`);
  let f = p, y = !1;
  p.rank === 3 && (f = l(p, [1, p.shape[0], p.shape[1], p.shape[2]]), y = !0), D(f.shape[3] === a.shape[2], () => `Error in dilation2d:  input and filter must have the same depth: ${f.shape[3]} vs ${a.shape[2]}`);
  const c = { x: f, filter: a }, m = { strides: s, pad: n, dilations: e }, I = d.runKernel(ft, c, m);
  return y ? l(I, [I.shape[1], I.shape[2], I.shape[3]]) : I;
}
const ys = /* @__PURE__ */ u({ dilation2d_: Ds });
function Is(t, o) {
  let s = h(t, "a", "div"), n = h(o, "b", "div");
  [s, n] = B(s, n);
  const e = H(s, n), i = C(e), p = j(n, i);
  return U(p, i, e);
}
const ws = /* @__PURE__ */ u({ divNoNan_: Is });
function xs(t, o) {
  const s = h(t, "t1", "dot"), n = h(o, "t2", "dot");
  D((s.rank === 1 || s.rank === 2) && (n.rank === 1 || n.rank === 2), () => `Error in dot: inputs must all be rank 1 or 2, but got ranks ${s.rank} and ${n.rank}.`);
  const e = s.rank === 1 ? s.size : s.shape[1], i = n.rank === 1 ? n.size : n.shape[0];
  if (D(e === i, () => `Error in dot: inner dimensions of inputs must match, but got ${e} and ${i}.`), s.rank === 1 && n.rank === 1) {
    const p = l(s, [1, -1]), a = l(n, [-1, 1]), f = k(p, a);
    return l(f, []);
  } else if (s.rank === 1 && n.rank === 2) {
    const p = l(s, [1, -1]), a = l(n, [n.shape[0], n.shape[1]]), f = k(p, a);
    return l(f, [f.size]);
  } else if (s.rank === 2 && n.rank === 1) {
    const p = l(n, [-1, 1]), a = k(s, p);
    return l(a, [a.size]);
  } else {
    const p = l(n, [n.shape[0], n.shape[1]]);
    return k(s, p);
  }
}
const gs = /* @__PURE__ */ u({ dot_: xs });
function $s(t, o = null, s = !1) {
  return Q(t, "euclidean", o, s);
}
const bs = /* @__PURE__ */ u({ euclideanNorm_: $s });
function vs(t) {
  const s = { x: h(t, "x", "expm1") };
  return d.runKernel(lt, s);
}
const ks = /* @__PURE__ */ u({ expm1_: vs });
function Ns(t) {
  const s = { x: h(t, "x", "isFinite") };
  return d.runKernel(dt, s);
}
const _s = /* @__PURE__ */ u({ isFinite_: Ns });
function Ts(t) {
  const s = { x: h(t, "x", "isInf") };
  return d.runKernel(mt, s);
}
const Es = /* @__PURE__ */ u({ isInf_: Ts });
function Ss(t) {
  const s = { x: h(t, "x", "isNaN") };
  return d.runKernel(Dt, s);
}
const qs = /* @__PURE__ */ u({ isNaN_: Ss });
function Ks(t, o = 5, s = 1, n = 1, e = 0.5) {
  const i = h(t, "x", "localResponseNormalization");
  D(i.rank === 4 || i.rank === 3, () => `Error in localResponseNormalization: x must be rank 3 or 4 but got
               rank ${i.rank}.`), D(yt(o), () => `Error in localResponseNormalization: depthRadius must be an integer but got depthRadius ${o}.`);
  let p = i, a = !1;
  i.rank === 3 && (a = !0, p = l(i, [1, i.shape[0], i.shape[1], i.shape[2]]));
  const f = { x: p }, y = { depthRadius: o, bias: s, alpha: n, beta: e }, c = d.runKernel(It, f, y);
  return a ? l(c, [c.shape[1], c.shape[2], c.shape[3]]) : c;
}
const zs = /* @__PURE__ */ u({ localResponseNormalization_: Ks });
function Ps(t) {
  const o = h(t, "x", "logSigmoid");
  return wt((n) => ({ value: N(R(N(n))), gradFunc: (p) => M(p, Y(N(n))) }))(o);
}
const Cs = /* @__PURE__ */ u({ logSigmoid_: Ps });
function Ms(t, o) {
  const s = h(t, "a", "logicalOr", "bool"), n = h(o, "b", "logicalOr", "bool");
  F(s.shape, n.shape);
  const e = { a: s, b: n };
  return d.runKernel(xt, e);
}
const tt = /* @__PURE__ */ u({ logicalOr_: Ms });
function Os(t, o) {
  const s = h(t, "a", "logicalXor", "bool"), n = h(o, "b", "logicalXor", "bool");
  return F(s.shape, n.shape), S(tt(t, o), X(S(t, o)));
}
const As = /* @__PURE__ */ u({ logicalXor_: Os });
function Bs(t, o, s) {
  D(s === "reflect" || s === "symmetric", () => `Invalid mode. Mode must be either reflect or symmetric. Got ${s}.`);
  const n = h(t, "x", "mirrorPad");
  if (n.rank === 0)
    throw new Error("mirrorPad(scalar) is not defined. Pass non-scalar to mirrorPad");
  D(o.length === n.rank, () => `Padding doesn't match input. Must be ${n.rank}. Got ${o.length}.`);
  const e = s === "reflect" ? 1 : 0;
  for (let a = 0; a < n.rank; a++)
    D(o[a].length === 2, () => "Invalid number of paddings. Must be length of 2 each."), D(o[a][0] >= 0 && o[a][0] <= n.shape[a] - e && o[a][1] >= 0 && o[a][1] <= n.shape[a] - e, () => `Padding in dimension ${a} cannot be greater than or equal to ${n.shape[a] - e} or less than 0 for input of shape ${n.shape}`);
  const i = { paddings: o, mode: s }, p = { x: n };
  return d.runKernel(gt, p, i);
}
const Hs = /* @__PURE__ */ u({ mirrorPad_: Bs });
function Fs(t, o, s, n, e, i, p) {
  e == null && (e = [1, 1]), i == null && (i = 1), n === 0 && (n = "valid");
  const a = h(t, "x", "maxPool");
  let f = a, y = !1;
  a.rank === 3 && (y = !0, f = l(a, [1, a.shape[0], a.shape[1], a.shape[2]])), D(wo(i, e), () => `Error in pool: Either strides or dilations must be 1. Got strides ${i} and dilations '${e}'`);
  const c = xo(f.shape, o, i, e, n), m = [c.dilationHeight, c.dilationWidth];
  let I;
  n === "same" ? I = js([c.filterHeight, c.filterWidth], m) : I = [[0, 0], [0, 0]];
  const w = m[0] === 1 && m[1] === 1, [x, g] = Ws([c.inHeight, c.inWidth], m, I), b = w ? n : "valid", O = w ? f : G(f, m, x), A = (s === "avg" ? () => Z(O, o, i, b, p) : () => J(O, o, i, b, p))(), v = w ? A : V(A, m, g);
  return y ? l(v, [v.shape[1], v.shape[2], v.shape[3]]) : v;
}
function Ws(t, o, s) {
  const n = s.map((c) => c[0]), e = s.map((c) => c[1]), i = t.concat(n, e), p = o.map((c, m) => (c - i[m] % c) % c), a = e.map((c, m) => c + p[m]), f = o.map((c, m) => [n[m], a[m]]), y = o.map((c, m) => [0, p[m]]);
  return [f, y];
}
function js(t, o) {
  const n = t.map((p, a) => p + (p - 1) * (o[a] - 1)).map((p) => p - 1), e = n.map((p) => Math.floor(p / 2)), i = n.map((p, a) => p - e[a]);
  return n.map((p, a) => [e[a], i[a]]);
}
const Rs = /* @__PURE__ */ u({ pool_: Fs });
function Xs(t, o = null, s = !1) {
  let n = h(t, "x", "prod");
  n.dtype === "bool" && (n = $(n, "int32"));
  const e = { x: n }, i = { axis: o, keepDims: s };
  return d.runKernel($t, e, i);
}
const Gs = /* @__PURE__ */ u({ prod_: Xs });
function Vs(t) {
  const s = { x: h(t, "x", "reciprocal") };
  return d.runKernel(bt, s);
}
const Zs = /* @__PURE__ */ u({ reciprocal_: Vs });
function Js(t) {
  const s = { x: h(t, "x", "sign") };
  return d.runKernel(vt, s);
}
const Us = /* @__PURE__ */ u({ sign_: Js });
function Ys(t) {
  D(t.dtype === "complex64", () => `The dtype for tf.spectral.fft() must be complex64 but got ${t.dtype}.`);
  const o = { input: t };
  return d.runKernel(kt, o);
}
const ot = /* @__PURE__ */ u({ fft_: Ys });
function Qs(t) {
  D(t.dtype === "complex64", () => `The dtype for tf.spectral.ifft() must be complex64 but got ${t.dtype}.`);
  const o = { input: t };
  return d.runKernel(Nt, o);
}
const P = /* @__PURE__ */ u({ ifft_: Qs });
function Ls(t) {
  const o = t.shape[t.shape.length - 1], s = t.size / o;
  let n;
  if (o <= 2) {
    const e = l(t, [s, o]);
    n = P(e);
  } else {
    const e = [s, 2 * (o - 1)], i = l(K(t), [s, o]), p = l(L(t), [s, o]), a = E(T(i, [0, 1], [s, o - 2]), 1), f = M(E(T(p, [0, 1], [s, o - 2]), 1), _t(-1)), y = _([i, a], 1), c = _([p, f], 1), m = l(q(y, c), [e[0], e[1]]);
    n = P(m);
  }
  if (n = K(n), t.rank === 3 && t.shape[0] !== 0) {
    const e = n, i = t.shape[0];
    n = l(n, [i, n.shape[0] / i, n.shape[1]]), e.dispose();
  }
  return n;
}
const tr = /* @__PURE__ */ u({ irfft_: Ls });
function or(t, o) {
  D(t.dtype === "float32", () => `The dtype for rfft() must be real value but got ${t.dtype}`);
  let s = t.shape[t.shape.length - 1];
  const n = t.size / s;
  let e;
  if (o != null && o < s) {
    const x = t.shape.map((b) => 0), g = t.shape.map((b) => b);
    g[t.shape.length - 1] = o, e = T(t, x, g), s = o;
  } else if (o != null && o > s) {
    const x = t.shape.map((g) => g);
    x[t.shape.length - 1] = o - s, e = _([t, Ro(x)], t.shape.length - 1), s = o;
  } else
    e = t;
  const i = C(e), p = l(q(e, i), [n, s]), a = ot(p), f = Math.floor(s / 2) + 1, y = K(a), c = L(a), m = z(y, [f, s - f], y.shape.length - 1), I = z(c, [f, s - f], c.shape.length - 1), w = e.shape.slice();
  return w[e.shape.length - 1] = f, l(q(m[0], I[0]), w);
}
const sr = /* @__PURE__ */ u({ rfft_: or });
function rr(t, o, s, n, e = 0, i = 0, p = 0, a = 0, f = 0) {
  const c = { x: h(t, "x", "stridedSlice", "string_or_numeric") }, m = {
    begin: o,
    end: s,
    strides: n,
    beginMask: e,
    endMask: i,
    ellipsisMask: p,
    newAxisMask: a,
    shrinkAxisMask: f
  };
  return d.runKernel(Tt, c, m);
}
const nr = /* @__PURE__ */ u({ stridedSlice_: rr });
function er(t) {
  const s = { x: h(t, "x", "tan", "float32") };
  return d.runKernel(Et, s);
}
const ir = /* @__PURE__ */ u({ tan_: er });
function pr(t, o = 1, s = !0) {
  const n = h(t, "x", "topk");
  if (n.rank === 0)
    throw new Error("topk() expects the input to be of rank 1 or higher");
  const e = n.shape[n.shape.length - 1];
  if (o < 0)
    throw new Error(`'k' passed to topk() must be >= 0 but got ${o}`);
  if (o > e)
    throw new Error(`'k' passed to topk() must be <= the last dimension (${e}) but got ${o}`);
  const i = { x: n }, p = { k: o, sorted: s }, [a, f] = d.runKernel(St, i, p);
  return { values: a, indices: f };
}
const ar = /* @__PURE__ */ u({ topk_: pr });
function hr(t, o = 0) {
  const s = h(t, "x", "unique", "string_or_numeric");
  D(s.rank > 0, () => "The input tensor must be at least 1D");
  const n = { x: s }, e = { axis: o }, [i, p] = d.runKernel(qt, n, e);
  return { values: i, indices: p };
}
const ur = /* @__PURE__ */ u({ unique_: hr });
r().prototype.abs = function() {
  return this.throwIfDisposed(), Kt(this);
};
r().prototype.acos = function() {
  return this.throwIfDisposed(), Yo(this);
};
r().prototype.acosh = function() {
  return this.throwIfDisposed(), Lo(this);
};
r().prototype.add = function(t) {
  return this.throwIfDisposed(), zt(this, t);
};
r().prototype.all = function(t, o) {
  return this.throwIfDisposed(), Ht(this, t, o);
};
r().prototype.any = function(t, o) {
  return this.throwIfDisposed(), Ft(this, t, o);
};
r().prototype.argMax = function(t) {
  return this.throwIfDisposed(), Wt(this, t);
};
r().prototype.argMin = function(t) {
  return this.throwIfDisposed(), os(this, t);
};
r().prototype.asScalar = function() {
  return this.throwIfDisposed(), D(this.size === 1, () => "The array must have only 1 element."), l(this, []);
};
r().prototype.asType = function(t) {
  return this.throwIfDisposed(), $(this, t);
};
r().prototype.as1D = function() {
  return this.throwIfDisposed(), l(this, [this.size]);
};
r().prototype.as2D = function(t, o) {
  return this.throwIfDisposed(), l(this, [t, o]);
};
r().prototype.as3D = function(t, o, s) {
  return this.throwIfDisposed(), l(this, [t, o, s]);
};
r().prototype.as4D = function(t, o, s, n) {
  return this.throwIfDisposed(), l(this, [t, o, s, n]);
};
r().prototype.as5D = function(t, o, s, n, e) {
  return this.throwIfDisposed(), l(this, [t, o, s, n, e]);
};
r().prototype.asin = function() {
  return this.throwIfDisposed(), rs(this);
};
r().prototype.asinh = function() {
  return this.throwIfDisposed(), es(this);
};
r().prototype.atan = function() {
  return this.throwIfDisposed(), ps(this);
};
r().prototype.atan2 = function(t) {
  return this.throwIfDisposed(), hs(this, t);
};
r().prototype.atanh = function() {
  return this.throwIfDisposed(), cs(this);
};
r().prototype.avgPool = function(t, o, s, n) {
  return this.throwIfDisposed(), Z(this, t, o, s, n);
};
r().prototype.batchToSpaceND = function(t, o) {
  return this.throwIfDisposed(), V(this, t, o);
};
r().prototype.batchNorm = function(t, o, s, n, e) {
  return this.throwIfDisposed(), jt(this, t, o, s, n, e);
};
r().prototype.broadcastTo = function(t) {
  return this.throwIfDisposed(), uo(this, t);
};
r().prototype.cast = function(t) {
  return this.throwIfDisposed(), $(this, t);
};
r().prototype.ceil = function() {
  return this.throwIfDisposed(), ls(this);
};
r().prototype.clipByValue = function(t, o) {
  return this.throwIfDisposed(), co(this, t, o);
};
r().prototype.concat = function(t, o) {
  return this.throwIfDisposed(), t instanceof W && (t = [t]), _([this, ...t], o);
};
r().prototype.conv1d = function(t, o, s, n, e, i) {
  return this.throwIfDisposed(), Rt(this, t, o, s, n, e, i);
};
r().prototype.conv2dTranspose = function(t, o, s, n, e) {
  return this.throwIfDisposed(), Xt(this, t, o, s, n, e);
};
r().prototype.conv2d = function(t, o, s, n, e, i) {
  return this.throwIfDisposed(), Gt(this, t, o, s, n, e, i);
};
r().prototype.cos = function() {
  return this.throwIfDisposed(), Vt(this);
};
r().prototype.cosh = function() {
  return this.throwIfDisposed(), Zt(this);
};
r().prototype.cumprod = function(t, o, s) {
  return this.throwIfDisposed(), Jt(this, t, o, s);
};
r().prototype.cumsum = function(t, o, s) {
  return this.throwIfDisposed(), Ut(this, t, o, s);
};
r().prototype.depthToSpace = function(t, o) {
  return this.throwIfDisposed(), ms(this, t, o);
};
r().prototype.depthwiseConv2d = function(t, o, s, n, e, i) {
  return this.throwIfDisposed(), Yt(this, t, o, s, n, e, i);
};
r().prototype.dilation2d = function(t, o, s, n, e) {
  return this.throwIfDisposed(), ys(this, t, o, s, n, e);
};
r().prototype.divNoNan = function(t) {
  return this.throwIfDisposed(), ws(this, t);
};
r().prototype.div = function(t) {
  return this.throwIfDisposed(), H(this, t);
};
r().prototype.dot = function(t) {
  return this.throwIfDisposed(), gs(this, t);
};
r().prototype.elu = function() {
  return this.throwIfDisposed(), go(this);
};
r().prototype.equal = function(t) {
  return this.throwIfDisposed(), j(this, t);
};
r().prototype.erf = function() {
  return this.throwIfDisposed(), Qt(this);
};
r().prototype.euclideanNorm = function(t, o) {
  return this.throwIfDisposed(), bs(this, t, o);
};
r().prototype.exp = function() {
  return this.throwIfDisposed(), fo(this);
};
r().prototype.expandDims = function(t) {
  return this.throwIfDisposed(), Ao(this, t);
};
r().prototype.expm1 = function() {
  return this.throwIfDisposed(), ks(this);
};
r().prototype.fft = function() {
  return this.throwIfDisposed(), ot(this);
};
r().prototype.flatten = function() {
  return this.throwIfDisposed(), l(this, [this.size]);
};
r().prototype.floor = function() {
  return this.throwIfDisposed(), Bo(this);
};
r().prototype.floorDiv = function(t) {
  return this.throwIfDisposed(), Pt(this, t);
};
r().prototype.gather = function(t, o, s) {
  return this.throwIfDisposed(), Ho(this, t, o, s);
};
r().prototype.greaterEqual = function(t) {
  return this.throwIfDisposed(), No(this, t);
};
r().prototype.greater = function(t) {
  return this.throwIfDisposed(), _o(this, t);
};
r().prototype.ifft = function() {
  return this.throwIfDisposed(), P(this);
};
r().prototype.irfft = function() {
  return this.throwIfDisposed(), tr(this);
};
r().prototype.isFinite = function() {
  return this.throwIfDisposed(), _s(this);
};
r().prototype.isInf = function() {
  return this.throwIfDisposed(), Es(this);
};
r().prototype.isNaN = function() {
  return this.throwIfDisposed(), qs(this);
};
r().prototype.leakyRelu = function(t) {
  return this.throwIfDisposed(), $o(this, t);
};
r().prototype.lessEqual = function(t) {
  return this.throwIfDisposed(), To(this, t);
};
r().prototype.less = function(t) {
  return this.throwIfDisposed(), Eo(this, t);
};
r().prototype.localResponseNormalization = function(t, o, s, n) {
  return this.throwIfDisposed(), zs(this, t, o, s, n);
};
r().prototype.logSigmoid = function() {
  return this.throwIfDisposed(), Cs(this);
};
r().prototype.logSoftmax = function(t) {
  return this.throwIfDisposed(), Lt(this, t);
};
r().prototype.logSumExp = function(t, o) {
  return this.throwIfDisposed(), lo(this, t, o);
};
r().prototype.log = function() {
  return this.throwIfDisposed(), mo(this);
};
r().prototype.log1p = function() {
  return this.throwIfDisposed(), So(this);
};
r().prototype.logicalAnd = function(t) {
  return this.throwIfDisposed(), S(this, t);
};
r().prototype.logicalNot = function() {
  return this.throwIfDisposed(), X(this);
};
r().prototype.logicalOr = function(t) {
  return this.throwIfDisposed(), tt(this, t);
};
r().prototype.logicalXor = function(t) {
  return this.throwIfDisposed(), As(this, t);
};
r().prototype.matMul = function(t, o, s) {
  return this.throwIfDisposed(), k(this, t, o, s);
};
r().prototype.maxPool = function(t, o, s, n) {
  return this.throwIfDisposed(), J(this, t, o, s, n);
};
r().prototype.max = function(t, o) {
  return this.throwIfDisposed(), Do(this, t, o);
};
r().prototype.maximum = function(t) {
  return this.throwIfDisposed(), Ct(this, t);
};
r().prototype.mean = function(t, o) {
  return this.throwIfDisposed(), yo(this, t, o);
};
r().prototype.min = function(t, o) {
  return this.throwIfDisposed(), qo(this, t, o);
};
r().prototype.minimum = function(t) {
  return this.throwIfDisposed(), Ko(this, t);
};
r().prototype.mirrorPad = function(t, o) {
  return this.throwIfDisposed(), Hs(this, t, o);
};
r().prototype.mod = function(t) {
  return this.throwIfDisposed(), Wo(this, t);
};
r().prototype.mul = function(t) {
  return this.throwIfDisposed(), M(this, t);
};
r().prototype.neg = function() {
  return this.throwIfDisposed(), N(this);
};
r().prototype.norm = function(t, o, s) {
  return this.throwIfDisposed(), Q(this, t, o, s);
};
r().prototype.notEqual = function(t) {
  return this.throwIfDisposed(), Io(this, t);
};
r().prototype.oneHot = function(t, o = 1, s = 0) {
  return this.throwIfDisposed(), to(this, t, o, s);
};
r().prototype.onesLike = function() {
  return this.throwIfDisposed(), oo(this);
};
r().prototype.pad = function(t, o) {
  return this.throwIfDisposed(), so(this, t, o);
};
r().prototype.pool = function(t, o, s, n, e, i) {
  return this.throwIfDisposed(), Rs(this, t, o, s, n, e, i);
};
r().prototype.pow = function(t) {
  return this.throwIfDisposed(), Mt(this, t);
};
r().prototype.prelu = function(t) {
  return this.throwIfDisposed(), bo(this, t);
};
r().prototype.prod = function(t, o) {
  return this.throwIfDisposed(), Gs(this, t, o);
};
r().prototype.reciprocal = function() {
  return this.throwIfDisposed(), Zs(this);
};
r().prototype.relu = function() {
  return this.throwIfDisposed(), jo(this);
};
r().prototype.relu6 = function() {
  return this.throwIfDisposed(), vo(this);
};
r().prototype.reshapeAs = function(t) {
  return this.throwIfDisposed(), l(this, t.shape);
};
r().prototype.reshape = function(t) {
  return this.throwIfDisposed(), l(this, t);
};
r().prototype.resizeBilinear = function(t, o, s) {
  return this.throwIfDisposed(), zo(this, t, o, s);
};
r().prototype.resizeNearestNeighbor = function(t, o, s) {
  return this.throwIfDisposed(), Po(this, t, o, s);
};
r().prototype.reverse = function(t) {
  return this.throwIfDisposed(), E(this, t);
};
r().prototype.rfft = function() {
  return this.throwIfDisposed(), sr(this);
};
r().prototype.round = function() {
  return this.throwIfDisposed(), Co(this);
};
r().prototype.rsqrt = function() {
  return this.throwIfDisposed(), ro(this);
};
r().prototype.selu = function() {
  return this.throwIfDisposed(), no(this);
};
r().prototype.separableConv2d = function(t, o, s, n, e, i) {
  return this.throwIfDisposed(), eo(this, t, o, s, n, e, i);
};
r().prototype.sigmoid = function() {
  return this.throwIfDisposed(), Y(this);
};
r().prototype.sign = function() {
  return this.throwIfDisposed(), Us(this);
};
r().prototype.sin = function() {
  return this.throwIfDisposed(), io(this);
};
r().prototype.sinh = function() {
  return this.throwIfDisposed(), po(this);
};
r().prototype.slice = function(t, o) {
  return this.throwIfDisposed(), T(this, t, o);
};
r().prototype.softmax = function(t) {
  return this.throwIfDisposed(), Xo(this, t);
};
r().prototype.softplus = function() {
  return this.throwIfDisposed(), R(this);
};
r().prototype.spaceToBatchND = function(t, o) {
  return this.throwIfDisposed(), G(this, t, o);
};
r().prototype.split = function(t, o) {
  return this.throwIfDisposed(), z(this, t, o);
};
r().prototype.sqrt = function() {
  return this.throwIfDisposed(), Ot(this);
};
r().prototype.square = function() {
  return this.throwIfDisposed(), At(this);
};
r().prototype.squaredDifference = function(t) {
  return this.throwIfDisposed(), Mo(this, t);
};
r().prototype.squeeze = function(t) {
  return this.throwIfDisposed(), Go(this, t);
};
r().prototype.stack = function(t, o) {
  this.throwIfDisposed();
  const s = t instanceof W ? [this, t] : [this, ...t];
  return Vo(s, o);
};
r().prototype.step = function(t) {
  return this.throwIfDisposed(), ko(this, t);
};
r().prototype.stridedSlice = function(t, o, s, n, e, i, p, a) {
  return this.throwIfDisposed(), nr(this, t, o, s, n, e, i, p, a);
};
r().prototype.sub = function(t) {
  return this.throwIfDisposed(), Bt(this, t);
};
r().prototype.sum = function(t, o) {
  return this.throwIfDisposed(), Zo(this, t, o);
};
r().prototype.tan = function() {
  return this.throwIfDisposed(), ir(this);
};
r().prototype.tanh = function() {
  return this.throwIfDisposed(), ao(this);
};
r().prototype.tile = function(t) {
  return this.throwIfDisposed(), Jo(this, t);
};
r().prototype.toBool = function() {
  return this.throwIfDisposed(), $(this, "bool");
};
r().prototype.toFloat = function() {
  return this.throwIfDisposed(), $(this, "float32");
};
r().prototype.toInt = function() {
  return this.throwIfDisposed(), $(this, "int32");
};
r().prototype.topk = function(t, o) {
  return this.throwIfDisposed(), ar(this, t, o);
};
r().prototype.transpose = function(t) {
  return this.throwIfDisposed(), Fo(this, t);
};
r().prototype.unique = function(t) {
  return this.throwIfDisposed(), ur(this, t);
};
r().prototype.unsortedSegmentSum = function(t, o) {
  return this.throwIfDisposed(), ho(this, t, o);
};
r().prototype.unstack = function(t) {
  return this.throwIfDisposed(), Oo(this, t);
};
r().prototype.where = function(t, o) {
  return this.throwIfDisposed(), U(t, this, o);
};
r().prototype.zerosLike = function() {
  return this.throwIfDisposed(), C(this);
};
export {
  Zs as r,
  ar as t
};
