diff --git a/libs/tensorflow-stripped.js b/libs/tensorflow-stripped.js
index 02b2ef6b64..65abdb28cb 100644
--- a/libs/tensorflow-stripped.js
+++ b/libs/tensorflow-stripped.js
@@ -131,7 +131,7 @@ function swap(object, left, right) {
     object[left] = object[right];
     object[right] = temp;
 }
-function sum$2(arr) {
+function sum$3(arr) {
     let sum = 0;
     for (let i = 0; i < arr.length; i++) {
         sum += arr[i];
@@ -462,6 +462,24 @@ function toNestedArray(shape, a, isComplex = false) {
     }
     return createNestedArray(0, shape, a, isComplex);
 }
+function convertBackendValuesAndArrayBuffer(data, dtype) {
+    
+    if (Array.isArray(data)) {
+        return data;
+    }
+    if (dtype === 'float32') {
+        return data instanceof Float32Array ? data : new Float32Array(data);
+    }
+    else if (dtype === 'int32') {
+        return data instanceof Int32Array ? data : new Int32Array(data);
+    }
+    else if (dtype === 'bool' || dtype === 'string') {
+        return Uint8Array.from(new Int32Array(data));
+    }
+    else {
+        throw new Error(`Unknown dtype ${dtype}`);
+    }
+}
 function makeOnesTypedArray(size, dtype) {
     const array = makeZerosTypedArray(size, dtype);
     for (let i = 0; i < array.length; i++) {
@@ -483,6 +501,22 @@ function makeZerosTypedArray(size, dtype) {
         throw new Error(`Unknown data type ${dtype}`);
     }
 }
+
+function makeZerosNestedTypedArray(shape, dtype) {
+    const size = shape.reduce((prev, curr) => prev * curr, 1);
+    if (dtype == null || dtype === 'float32') {
+        return toNestedArray(shape, new Float32Array(size));
+    }
+    else if (dtype === 'int32') {
+        return toNestedArray(shape, new Int32Array(size));
+    }
+    else if (dtype === 'bool') {
+        return toNestedArray(shape, new Uint8Array(size));
+    }
+    else {
+        throw new Error(`Unknown data type ${dtype}`);
+    }
+}
 function assertNonNegativeIntegerDimensions(shape) {
     shape.forEach(dimSize => {
         assert$1(Number.isInteger(dimSize) && dimSize >= 0, () => `Tensor must have a shape comprised of positive integers but got ` +
@@ -775,6 +809,7 @@ const Diag = 'Diag';
 const Dilation2D = 'Dilation2D';
 const Dilation2DBackpropInput = 'Dilation2DBackpropInput';
 const Dilation2DBackpropFilter = 'Dilation2DBackpropFilter';
+const Draw = 'Draw';
 const RealDiv = 'RealDiv';
 const Einsum = 'Einsum';
 const Elu$1 = 'Elu';
@@ -907,7 +942,7 @@ function warn(...msg) {
         console.warn(...msg);
     }
 }
-function log$2(...msg) {
+function log$3(...msg) {
     if (!(env().getBool('IS_TEST') || env().getBool('PROD'))) {
         console.log(...msg);
     }
@@ -3688,7 +3723,7 @@ class Engine {
             
             f => this.tidy(f), 
             
-            add$1);
+            add$2);
             const grads = xs.map(x => accumulatedGradientMap[x.id]);
             if (this.state.gradientDepth === 0) {
                 
@@ -3812,7 +3847,7 @@ function getOrMakeEngine() {
 }
 const ENGINE = getOrMakeEngine();
 
-function add$1(a, b) {
+function add$2(a, b) {
     
     const inputs = { a, b };
     return ENGINE.runKernel(Add, inputs);
@@ -4056,7 +4091,7 @@ function cast_(x, dtype) {
     const attrs = { dtype };
     return ENGINE.runKernel(Cast, inputs, attrs);
 }
-const cast$2 =  op({ cast_ });
+const cast$3 =  op({ cast_ });
 
 
 
@@ -4081,7 +4116,7 @@ function print(x, verbose = false) {
 getOrMakeEngine();
 const opHandler = {
     buffer,
-    cast: cast$2,
+    cast: cast$3,
     clone,
     print
 };
@@ -4131,7 +4166,7 @@ function add_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Add, inputs);
 }
-const add =  op({ add_ });
+const add$1 =  op({ add_ });
 
 
 
@@ -4142,7 +4177,7 @@ function floorDiv_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(FloorDiv, inputs);
 }
-const floorDiv$1 =  op({ floorDiv_ });
+const floorDiv$2 =  op({ floorDiv_ });
 
 
 
@@ -4151,14 +4186,14 @@ function div_(a, b) {
     let $b = convertToTensor(b, 'b', 'div');
     [$a, $b] = makeTypesMatch($a, $b);
     if ($a.dtype === 'int32' && $b.dtype === 'int32') {
-        return floorDiv$1($a, $b);
+        return floorDiv$2($a, $b);
     }
     const inputs = { a: $a, b: $b };
     const attrs = {};
     
     return ENGINE.runKernel(RealDiv, inputs, attrs);
 }
-const div =  op({ div_ });
+const div$1 =  op({ div_ });
 
 
 
@@ -4184,7 +4219,7 @@ function abs_(x) {
         return ENGINE.runKernel(Abs, inputs);
     }
 }
-const abs$1 =  op({ abs_ });
+const abs$2 =  op({ abs_ });
 
 
 
@@ -4195,7 +4230,7 @@ function any_(x, axis = null, keepDims = false) {
     return ENGINE.runKernel(Any, inputs, attrs);
 }
 
-const any$1 =  op({ any_ });
+const any$2 =  op({ any_ });
 
 
 
@@ -4205,7 +4240,7 @@ function argMax_(x, axis = 0) {
     const attrs = { axis };
     return ENGINE.runKernel(ArgMax, inputs, attrs);
 }
-const argMax$1 =  op({ argMax_ });
+const argMax$2 =  op({ argMax_ });
 
 
 
@@ -4364,8 +4399,8 @@ function computeOutputShape2D(inShape, fieldSize, stride, zeroPad, roundingMode)
     }
     const inputRows = inShape[0];
     const inputCols = inShape[1];
-    const outputRows = round$1((inputRows - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
-    const outputCols = round$1((inputCols - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
+    const outputRows = round$2((inputRows - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
+    const outputCols = round$2((inputCols - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
     return [outputRows, outputCols];
 }
 function computeOutputShape4D(inShape, filterShape, outChannels, strides, zeroPad, roundingMode) {
@@ -4375,7 +4410,7 @@ function computeOutputShape4D(inShape, filterShape, outChannels, strides, zeroPa
     const outShape = [0, 0, 0, outChannels];
     for (let index = 0; index < 3; index++) {
         if (inShape[index] + 2 * zeroPad >= filterShape[index]) {
-            outShape[index] = round$1((inShape[index] - filterShape[index] + 2 * zeroPad) / strides[index] +
+            outShape[index] = round$2((inShape[index] - filterShape[index] + 2 * zeroPad) / strides[index] +
                 1, roundingMode);
         }
     }
@@ -4440,8 +4475,8 @@ function getPadAndOutInfo(pad, inHeight, inWidth, strideHeight, strideWidth, fil
             'VALID' :
             'EXPLICIT';
         padInfo = { top, bottom, left, right, type: padType };
-        outHeight = round$1((inHeight - filterHeight + top + bottom) / strideHeight + 1, roundingMode);
-        outWidth = round$1((inWidth - filterWidth + left + right) / strideWidth + 1, roundingMode);
+        outHeight = round$2((inHeight - filterHeight + top + bottom) / strideHeight + 1, roundingMode);
+        outWidth = round$2((inWidth - filterWidth + left + right) / strideWidth + 1, roundingMode);
     }
     else {
         throw Error(`Unknown padding parameter: ${pad}`);
@@ -4493,7 +4528,7 @@ function get3DPadAndOutInfo(pad, inDepth, inHeight, inWidth, strideDepth, stride
     return { padInfo, outDepth, outHeight, outWidth };
 }
 
-function round$1(value, roundingMode) {
+function round$2(value, roundingMode) {
     if (!roundingMode) {
         return Math.trunc(value);
     }
@@ -4565,7 +4600,7 @@ function reshape_(x, shape) {
     const attrs = { shape };
     return ENGINE.runKernel(Reshape$1, inputs, attrs);
 }
-const reshape$1 =  op({ reshape_ });
+const reshape$2 =  op({ reshape_ });
 
 
 
@@ -4587,7 +4622,7 @@ function concat_(tensors, axis = 0) {
     const attr = { axis };
     return ENGINE.runKernel(Concat, inputs, attr);
 }
-const concat$1 =  op({ concat_ });
+const concat$2 =  op({ concat_ });
 
 
 
@@ -4608,7 +4643,7 @@ function sigmoid_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Sigmoid$1, inputs);
 }
-const sigmoid$1 =  op({ sigmoid_ });
+const sigmoid$2 =  op({ sigmoid_ });
 
 
 
@@ -4621,7 +4656,7 @@ function slice_(x, begin, size) {
     const attrs = { begin, size };
     return ENGINE.runKernel(Slice, inputs, attrs);
 }
-const slice$1 =  op({ slice_ });
+const slice$2 =  op({ slice_ });
 
 
 
@@ -4630,7 +4665,7 @@ function tanh_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Tanh$1, inputs);
 }
-const tanh$1 =  op({ tanh_ });
+const tanh$2 =  op({ tanh_ });
 
 
 
@@ -4645,7 +4680,7 @@ function batchToSpaceND_(x, blockShape, crops) {
     const attrs = { blockShape, crops };
     return ENGINE.runKernel(BatchToSpaceND, inputs, attrs);
 }
-const batchToSpaceND$1 =  op({ batchToSpaceND_ });
+const batchToSpaceND$2 =  op({ batchToSpaceND_ });
 
 
 
@@ -4661,7 +4696,7 @@ function broadcastTo_(x, shape) {
         while (newShape.length < shape.length) {
             newShape.unshift(1);
         }
-        input = reshape$1(input, newShape);
+        input = reshape$2(input, newShape);
     }
     const inputShape = input.shape;
     const reps = Array.from(shape);
@@ -4686,7 +4721,7 @@ const broadcastTo =  op({ broadcastTo_ });
 
 
 
-function fill$1(shape, value, dtype) {
+function fill$2(shape, value, dtype) {
     assertNonNegativeIntegerDimensions(shape);
     dtype = dtype || inferDtype(value);
     const attrs = { shape, value, dtype };
@@ -4700,13 +4735,13 @@ function clipByValue_(x, clipValueMin, clipValueMax) {
     assert$1((clipValueMin <= clipValueMax), () => `Error in clip: min (${clipValueMin}) must be ` +
         `less than or equal to max (${clipValueMax}).`);
     if (clipValueMin === clipValueMax) {
-        return fill$1($x.shape, clipValueMin, $x.dtype);
+        return fill$2($x.shape, clipValueMin, $x.dtype);
     }
     const inputs = { x: $x };
     const attrs = { clipValueMin, clipValueMax };
     return ENGINE.runKernel(ClipByValue, inputs, attrs);
 }
-const clipByValue$1 =  op({ clipByValue_ });
+const clipByValue$2 =  op({ clipByValue_ });
 
 
 
@@ -4718,7 +4753,7 @@ function complex_(real, imag) {
     const inputs = { real: $real, imag: $imag };
     return ENGINE.runKernel(Complex, inputs);
 }
-const complex$1 =  op({ complex_ });
+const complex$2 =  op({ complex_ });
 
 
 
@@ -4729,7 +4764,7 @@ function conv2d_(x, filter, strides, pad, dataFormat = 'NHWC', dilations = [1, 1
     let reshapedTo4D = false;
     if ($x.rank === 3) {
         reshapedTo4D = true;
-        x4D = reshape$1($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
+        x4D = reshape$2($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
     }
     assert$1(x4D.rank === 4, () => `Error in conv2d: input must be rank 4, but got rank ${x4D.rank}.`);
     assert$1($filter.rank === 4, () => `Error in conv2d: filter must be rank 4, but got rank ` +
@@ -4747,7 +4782,7 @@ function conv2d_(x, filter, strides, pad, dataFormat = 'NHWC', dilations = [1, 1
     
     const res = ENGINE.runKernel(Conv2D, inputs, attrs);
     if (reshapedTo4D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3]]);
     }
     return res;
 }
@@ -4763,7 +4798,7 @@ function conv2DBackpropInput_(xShape, dy, filter, strides, pad, dataFormat = 'NH
     let reshapedTo4D = false;
     if (dy.rank === 3) {
         reshapedTo4D = true;
-        dy4D = reshape$1(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
+        dy4D = reshape$2(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
         xShape4D = [1, xShape[0], xShape[1], xShape[2]];
     }
     assert$1(xShape4D.length === 4, () => `Error in conv2dDerInput: inShape must be length 4, but got length ` +
@@ -4784,11 +4819,11 @@ function conv2DBackpropInput_(xShape, dy, filter, strides, pad, dataFormat = 'NH
     
     const res = ENGINE.runKernel(Conv2DBackpropInput, inputs, attrs);
     if (reshapedTo4D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3]]);
     }
     return res;
 }
-const conv2DBackpropInput$1 =  op({ conv2DBackpropInput_ });
+const conv2DBackpropInput$2 =  op({ conv2DBackpropInput_ });
 
 
 
@@ -4800,7 +4835,7 @@ function conv3DBackpropInput_(xShape, dy, filter, strides, pad) {
     let reshapedTo5D = false;
     if (dy.rank === 4) {
         reshapedTo5D = true;
-        dy5D = reshape$1(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
+        dy5D = reshape$2(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
         xShape5D = [1, xShape[0], xShape[1], xShape[2], xShape[3]];
     }
     const inDepth = xShape5D[4];
@@ -4820,7 +4855,7 @@ function conv3DBackpropInput_(xShape, dy, filter, strides, pad) {
     
     const res = ENGINE.runKernel(Conv3DBackpropInputV2, inputs, attrs);
     if (reshapedTo5D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
     }
     return res;
 }
@@ -4833,7 +4868,7 @@ function cos_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Cos, inputs);
 }
-const cos$1 =  op({ cos_ });
+const cos$2 =  op({ cos_ });
 
 
 
@@ -4842,7 +4877,7 @@ function cosh_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Cosh, inputs);
 }
-const cosh$1 =  op({ cosh_ });
+const cosh$2 =  op({ cosh_ });
 
 
 
@@ -4852,7 +4887,7 @@ function cumprod_(x, axis = 0, exclusive = false, reverse = false) {
     const attrs = { axis, exclusive, reverse };
     return ENGINE.runKernel(Cumprod, inputs, attrs);
 }
-const cumprod$1 =  op({ cumprod_ });
+const cumprod$2 =  op({ cumprod_ });
 
 
 
@@ -4862,7 +4897,7 @@ function cumsum_(x, axis = 0, exclusive = false, reverse = false) {
     const attrs = { axis, exclusive, reverse };
     return ENGINE.runKernel(Cumsum, inputs, attrs);
 }
-const cumsum$1 =  op({ cumsum_ });
+const cumsum$2 =  op({ cumsum_ });
 
 
 
@@ -4932,7 +4967,7 @@ function equal_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Equal, inputs);
 }
-const equal$1 =  op({ equal_ });
+const equal$2 =  op({ equal_ });
 
 
 
@@ -4963,7 +4998,7 @@ function zerosLike_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(ZerosLike, inputs);
 }
-const zerosLike$1 =  op({ zerosLike_ });
+const zerosLike$2 =  op({ zerosLike_ });
 
 
 
@@ -4972,7 +5007,7 @@ function elu_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Elu$1, inputs);
 }
-const elu$2 =  op({ elu_ });
+const elu$3 =  op({ elu_ });
 
 
 
@@ -4980,12 +5015,12 @@ function erf_(x) {
     let $x = convertToTensor(x, 'x', 'erf');
     assert$1($x.dtype === 'int32' || $x.dtype === 'float32', () => 'Input dtype must be `int32` or `float32`.');
     if ($x.dtype === 'int32') {
-        $x = cast$2($x, 'float32');
+        $x = cast$3($x, 'float32');
     }
     const inputs = { x: $x };
     return ENGINE.runKernel(Erf, inputs);
 }
-const erf$1 =  op({ erf_ });
+const erf$2 =  op({ erf_ });
 
 
 
@@ -5067,7 +5102,7 @@ function max_(x, axis = null, keepDims = false) {
     const attrs = { reductionIndices: axis, keepDims };
     return ENGINE.runKernel(Max, inputs, attrs);
 }
-const max$1 =  op({ max_ });
+const max$2 =  op({ max_ });
 
 
 
@@ -5078,7 +5113,7 @@ function min_(x, axis = null, keepDims = false) {
     
     return ENGINE.runKernel(Min, inputs, attrs);
 }
-const min$1 =  op({ min_ });
+const min$2 =  op({ min_ });
 
 
 
@@ -5089,7 +5124,7 @@ function pow_(base, exp) {
     const inputs = { a: $base, b: $exp };
     return ENGINE.runKernel(Pow, inputs);
 }
-const pow$1 =  op({ pow_ });
+const pow$2 =  op({ pow_ });
 
 
 
@@ -5166,7 +5201,7 @@ function sqrt_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Sqrt, inputs);
 }
-const sqrt$1 =  op({ sqrt_ });
+const sqrt$2 =  op({ sqrt_ });
 
 
 
@@ -5182,13 +5217,13 @@ const square$2 =  op({ square_ });
 function sum_(x, axis = null, keepDims = false) {
     let $x = convertToTensor(x, 'x', 'sum');
     if ($x.dtype === 'bool') {
-        $x = cast$2($x, 'int32');
+        $x = cast$3($x, 'int32');
     }
     const inputs = { x: $x };
     const attrs = { axis, keepDims };
     return ENGINE.runKernel(Sum, inputs, attrs);
 }
-const sum$1 =  op({ sum_ });
+const sum$2 =  op({ sum_ });
 
 
 
@@ -5200,48 +5235,48 @@ function norm_(x, ord = 'euclidean', axis = null, keepDims = false) {
         const axes = parseAxisParam(axis, x.shape);
         keepDimsShape = expandShapeToKeepDim(norm.shape, axes);
     }
-    return reshape$1(norm, keepDimsShape);
+    return reshape$2(norm, keepDimsShape);
 }
 function normImpl(x, p, axis = null) {
     if (x.rank === 0) {
-        return abs$1(x);
+        return abs$2(x);
     }
     
     if (x.rank !== 1 && axis === null) {
-        return normImpl(reshape$1(x, [-1]), p, axis);
+        return normImpl(reshape$2(x, [-1]), p, axis);
     }
     
     if (x.rank === 1 || typeof axis === 'number' ||
         Array.isArray(axis) && axis.length === 1) {
         if (p === 1) {
-            return sum$1(abs$1(x), axis);
+            return sum$2(abs$2(x), axis);
         }
         if (p === Infinity) {
-            return max$1(abs$1(x), axis);
+            return max$2(abs$2(x), axis);
         }
         if (p === -Infinity) {
-            return min$1(abs$1(x), axis);
+            return min$2(abs$2(x), axis);
         }
         if (p === 'euclidean' || p === 2) {
             
-            return sqrt$1(sum$1(pow$1(abs$1(x), scalar(2, 'int32')), axis));
+            return sqrt$2(sum$2(pow$2(abs$2(x), scalar(2, 'int32')), axis));
         }
         throw new Error(`Error in norm: invalid ord value: ${p}`);
     }
     
     if (Array.isArray(axis) && axis.length === 2) {
         if (p === 1) {
-            return max$1(sum$1(abs$1(x), axis[0]), axis[1] - 1);
+            return max$2(sum$2(abs$2(x), axis[0]), axis[1] - 1);
         }
         if (p === Infinity) {
-            return max$1(sum$1(abs$1(x), axis[1]), axis[0]);
+            return max$2(sum$2(abs$2(x), axis[1]), axis[0]);
         }
         if (p === -Infinity) {
-            return min$1(sum$1(abs$1(x), axis[1]), axis[0]);
+            return min$2(sum$2(abs$2(x), axis[1]), axis[0]);
         }
         if (p === 'fro' || p === 'euclidean') {
             
-            return sqrt$1(sum$1(square$2(x), axis));
+            return sqrt$2(sum$2(square$2(x), axis));
         }
         throw new Error(`Error in norm: invalid ord value: ${p}`);
     }
@@ -5256,7 +5291,7 @@ function exp_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Exp, inputs);
 }
-const exp$1 =  op({ exp_ });
+const exp$2 =  op({ exp_ });
 
 
 
@@ -5267,7 +5302,7 @@ function expandDims_(x, axis = 0) {
     const attrs = { dim: axis };
     return ENGINE.runKernel(ExpandDims, inputs, attrs);
 }
-const expandDims$2 =  op({ expandDims_ });
+const expandDims$3 =  op({ expandDims_ });
 
 
 
@@ -5279,7 +5314,7 @@ function tile_(x, reps) {
     const attrs = { reps };
     return ENGINE.runKernel(Tile, inputs, attrs);
 }
-const tile$2 =  op({ tile_ });
+const tile$3 =  op({ tile_ });
 
 
 
@@ -5292,21 +5327,21 @@ function eye_(numRows, numColumns, batchShape, dtype = 'float32') {
     for (let i = 0; i < n; ++i) {
         buff.set(1, i, i);
     }
-    const out = reshape$1(buff.toTensor(), [numRows, numColumns]);
+    const out = reshape$2(buff.toTensor(), [numRows, numColumns]);
     if (batchShape == null) {
         return out;
     }
     else {
         if (batchShape.length === 1) {
-            return tile$2(expandDims$2(out, 0), [batchShape[0], 1, 1]);
+            return tile$3(expandDims$3(out, 0), [batchShape[0], 1, 1]);
         }
         else if (batchShape.length === 2) {
             
-            return tile$2(expandDims$2(expandDims$2(out, 0), 0), [batchShape[0], batchShape[1], 1, 1]);
+            return tile$3(expandDims$3(expandDims$3(out, 0), 0), [batchShape[0], batchShape[1], 1, 1]);
         }
         else if (batchShape.length === 3) {
             
-            return tile$2(expandDims$2(expandDims$2(expandDims$2(out, 0), 0), 0), [
+            return tile$3(expandDims$3(expandDims$3(expandDims$3(out, 0), 0), 0), [
                 batchShape[0], batchShape[1], batchShape[2], 1, 1
             ]);
         }
@@ -5326,7 +5361,7 @@ function floor_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Floor, inputs);
 }
-const floor$1 =  op({ floor_ });
+const floor$2 =  op({ floor_ });
 
 
 
@@ -5349,7 +5384,7 @@ function greater_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Greater, inputs);
 }
-const greater$1 =  op({ greater_ });
+const greater$2 =  op({ greater_ });
 
 
 
@@ -5361,7 +5396,7 @@ function greaterEqual_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(GreaterEqual, inputs);
 }
-const greaterEqual$1 =  op({ greaterEqual_ });
+const greaterEqual$2 =  op({ greaterEqual_ });
 
 
 
@@ -5370,7 +5405,7 @@ function imag_(input) {
     const inputs = { input: $input };
     return ENGINE.runKernel(Imag, inputs);
 }
-const imag$1 =  op({ imag_ });
+const imag$2 =  op({ imag_ });
 
 
 
@@ -5380,7 +5415,7 @@ function leakyRelu_(x, alpha = 0.2) {
     const attrs = { alpha };
     return ENGINE.runKernel(LeakyRelu, inputs, attrs);
 }
-const leakyRelu$1 =  op({ leakyRelu_ });
+const leakyRelu$2 =  op({ leakyRelu_ });
 
 
 
@@ -5392,7 +5427,7 @@ function less_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Less, inputs);
 }
-const less$1 =  op({ less_ });
+const less$2 =  op({ less_ });
 
 
 
@@ -5404,7 +5439,7 @@ function lessEqual_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(LessEqual, inputs);
 }
-const lessEqual$1 =  op({ lessEqual_ });
+const lessEqual$2 =  op({ lessEqual_ });
 
 
 
@@ -5413,7 +5448,7 @@ function log_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Log, inputs);
 }
-const log$1 =  op({ log_ });
+const log$2 =  op({ log_ });
 
 
 
@@ -5422,7 +5457,7 @@ function log1p_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Log1p, inputs);
 }
-const log1p$1 =  op({ log1p_ });
+const log1p$2 =  op({ log1p_ });
 
 
 
@@ -5478,7 +5513,7 @@ function neg_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Neg, inputs);
 }
-const neg$1 =  op({ neg_ });
+const neg$2 =  op({ neg_ });
 
 
 
@@ -5487,7 +5522,7 @@ function softplus_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Softplus$1, inputs);
 }
-const softplus$1 =  op({ softplus_ });
+const softplus$2 =  op({ softplus_ });
 
 
 
@@ -5498,7 +5533,7 @@ function sub_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Sub, inputs);
 }
-const sub$1 =  op({ sub_ });
+const sub$2 =  op({ sub_ });
 
 
 
@@ -5524,15 +5559,15 @@ function logSoftmax_(logits, axis = -1) {
     
     const customOp = customGrad((logits, save) => {
         const keepDims = true;
-        const xMax = max$1(logits, axis, true);
-        const shifted = sub$1(logits, xMax);
-        const value = sub$1(cast$2(shifted, 'float32'), log$1(sum$1(exp$1(shifted), axis, keepDims)));
+        const xMax = max$2(logits, axis, true);
+        const shifted = sub$2(logits, xMax);
+        const value = sub$2(cast$3(shifted, 'float32'), log$2(sum$2(exp$2(shifted), axis, keepDims)));
         save([value]);
         const gradFunc = (dy, saved) => {
             const [value] = saved;
             const keepDims = true;
-            const softmax = exp$1(value);
-            return sub$1(dy, mul(sum$1(dy, axis, keepDims), softmax));
+            const softmax = exp$2(value);
+            return sub$2(dy, mul(sum$2(dy, axis, keepDims), softmax));
         };
         return { value, gradFunc };
     });
@@ -5555,7 +5590,7 @@ function logicalAnd_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(LogicalAnd, inputs);
 }
-const logicalAnd$1 =  op({ logicalAnd_ });
+const logicalAnd$2 =  op({ logicalAnd_ });
 
 
 
@@ -5564,7 +5599,7 @@ function logicalNot_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(LogicalNot, inputs);
 }
-const logicalNot$1 =  op({ logicalNot_ });
+const logicalNot$2 =  op({ logicalNot_ });
 
 
 
@@ -5573,14 +5608,14 @@ function maximum_(a, b) {
     let $b = convertToTensor(b, 'b', 'maximum');
     [$a, $b] = makeTypesMatch($a, $b);
     if ($a.dtype === 'bool') {
-        $a = cast$2($a, 'int32');
-        $b = cast$2($b, 'int32');
+        $a = cast$3($a, 'int32');
+        $b = cast$3($b, 'int32');
     }
     assertAndGetBroadcastShape($a.shape, $b.shape);
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Maximum, inputs);
 }
-const maximum$1 =  op({ maximum_ });
+const maximum$2 =  op({ maximum_ });
 
 
 
@@ -5590,16 +5625,16 @@ function mean_(x, axis = null, keepDims = false) {
     const attrs = { axis, keepDims };
     return ENGINE.runKernel(Mean, inputs, attrs);
 }
-const mean =  op({ mean_ });
+const mean$1 =  op({ mean_ });
 
 
 
-function zeros(shape, dtype = 'float32') {
+function zeros$1(shape, dtype = 'float32') {
     assertNonNegativeIntegerDimensions(shape);
     if (dtype === 'complex64') {
-        const real = zeros(shape, 'float32');
-        const imag = zeros(shape, 'float32');
-        return complex$1(real, imag);
+        const real = zeros$1(shape, 'float32');
+        const imag = zeros$1(shape, 'float32');
+        return complex$2(real, imag);
     }
     const values = makeZerosTypedArray(sizeFromShape(shape), dtype);
     return ENGINE.makeTensor(values, shape, dtype);
@@ -5611,8 +5646,8 @@ function ones(shape, dtype = 'float32') {
     assertNonNegativeIntegerDimensions(shape);
     if (dtype === 'complex64') {
         const real = ones(shape, 'float32');
-        const imag = zeros(shape, 'float32');
-        return complex$1(real, imag);
+        const imag = zeros$1(shape, 'float32');
+        return complex$2(real, imag);
     }
     const values = makeOnesTypedArray(sizeFromShape(shape), dtype);
     return ENGINE.makeTensor(values, shape, dtype);
@@ -5625,14 +5660,14 @@ function minimum_(a, b) {
     let $b = convertToTensor(b, 'b', 'minimum');
     [$a, $b] = makeTypesMatch($a, $b);
     if ($a.dtype === 'bool') {
-        $a = cast$2($a, 'int32');
-        $b = cast$2($b, 'int32');
+        $a = cast$3($a, 'int32');
+        $b = cast$3($b, 'int32');
     }
     assertAndGetBroadcastShape($a.shape, $b.shape);
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Minimum, inputs);
 }
-const minimum$1 =  op({ minimum_ });
+const minimum$2 =  op({ minimum_ });
 
 
 
@@ -5644,7 +5679,7 @@ function notEqual_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(NotEqual, inputs);
 }
-const notEqual$1 =  op({ notEqual_ });
+const notEqual$2 =  op({ notEqual_ });
 
 
 
@@ -5657,7 +5692,7 @@ function oneHot_(indices, depth, onValue = 1, offValue = 0, dtype = 'int32') {
     const attrs = { dtype, depth, onValue, offValue };
     return ENGINE.runKernel(OneHot, inputs, attrs);
 }
-const oneHot$1 =  op({ oneHot_ });
+const oneHot$2 =  op({ oneHot_ });
 
 
 
@@ -5666,7 +5701,7 @@ function onesLike_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(OnesLike, inputs);
 }
-const onesLike$1 =  op({ onesLike_ });
+const onesLike$2 =  op({ onesLike_ });
 
 
 
@@ -5700,7 +5735,7 @@ function spaceToBatchND_(x, blockShape, paddings) {
     const attrs = { blockShape, paddings };
     return ENGINE.runKernel(SpaceToBatchND, inputs, attrs);
 }
-const spaceToBatchND$1 =  op({ spaceToBatchND_ });
+const spaceToBatchND$2 =  op({ spaceToBatchND_ });
 
 
 
@@ -5710,7 +5745,7 @@ function prelu_(x, alpha) {
     const inputs = { x: $x, alpha: $alpha };
     return ENGINE.runKernel(Prelu, inputs);
 }
-const prelu$1 =  op({ prelu_ });
+const prelu$2 =  op({ prelu_ });
 
 var alea$1 = {exports: {}};
 
@@ -6744,7 +6779,7 @@ const randomUniform =  op({ randomUniform_ });
 
 
 
-function range$2(start, stop, step = 1, dtype = 'float32') {
+function range$3(start, stop, step = 1, dtype = 'float32') {
     if (step === 0) {
         throw new Error('Cannot have a step of zero');
     }
@@ -6759,7 +6794,7 @@ function real_(input) {
     const inputs = { input: $input };
     return ENGINE.runKernel(Real, inputs);
 }
-const real$1 =  op({ real_ });
+const real$2 =  op({ real_ });
 
 
 
@@ -6768,7 +6803,7 @@ function relu_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Relu$1, inputs);
 }
-const relu$1 =  op({ relu_ });
+const relu$2 =  op({ relu_ });
 
 
 
@@ -6777,7 +6812,7 @@ function relu6_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Relu6$1, inputs);
 }
-const relu6$1 =  op({ relu6_ });
+const relu6$2 =  op({ relu6_ });
 
 
 
@@ -6787,7 +6822,7 @@ function reverse_(x, axis) {
     const attrs = { dims: axis };
     return ENGINE.runKernel(Reverse, inputs, attrs);
 }
-const reverse$1 =  op({ reverse_ });
+const reverse$2 =  op({ reverse_ });
 
 
 
@@ -6796,7 +6831,7 @@ function rsqrt_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Rsqrt, inputs);
 }
-const rsqrt$1 =  op({ rsqrt_ });
+const rsqrt$2 =  op({ rsqrt_ });
 
 
 
@@ -6805,7 +6840,7 @@ function selu_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Selu$1, inputs);
 }
-const selu$1 =  op({ selu_ });
+const selu$2 =  op({ selu_ });
 
 
 
@@ -6814,7 +6849,7 @@ function sin_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Sin, inputs);
 }
-const sin$1 =  op({ sin_ });
+const sin$2 =  op({ sin_ });
 
 
 
@@ -6823,14 +6858,14 @@ function sinh_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Sinh, inputs);
 }
-const sinh$1 =  op({ sinh_ });
+const sinh$2 =  op({ sinh_ });
 
 
 
 function slice1d_(x, begin, size) {
     const $x = convertToTensor(x, 'x', 'slice1d');
     assert$1($x.rank === 1, () => `slice1d expects a rank-1 tensor, but got a rank-${$x.rank} tensor`);
-    return slice$1($x, [begin], [size]);
+    return slice$2($x, [begin], [size]);
 }
 const slice1d =  op({ slice1d_ });
 
@@ -6839,7 +6874,7 @@ const slice1d =  op({ slice1d_ });
 function slice2d_(x, begin, size) {
     const $x = convertToTensor(x, 'x', 'slice2d');
     assert$1($x.rank === 2, () => `slice2d expects a rank-2 tensor, but got a rank-${$x.rank} tensor`);
-    return slice$1($x, begin, size);
+    return slice$2($x, begin, size);
 }
 const slice2d =  op({ slice2d_ });
 
@@ -6848,7 +6883,7 @@ const slice2d =  op({ slice2d_ });
 function slice3d_(x, begin, size) {
     const $x = convertToTensor(x, 'x', 'slice3d');
     assert$1($x.rank === 3, () => `slice3d expects a rank-3 tensor, but got a rank-${$x.rank} tensor`);
-    return slice$1($x, begin, size);
+    return slice$2($x, begin, size);
 }
 const slice3d =  op({ slice3d_ });
 
@@ -6857,7 +6892,7 @@ const slice3d =  op({ slice3d_ });
 function slice4d_(x, begin, size) {
     const $x = convertToTensor(x, 'x', 'slice4d');
     assert$1($x.rank === 4, () => `slice4d expects a rank-4 tensor, but got a rank-${$x.rank} tensor`);
-    return slice$1($x, begin, size);
+    return slice$2($x, begin, size);
 }
 const slice4d =  op({ slice4d_ });
 
@@ -6876,7 +6911,7 @@ function softmax_(logits, dim = -1) {
     const attrs = { dim };
     return ENGINE.runKernel(Softmax$1, inputs, attrs);
 }
-const softmax$1 =  op({ softmax_ });
+const softmax$2 =  op({ softmax_ });
 
 
 
@@ -6892,7 +6927,7 @@ const split$1 =  op({ split_ });
 
 function squeeze_(x, axis) {
     const $x = convertToTensor(x, 'x', 'squeeze', 'string_or_numeric');
-    return reshape$1($x, squeezeShape($x.shape, axis).newShape);
+    return reshape$2($x, squeezeShape($x.shape, axis).newShape);
 }
 const squeeze =  op({ squeeze_ });
 
@@ -6918,7 +6953,7 @@ function step_(x, alpha = 0.0) {
     const attrs = { alpha };
     return ENGINE.runKernel(Step, inputs, attrs);
 }
-const step$1 =  op({ step_ });
+const step$2 =  op({ step_ });
 
 
 
@@ -7060,7 +7095,7 @@ function unsortedSegmentSum_(x, segmentIds, numSegments) {
     const attrs = { numSegments };
     return ENGINE.runKernel(UnsortedSegmentSum, inputs, attrs);
 }
-const unsortedSegmentSum$1 =  op({ unsortedSegmentSum_ });
+const unsortedSegmentSum$2 =  op({ unsortedSegmentSum_ });
 
 
 
@@ -7081,7 +7116,7 @@ function variable(initialValue, trainable = true, name, dtype) {
 
 
 
-function whereImpl$1(condShape, condVals) {
+function whereImpl$2(condShape, condVals) {
     const indices = [];
     for (let i = 0; i < condVals.length; i++) {
         if (condVals[i]) {
@@ -7118,19 +7153,19 @@ function transpose_(x, perm, conjugate) {
     const attrs = { perm };
     if ($x.dtype === 'complex64') {
         return tidy(() => {
-            let $real = real$1($x);
-            let $imag = imag$1($x);
+            let $real = real$2($x);
+            let $imag = imag$2($x);
             $real = ENGINE.runKernel(Transpose, { x: $real }, attrs);
             $imag = ENGINE.runKernel(Transpose, { x: $imag }, attrs);
             if (conjugate) {
-                $imag = neg$1($imag);
+                $imag = neg$2($imag);
             }
-            return complex$1($real, $imag);
+            return complex$2($real, $imag);
         });
     }
     return ENGINE.runKernel(Transpose, inputs, attrs);
 }
-const transpose$1 =  op({ transpose_ });
+const transpose$2 =  op({ transpose_ });
 
 
 
@@ -7168,7 +7203,7 @@ function dropout_(x, rate, noiseShape, seed) {
     }
     const $noiseShape = getNoiseShape($x, noiseShape);
     const keepProb = 1 - rate;
-    const multiplier = div(floor$1(add(randomUniform($noiseShape, 0, 1, 'float32', seed), keepProb)), keepProb);
+    const multiplier = div$1(floor$2(add$1(randomUniform($noiseShape, 0, 1, 'float32', seed), keepProb)), keepProb);
     return mul($x, multiplier);
 }
 const dropout$2 =  op({ dropout_ });
@@ -7178,11 +7213,11 @@ const dropout$2 =  op({ dropout_ });
 function conv2DBackpropFilter_(x, dy, filterShape, strides, pad, dataFormat = 'NHWC', dimRoundingMode) {
     let x4D = x;
     if (x.rank === 3) {
-        x4D = reshape$1(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
+        x4D = reshape$2(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
     }
     let dy4D = dy;
     if (dy4D.rank === 3) {
-        dy4D = reshape$1(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
+        dy4D = reshape$2(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
     }
     assert$1(x4D.rank === 4, () => `Error in conv2dDerFilter: input must be rank 4, but got shape ` +
         `${x4D.shape}.`);
@@ -7202,7 +7237,7 @@ function conv2DBackpropFilter_(x, dy, filterShape, strides, pad, dataFormat = 'N
     
     return ENGINE.runKernel(Conv2DBackpropFilter, inputs, attrs);
 }
-const conv2DBackpropFilter$1 =  op({ conv2DBackpropFilter_ });
+const conv2DBackpropFilter$2 =  op({ conv2DBackpropFilter_ });
 
 
 
@@ -7211,7 +7246,7 @@ function getFusedDyActivation(dy, y, activation) {
         return dy;
     }
     if (activation === 'relu') {
-        return mul(dy, step$1(y));
+        return mul(dy, step$2(y));
     }
     throw new Error(`Cannot compute gradient for fused activation ${activation}.`);
 }
@@ -7220,31 +7255,31 @@ function getFusedBiasGradient(bias, dyActivation) {
     let res = dyActivation;
     const reduceAxes = getReductionAxes(bias.shape, dyActivation.shape);
     if (reduceAxes.length > 0) {
-        res = sum$1(res, reduceAxes);
+        res = sum$2(res, reduceAxes);
     }
-    return reshape$1(res, bias.shape);
+    return reshape$2(res, bias.shape);
 }
-function applyActivation(x, activation, preluActivationWeights, leakyreluAlpha) {
+function applyActivation$1(x, activation, preluActivationWeights, leakyreluAlpha) {
     if (activation === 'linear') {
         return x;
     }
     else if (activation === 'relu') {
-        return relu$1(x);
+        return relu$2(x);
     }
     else if (activation === 'elu') {
-        return elu$2(x);
+        return elu$3(x);
     }
     else if (activation === 'relu6') {
-        return relu6$1(x);
+        return relu6$2(x);
     }
     else if (activation === 'prelu') {
-        return prelu$1(x, preluActivationWeights);
+        return prelu$2(x, preluActivationWeights);
     }
     else if (activation === 'leakyrelu') {
-        return leakyRelu$1(x, leakyreluAlpha);
+        return leakyRelu$2(x, leakyreluAlpha);
     }
     else if (activation === 'sigmoid') {
-        return sigmoid$1(x);
+        return sigmoid$2(x);
     }
     throw new Error(`Unknown fused activation ${activation}.`);
 }
@@ -7258,18 +7293,18 @@ const shouldFuse = (gradientDepth, activation) => {
 function depthwiseConv2dNativeBackpropFilter_(x, dy, filterShape, strides, pad, dilations = [1, 1], dimRoundingMode) {
     let x4D = x;
     if (x.rank === 3) {
-        x4D = reshape$1(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
+        x4D = reshape$2(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
     }
     let dy4D = dy;
     if (dy4D.rank === 3) {
-        dy4D = reshape$1(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
+        dy4D = reshape$2(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
     }
     const inputs = { x: x4D, dy: dy4D };
     const attrs = { strides, pad, dimRoundingMode, dilations, filterShape };
     
     return ENGINE.runKernel(DepthwiseConv2dNativeBackpropFilter, inputs, attrs);
 }
-const depthwiseConv2dNativeBackpropFilter$1 = op({ depthwiseConv2dNativeBackpropFilter_ });
+const depthwiseConv2dNativeBackpropFilter$2 = op({ depthwiseConv2dNativeBackpropFilter_ });
 
 
 function depthwiseConv2dNativeBackpropInput_(xShape, dy, filter, strides, pad, dilations = [1, 1], dimRoundingMode) {
@@ -7277,7 +7312,7 @@ function depthwiseConv2dNativeBackpropInput_(xShape, dy, filter, strides, pad, d
     let reshapedTo4D = false;
     if (dy.rank === 3) {
         reshapedTo4D = true;
-        dy4D = reshape$1(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
+        dy4D = reshape$2(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
     }
     const inputs = { dy: dy4D, filter };
     const attrs = { strides, pad, dimRoundingMode, dilations, inputShape: xShape };
@@ -7285,11 +7320,11 @@ function depthwiseConv2dNativeBackpropInput_(xShape, dy, filter, strides, pad, d
     
     ENGINE.runKernel(DepthwiseConv2dNativeBackpropInput, inputs, attrs);
     if (reshapedTo4D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3]]);
     }
     return res;
 }
-const depthwiseConv2dNativeBackpropInput$1 = op({ depthwiseConv2dNativeBackpropInput_ });
+const depthwiseConv2dNativeBackpropInput$2 = op({ depthwiseConv2dNativeBackpropInput_ });
 
 
 
@@ -7297,9 +7332,9 @@ function fusedMatMul_({ a, b, transposeA = false, transposeB = false, bias, acti
     if (shouldFuse(ENGINE.state.gradientDepth, activation) === false) {
         let result = matMul$1(a, b, transposeA, transposeB);
         if (bias != null) {
-            result = add(result, bias);
+            result = add$1(result, bias);
         }
-        return applyActivation(result, activation, preluActivationWeights, leakyreluAlpha);
+        return applyActivation$1(result, activation, preluActivationWeights, leakyreluAlpha);
     }
     let $a = convertToTensor(a, 'a', 'fused matMul');
     let $b = convertToTensor(b, 'b', 'fused matMul');
@@ -7319,11 +7354,11 @@ function fusedMatMul_({ a, b, transposeA = false, transposeB = false, bias, acti
     const outShapeOuterDims = assertAndGetBroadcastShape($a.shape.slice(0, -2), $b.shape.slice(0, -2));
     const outShape = outShapeOuterDims.concat([outerShapeA, outerShapeB]);
     const a3D = transposeA ?
-        reshape$1($a, [batchDimA, innerShapeA, outerShapeA]) :
-        reshape$1($a, [batchDimA, outerShapeA, innerShapeA]);
+        reshape$2($a, [batchDimA, innerShapeA, outerShapeA]) :
+        reshape$2($a, [batchDimA, outerShapeA, innerShapeA]);
     const b3D = transposeB ?
-        reshape$1($b, [batchDimB, outerShapeB, innerShapeB]) :
-        reshape$1($b, [batchDimB, innerShapeB, outerShapeB]);
+        reshape$2($b, [batchDimB, outerShapeB, innerShapeB]) :
+        reshape$2($b, [batchDimB, innerShapeB, outerShapeB]);
     let $bias;
     if (bias != null) {
         $bias = convertToTensor(bias, 'bias', 'fused matMul');
@@ -7339,7 +7374,7 @@ function fusedMatMul_({ a, b, transposeA = false, transposeB = false, bias, acti
         
         
         
-        const dyActivation = getFusedDyActivation(reshape$1(dy, y.shape), y, activation);
+        const dyActivation = getFusedDyActivation(reshape$2(dy, y.shape), y, activation);
         let aDer;
         let bDer;
         if (!transposeA && !transposeB) {
@@ -7381,7 +7416,7 @@ function fusedMatMul_({ a, b, transposeA = false, transposeB = false, bias, acti
             
             ENGINE.runKernel(_FusedMatMul, inputs, attrs);
             save([a3D, b3D, res]);
-            return { value: reshape$1(res, outShape), gradFunc: grad };
+            return { value: reshape$2(res, outShape), gradFunc: grad };
         });
         return customOp(a3D, b3D);
     }
@@ -7391,7 +7426,7 @@ function fusedMatMul_({ a, b, transposeA = false, transposeB = false, bias, acti
             
             ENGINE.runKernel(_FusedMatMul, inputs, attrs);
             save([a3D, b3D, res, $bias]);
-            return { value: reshape$1(res, outShape), gradFunc: grad };
+            return { value: reshape$2(res, outShape), gradFunc: grad };
         });
         return customOpWithBias(a3D, b3D, $bias);
     }
@@ -7435,14 +7470,14 @@ function binarySearch_(arr, target, comparator) {
 }
 
 
-function nonMaxSuppressionV3Impl$1(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold) {
+function nonMaxSuppressionV3Impl$2(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold) {
     return nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, 0 );
 }
-function nonMaxSuppressionV4Impl$1(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize) {
+function nonMaxSuppressionV4Impl$2(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize) {
     return nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, 0 , false , padToMaxOutputSize , true
      );
 }
-function nonMaxSuppressionV5Impl$1(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma) {
+function nonMaxSuppressionV5Impl$2(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma) {
     return nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma, true );
 }
 function nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma, returnScoresTensor = false, padToMaxOutputSize = false, returnValidOutputs = false) {
@@ -7584,7 +7619,7 @@ function bandPart_(a, numLower, numUpper) {
         assert$1(numLower.dtype === 'int32', () => `bandPart(): numLower's dtype must be an int32.`);
         
         
-        $numLower = where(less$1(numLower, 0), M, minimum$1(numLower, M));
+        $numLower = where(less$2(numLower, 0), M, minimum$2(numLower, M));
     }
     if (typeof numUpper === 'number') {
         assert$1(numUpper % 1 === 0, () => `bandPart(): numUpper must be an integer, got ${numUpper}.`);
@@ -7595,14 +7630,14 @@ function bandPart_(a, numLower, numUpper) {
     }
     else {
         assert$1(numUpper.dtype === 'int32', () => `bandPart(): numUpper's dtype must be an int32.`);
-        $numUpper = where(less$1(numUpper, 0), N, minimum$1(numUpper, N));
+        $numUpper = where(less$2(numUpper, 0), N, minimum$2(numUpper, N));
     }
-    const i = reshape$1(range$2(0, M, 1, 'int32'), [-1, 1]);
-    const j = range$2(0, N, 1, 'int32');
-    const ij = sub$1(i, j);
-    const inBand = logicalAnd$1(lessEqual$1(ij, $numLower), greaterEqual$1(ij, neg$1($numUpper)));
-    const zero = zeros([M, N], $a.dtype);
-    return reshape$1(stack(unstack(reshape$1($a, [-1, M, N]))
+    const i = reshape$2(range$3(0, M, 1, 'int32'), [-1, 1]);
+    const j = range$3(0, N, 1, 'int32');
+    const ij = sub$2(i, j);
+    const inBand = logicalAnd$2(lessEqual$2(ij, $numLower), greaterEqual$2(ij, neg$2($numUpper)));
+    const zero = zeros$1([M, N], $a.dtype);
+    return reshape$2(stack(unstack(reshape$2($a, [-1, M, N]))
         .map(mat => where(inBand, mat, zero))), shape);
 }
 const bandPart =  op({ bandPart_ });
@@ -7634,11 +7669,11 @@ function gramSchmidt_(xs) {
             let x = xs1d[i];
             if (i > 0) {
                 for (let j = 0; j < i; ++j) {
-                    const proj = mul(sum$1(mul(ys[j], x)), ys[j]);
-                    x = sub$1(x, proj);
+                    const proj = mul(sum$2(mul(ys[j], x)), ys[j]);
+                    x = sub$2(x, proj);
                 }
             }
-            return div(x, norm(x, 'euclidean'));
+            return div$1(x, norm(x, 'euclidean'));
         }));
     }
     if (inputIsTensor2D) {
@@ -7664,7 +7699,7 @@ function qr_(x, fullMatrices = false) {
         
         const outerDimsProd = x.shape.slice(0, x.shape.length - 2)
             .reduce((value, prev) => value * prev);
-        const x2ds = unstack(reshape$1(x, [
+        const x2ds = unstack(reshape$2(x, [
             outerDimsProd, x.shape[x.shape.length - 2],
             x.shape[x.shape.length - 1]
         ]), 0);
@@ -7675,8 +7710,8 @@ function qr_(x, fullMatrices = false) {
             q2ds.push(q2d);
             r2ds.push(r2d);
         });
-        const q = reshape$1(stack(q2ds, 0), x.shape);
-        const r = reshape$1(stack(r2ds, 0), x.shape);
+        const q = reshape$2(stack(q2ds, 0), x.shape);
+        const r = reshape$2(stack(r2ds, 0), x.shape);
         return [q, r];
     }
 }
@@ -7698,50 +7733,50 @@ function qr2d(x, fullMatrices = false) {
             const qTemp = q;
             [w, r, q] = ENGINE.tidy(() => {
                 
-                const rjEnd1 = slice$1(r, [j, j], [m - j, 1]);
+                const rjEnd1 = slice$2(r, [j, j], [m - j, 1]);
                 const normX = norm(rjEnd1);
-                const rjj = slice$1(r, [j, j], [1, 1]);
+                const rjj = slice$2(r, [j, j], [1, 1]);
                 
-                const s = where(greater$1(rjj, 0), tensor2d([[-1]]), tensor2d([[1]]));
-                const u1 = sub$1(rjj, mul(s, normX));
-                const wPre = div(rjEnd1, u1);
+                const s = where(greater$2(rjj, 0), tensor2d([[-1]]), tensor2d([[1]]));
+                const u1 = sub$2(rjj, mul(s, normX));
+                const wPre = div$1(rjEnd1, u1);
                 if (wPre.shape[0] === 1) {
                     w = clone(one2D);
                 }
                 else {
-                    w = concat$1([
+                    w = concat$2([
                         one2D,
-                        slice$1(wPre, [1, 0], [wPre.shape[0] - 1, wPre.shape[1]])
+                        slice$2(wPre, [1, 0], [wPre.shape[0] - 1, wPre.shape[1]])
                     ], 0);
                 }
-                const tau = neg$1(div(matMul$1(s, u1), normX));
+                const tau = neg$2(div$1(matMul$1(s, u1), normX));
                 
-                const rjEndAll = slice$1(r, [j, 0], [m - j, n]);
+                const rjEndAll = slice$2(r, [j, 0], [m - j, n]);
                 const tauTimesW = mul(tau, w);
-                const wT = transpose$1(w);
+                const wT = transpose$2(w);
                 if (j === 0) {
-                    r = sub$1(rjEndAll, matMul$1(tauTimesW, matMul$1(wT, rjEndAll)));
+                    r = sub$2(rjEndAll, matMul$1(tauTimesW, matMul$1(wT, rjEndAll)));
                 }
                 else {
-                    const rTimesTau = sub$1(rjEndAll, matMul$1(tauTimesW, matMul$1(wT, rjEndAll)));
-                    r = concat$1([slice$1(r, [0, 0], [j, n]), rTimesTau], 0);
+                    const rTimesTau = sub$2(rjEndAll, matMul$1(tauTimesW, matMul$1(wT, rjEndAll)));
+                    r = concat$2([slice$2(r, [0, 0], [j, n]), rTimesTau], 0);
                 }
-                const tawTimesWT = transpose$1(tauTimesW);
-                const qAllJEnd = slice$1(q, [0, j], [m, q.shape[1] - j]);
+                const tawTimesWT = transpose$2(tauTimesW);
+                const qAllJEnd = slice$2(q, [0, j], [m, q.shape[1] - j]);
                 if (j === 0) {
-                    q = sub$1(qAllJEnd, matMul$1(matMul$1(qAllJEnd, w), tawTimesWT));
+                    q = sub$2(qAllJEnd, matMul$1(matMul$1(qAllJEnd, w), tawTimesWT));
                 }
                 else {
-                    const qTimesTau = sub$1(qAllJEnd, matMul$1(matMul$1(qAllJEnd, w), tawTimesWT));
-                    q = concat$1([slice$1(q, [0, 0], [m, j]), qTimesTau], 1);
+                    const qTimesTau = sub$2(qAllJEnd, matMul$1(matMul$1(qAllJEnd, w), tawTimesWT));
+                    q = concat$2([slice$2(q, [0, 0], [m, j]), qTimesTau], 1);
                 }
                 return [w, r, q];
             });
             dispose([rTemp, wTemp, qTemp]);
         }
         if (!fullMatrices && m > n) {
-            q = slice$1(q, [0, 0], [m, n]);
-            r = slice$1(r, [0, 0], [n, n]);
+            q = slice$2(q, [0, 0], [m, n]);
+            r = slice$2(r, [0, 0], [n, n]);
         }
         return [q, r];
     });
@@ -7759,7 +7794,7 @@ function stringToHashBucketFast_(input, numBuckets) {
     const inputs = { input: $input };
     return ENGINE.runKernel(StringToHashBucketFast, inputs, attrs);
 }
-const stringToHashBucketFast$1 =  op({ stringToHashBucketFast_ });
+const stringToHashBucketFast$2 =  op({ stringToHashBucketFast_ });
 
 
 
@@ -7930,13 +7965,13 @@ class AdadeltaOptimizer extends Optimizer {
             if (this.accumulatedGrads[i] == null) {
                 this.accumulatedGrads[i] = {
                     originalName: `${name}/accum_grad`,
-                    variable: tidy(() => zerosLike$1(value).variable(trainable))
+                    variable: tidy(() => zerosLike$2(value).variable(trainable))
                 };
             }
             if (this.accumulatedUpdates[i] == null) {
                 this.accumulatedUpdates[i] = {
                     originalName: `${name}/accum_var`,
-                    variable: tidy(() => zerosLike$1(value).variable(trainable))
+                    variable: tidy(() => zerosLike$2(value).variable(trainable))
                 };
             }
             const gradient = Array.isArray(variableGradients) ?
@@ -7948,12 +7983,12 @@ class AdadeltaOptimizer extends Optimizer {
             const accumulatedGrad = this.accumulatedGrads[i].variable;
             const accumulatedUpdate = this.accumulatedUpdates[i].variable;
             tidy(() => {
-                const newAccumulatedGrad = add(mul(accumulatedGrad, this.rho), mul(square$2(gradient), 1 - this.rho));
-                const updates = mul(div(sqrt$1(add(accumulatedUpdate, this.epsilon)), sqrt$1(add(accumulatedGrad, this.epsilon))), gradient);
-                const newAccumulatedUpdate = add(mul(accumulatedUpdate, this.rho), mul(square$2(updates), 1 - this.rho));
+                const newAccumulatedGrad = add$1(mul(accumulatedGrad, this.rho), mul(square$2(gradient), 1 - this.rho));
+                const updates = mul(div$1(sqrt$2(add$1(accumulatedUpdate, this.epsilon)), sqrt$2(add$1(accumulatedGrad, this.epsilon))), gradient);
+                const newAccumulatedUpdate = add$1(mul(accumulatedUpdate, this.rho), mul(square$2(updates), 1 - this.rho));
                 accumulatedGrad.assign(newAccumulatedGrad);
                 accumulatedUpdate.assign(newAccumulatedUpdate);
-                const newValue = add(mul(updates, -this.learningRate), value);
+                const newValue = add$1(mul(updates, -this.learningRate), value);
                 value.assign(newValue);
             });
         });
@@ -8025,7 +8060,7 @@ class AdagradOptimizer extends Optimizer {
                 const trainable = false;
                 this.accumulatedGrads[i] = {
                     originalName: `${name}/accumulator`,
-                    variable: tidy(() => fill$1(value.shape, this.initialAccumulatorValue)
+                    variable: tidy(() => fill$2(value.shape, this.initialAccumulatorValue)
                         .variable(trainable))
                 };
             }
@@ -8037,9 +8072,9 @@ class AdagradOptimizer extends Optimizer {
             }
             const accumulatedGrad = this.accumulatedGrads[i].variable;
             tidy(() => {
-                const newAccumulatedGrad = add(accumulatedGrad, square$2(gradient));
+                const newAccumulatedGrad = add$1(accumulatedGrad, square$2(gradient));
                 accumulatedGrad.assign(newAccumulatedGrad);
-                const newValue = add(mul(div(gradient, sqrt$1(add(newAccumulatedGrad, ENGINE.backend.epsilon()))), -this.learningRate), value);
+                const newValue = add$1(mul(div$1(gradient, sqrt$2(add$1(newAccumulatedGrad, ENGINE.backend.epsilon()))), -this.learningRate), value);
                 value.assign(newValue);
             });
         });
@@ -8102,21 +8137,21 @@ class AdamOptimizer extends Optimizer {
             variableGradients.map(v => v.name) :
             Object.keys(variableGradients);
         tidy(() => {
-            const oneMinusAccBeta1 = sub$1(1, this.accBeta1);
-            const oneMinusAccBeta2 = sub$1(1, this.accBeta2);
+            const oneMinusAccBeta1 = sub$2(1, this.accBeta1);
+            const oneMinusAccBeta2 = sub$2(1, this.accBeta2);
             varNames.forEach((name, i) => {
                 const value = ENGINE.registeredVariables[name];
                 const trainable = false;
                 if (this.accumulatedFirstMoment[i] == null) {
                     this.accumulatedFirstMoment[i] = {
                         originalName: `${name}/m`,
-                        variable: tidy(() => zerosLike$1(value).variable(trainable))
+                        variable: tidy(() => zerosLike$2(value).variable(trainable))
                     };
                 }
                 if (this.accumulatedSecondMoment[i] == null) {
                     this.accumulatedSecondMoment[i] = {
                         originalName: `${name}/v`,
-                        variable: tidy(() => zerosLike$1(value).variable(trainable))
+                        variable: tidy(() => zerosLike$2(value).variable(trainable))
                     };
                 }
                 const gradient = Array.isArray(variableGradients) ?
@@ -8127,13 +8162,13 @@ class AdamOptimizer extends Optimizer {
                 }
                 const firstMoment = this.accumulatedFirstMoment[i].variable;
                 const secondMoment = this.accumulatedSecondMoment[i].variable;
-                const newFirstMoment = add(mul(firstMoment, this.beta1), mul(gradient, 1 - this.beta1));
-                const newSecondMoment = add(mul(secondMoment, this.beta2), mul(square$2(gradient), 1 - this.beta2));
-                const biasCorrectedFirstMoment = div(newFirstMoment, oneMinusAccBeta1);
-                const biasCorrectedSecondMoment = div(newSecondMoment, oneMinusAccBeta2);
+                const newFirstMoment = add$1(mul(firstMoment, this.beta1), mul(gradient, 1 - this.beta1));
+                const newSecondMoment = add$1(mul(secondMoment, this.beta2), mul(square$2(gradient), 1 - this.beta2));
+                const biasCorrectedFirstMoment = div$1(newFirstMoment, oneMinusAccBeta1);
+                const biasCorrectedSecondMoment = div$1(newSecondMoment, oneMinusAccBeta2);
                 firstMoment.assign(newFirstMoment);
                 secondMoment.assign(newSecondMoment);
-                const newValue = add(mul(div(biasCorrectedFirstMoment, add(sqrt$1(biasCorrectedSecondMoment), this.epsilon)), -this.learningRate), value);
+                const newValue = add$1(mul(div$1(biasCorrectedFirstMoment, add$1(sqrt$2(biasCorrectedSecondMoment), this.epsilon)), -this.learningRate), value);
                 value.assign(newValue);
             });
             this.accBeta1.assign(mul(this.accBeta1, this.beta1));
@@ -8159,8 +8194,8 @@ class AdamOptimizer extends Optimizer {
     async setWeights(weightValues) {
         weightValues = await this.extractIterations(weightValues);
         tidy(() => {
-            this.accBeta1.assign(pow$1(this.beta1, this.iterations_ + 1));
-            this.accBeta2.assign(pow$1(this.beta2, this.iterations_ + 1));
+            this.accBeta1.assign(pow$2(this.beta1, this.iterations_ + 1));
+            this.accBeta2.assign(pow$2(this.beta2, this.iterations_ + 1));
         });
         const variableCount = weightValues.length / 2;
         const trainable = false;
@@ -8221,21 +8256,21 @@ class AdamaxOptimizer extends Optimizer {
             variableGradients.map(item => item.name) :
             Object.keys(variableGradients);
         tidy(() => {
-            const oneMinusAccBeta1 = sub$1(1, this.accBeta1);
-            const lr = div(-this.learningRate, add(mul(this.iteration, this.decay), 1));
+            const oneMinusAccBeta1 = sub$2(1, this.accBeta1);
+            const lr = div$1(-this.learningRate, add$1(mul(this.iteration, this.decay), 1));
             variableNames.forEach((name, i) => {
                 const value = ENGINE.registeredVariables[name];
                 const trainable = false;
                 if (this.accumulatedFirstMoment[i] == null) {
                     this.accumulatedFirstMoment[i] = {
                         originalName: `${name}/m`,
-                        variable: zerosLike$1(value).variable(trainable)
+                        variable: zerosLike$2(value).variable(trainable)
                     };
                 }
                 if (this.accumulatedWeightedInfNorm[i] == null) {
                     this.accumulatedWeightedInfNorm[i] = {
                         originalName: `${name}/v`,
-                        variable: zerosLike$1(value).variable(trainable)
+                        variable: zerosLike$2(value).variable(trainable)
                     };
                 }
                 const gradient = Array.isArray(variableGradients) ?
@@ -8246,16 +8281,16 @@ class AdamaxOptimizer extends Optimizer {
                 }
                 const firstMoment = this.accumulatedFirstMoment[i].variable;
                 const weightedInfNorm = this.accumulatedWeightedInfNorm[i].variable;
-                const newFirstMoment = add(mul(firstMoment, this.beta1), mul(gradient, 1 - this.beta1));
+                const newFirstMoment = add$1(mul(firstMoment, this.beta1), mul(gradient, 1 - this.beta1));
                 const ut0 = mul(weightedInfNorm, this.beta2);
-                const ut1 = abs$1(gradient);
-                const newWeightedInfNorm = maximum$1(ut0, ut1);
+                const ut1 = abs$2(gradient);
+                const newWeightedInfNorm = maximum$2(ut0, ut1);
                 firstMoment.assign(newFirstMoment);
                 weightedInfNorm.assign(newWeightedInfNorm);
-                const newValue = add(mul(div(lr, oneMinusAccBeta1), div(newFirstMoment, add(newWeightedInfNorm, this.epsilon))), value);
+                const newValue = add$1(mul(div$1(lr, oneMinusAccBeta1), div$1(newFirstMoment, add$1(newWeightedInfNorm, this.epsilon))), value);
                 value.assign(newValue);
             });
-            this.iteration.assign(add(this.iteration, 1));
+            this.iteration.assign(add$1(this.iteration, 1));
             this.accBeta1.assign(mul(this.accBeta1, this.beta1));
         });
         this.incrementIterations();
@@ -8319,7 +8354,7 @@ class SGDOptimizer extends Optimizer {
             }
             const value = ENGINE.registeredVariables[name];
             tidy(() => {
-                const newValue = add(mul(this.c, gradient), value);
+                const newValue = add$1(mul(this.c, gradient), value);
                 value.assign(newValue);
             });
         });
@@ -8383,7 +8418,7 @@ class MomentumOptimizer extends SGDOptimizer {
                 const trainable = false;
                 this.accumulations[i] = {
                     originalName: `${name}/momentum`,
-                    variable: tidy(() => zerosLike$1(value).variable(trainable))
+                    variable: tidy(() => zerosLike$2(value).variable(trainable))
                 };
             }
             const accumulation = this.accumulations[i].variable;
@@ -8395,12 +8430,12 @@ class MomentumOptimizer extends SGDOptimizer {
             }
             tidy(() => {
                 let newValue;
-                const newAccumulation = add(mul(this.m, accumulation), gradient);
+                const newAccumulation = add$1(mul(this.m, accumulation), gradient);
                 if (this.useNesterov) {
-                    newValue = add(mul(this.c, add(gradient, mul(newAccumulation, this.m))), value);
+                    newValue = add$1(mul(this.c, add$1(gradient, mul(newAccumulation, this.m))), value);
                 }
                 else {
-                    newValue = add(mul(this.c, newAccumulation), value);
+                    newValue = add$1(mul(this.c, newAccumulation), value);
                 }
                 accumulation.assign(newAccumulation);
                 value.assign(newValue);
@@ -8477,19 +8512,19 @@ class RMSPropOptimizer extends Optimizer {
             if (this.accumulatedMeanSquares[i] == null) {
                 this.accumulatedMeanSquares[i] = {
                     originalName: `${name}/rms`,
-                    variable: tidy(() => zerosLike$1(value).variable(trainable))
+                    variable: tidy(() => zerosLike$2(value).variable(trainable))
                 };
             }
             if (this.accumulatedMoments[i] == null) {
                 this.accumulatedMoments[i] = {
                     originalName: `${name}/momentum`,
-                    variable: tidy(() => zerosLike$1(value).variable(trainable))
+                    variable: tidy(() => zerosLike$2(value).variable(trainable))
                 };
             }
             if (this.accumulatedMeanGrads[i] == null && this.centered) {
                 this.accumulatedMeanGrads[i] = {
                     originalName: `${name}/mg`,
-                    variable: tidy(() => zerosLike$1(value).variable(trainable))
+                    variable: tidy(() => zerosLike$2(value).variable(trainable))
                 };
             }
             const gradient = Array.isArray(variableGradients) ?
@@ -8501,26 +8536,26 @@ class RMSPropOptimizer extends Optimizer {
             const accumulatedMeanSquare = this.accumulatedMeanSquares[i].variable;
             const accumulatedMoments = this.accumulatedMoments[i].variable;
             tidy(() => {
-                const newAccumulatedMeanSquare = add(mul(accumulatedMeanSquare, this.decay), mul(square$2(gradient), 1 - this.decay));
+                const newAccumulatedMeanSquare = add$1(mul(accumulatedMeanSquare, this.decay), mul(square$2(gradient), 1 - this.decay));
                 if (this.centered) {
                     const accumulatedMeanGrad = this.accumulatedMeanGrads[i].variable;
                     
-                    const newAccumulatedMeanGrad = add(mul(accumulatedMeanGrad, this.decay), mul(gradient, 1 - this.decay));
-                    const gradContribution = div(mul(gradient, this.learningRate), sqrt$1(sub$1(newAccumulatedMeanSquare, add(square$2(newAccumulatedMeanGrad), this.epsilon))));
-                    const newAccumulatedMoments = add(mul(accumulatedMoments, this.momentum), gradContribution);
+                    const newAccumulatedMeanGrad = add$1(mul(accumulatedMeanGrad, this.decay), mul(gradient, 1 - this.decay));
+                    const gradContribution = div$1(mul(gradient, this.learningRate), sqrt$2(sub$2(newAccumulatedMeanSquare, add$1(square$2(newAccumulatedMeanGrad), this.epsilon))));
+                    const newAccumulatedMoments = add$1(mul(accumulatedMoments, this.momentum), gradContribution);
                     accumulatedMeanSquare.assign(newAccumulatedMeanSquare);
                     accumulatedMeanGrad.assign(newAccumulatedMeanGrad);
                     accumulatedMoments.assign(newAccumulatedMoments);
-                    const newValue = sub$1(value, newAccumulatedMoments);
+                    const newValue = sub$2(value, newAccumulatedMoments);
                     value.assign(newValue);
                 }
                 else {
                     
-                    const newAccumulatedMeanSquare = add(mul(accumulatedMeanSquare, this.decay), mul(square$2(gradient), 1 - this.decay));
-                    const newAccumulatedMoments = add(mul(accumulatedMoments, this.momentum), div(mul(gradient, this.learningRate), sqrt$1(add(newAccumulatedMeanSquare, this.epsilon))));
+                    const newAccumulatedMeanSquare = add$1(mul(accumulatedMeanSquare, this.decay), mul(square$2(gradient), 1 - this.decay));
+                    const newAccumulatedMoments = add$1(mul(accumulatedMoments, this.momentum), div$1(mul(gradient, this.learningRate), sqrt$2(add$1(newAccumulatedMeanSquare, this.epsilon))));
                     accumulatedMeanSquare.assign(newAccumulatedMeanSquare);
                     accumulatedMoments.assign(newAccumulatedMoments);
-                    const newValue = sub$1(value, newAccumulatedMoments);
+                    const newValue = sub$2(value, newAccumulatedMoments);
                     value.assign(newValue);
                 }
             });
@@ -8944,7 +8979,7 @@ function decodeWeight(spec, byteBuffer) {
             }
             const realTensor = tensor(real, shape, 'float32');
             const imageTensor = tensor(image, shape, 'float32');
-            const complexTensor = complex$1(realTensor, imageTensor);
+            const complexTensor = complex$2(realTensor, imageTensor);
             realTensor.dispose();
             imageTensor.dispose();
             return complexTensor;
@@ -11021,7 +11056,7 @@ var backend_util = Object.freeze({
     get RowPartitionType () { return RowPartitionType$1; },
     SELU_SCALE: SELU_SCALE,
     SELU_SCALEALPHA: SELU_SCALEALPHA,
-    applyActivation: applyActivation,
+    applyActivation: applyActivation$1,
     assertAndGetBroadcastShape: assertAndGetBroadcastShape,
     assertAxesAreInnerMostDims: assertAxesAreInnerMostDims,
     assertParamsConsistent: assertParamsConsistent,
@@ -11082,7 +11117,7 @@ var backend_util = Object.freeze({
     getSparseSegmentReductionSegmentIdOutOfRangeErrorMessage: getSparseSegmentReductionSegmentIdOutOfRangeErrorMessage,
     getUndoAxesPermutation: getUndoAxesPermutation,
     isIdentityPermutation: isIdentityPermutation,
-    log: log$2,
+    log: log$3,
     mergeRealAndImagArrays: mergeRealAndImagArrays,
     prepareAndValidate: prepareAndValidate,
     prepareSplitSize: prepareSplitSize,
@@ -11778,7 +11813,7 @@ function isWebGLFenceEnabled(webGLVersion) {
     const isEnabled = gl.fenceSync != null;
     return isEnabled;
 }
-function assertNotComplex(tensor, opName) {
+function assertNotComplex$1(tensor, opName) {
     if (!Array.isArray(tensor)) {
         tensor = [tensor];
     }
@@ -15021,6 +15056,18 @@ function linearSearchLastTrue(arr) {
 }
 
 
+function assertNotComplex(tensor, opName) {
+    if (!Array.isArray(tensor)) {
+        tensor = [tensor];
+    }
+    tensor.forEach(t => {
+        if (t != null) {
+            assert$1(t.dtype !== 'complex64', () => `${opName} does not support complex64 tensors in the CPU backend.`);
+        }
+    });
+}
+
+
 function simpleAbsImpl(vals) {
     const resultValues = new Float32Array(vals.length);
     for (let i = 0; i < vals.length; ++i) {
@@ -15028,6 +15075,20 @@ function simpleAbsImpl(vals) {
     }
     return resultValues;
 }
+const abs$1 = (args) => {
+    const { x } = args.inputs;
+    const cpuBackend = args.backend;
+    assertNotComplex(x, 'abs');
+    let resultValues = new Float32Array(sizeFromShape(x.shape));
+    const values = cpuBackend.data.get(x.dataId).values;
+    resultValues = simpleAbsImpl(values);
+    return cpuBackend.makeOutput(resultValues, x.shape, x.dtype);
+};
+const absConfig$1 = {
+    kernelName: Abs,
+    backendName: 'cpu',
+    kernelFunc: abs$1,
+};
 
 
 
@@ -15066,6 +15127,71 @@ function createSimpleBinaryKernelImpl(op) {
 }
 
 
+function complex$1(args) {
+    const { inputs, backend } = args;
+    const { real, imag } = inputs;
+    const realVals = backend.data.get(real.dataId).values;
+    const imagVals = backend.data.get(imag.dataId).values;
+    const complexInfo = backend.makeTensorInfo(real.shape, 'complex64');
+    const complex = backend.data.get(complexInfo.dataId);
+    
+    
+    
+    complex.complexTensorInfos = {
+        real: backend.makeTensorInfo(real.shape, 'float32', realVals),
+        imag: backend.makeTensorInfo(imag.shape, 'float32', imagVals)
+    };
+    return complexInfo;
+}
+const complexConfig$1 = {
+    kernelName: Complex,
+    backendName: 'cpu',
+    kernelFunc: complex$1
+};
+
+
+
+function zeros(backend, shape, dtype = 'float32') {
+    if (dtype === 'complex64') {
+        const real = zeros(backend, shape, 'float32');
+        const imag = zeros(backend, shape, 'float32');
+        return complex$1({ inputs: { real, imag }, backend });
+    }
+    const values = makeZerosTypedArray(sizeFromShape(shape), dtype);
+    return backend.makeTensorInfo(shape, dtype, values);
+}
+
+
+function identity$1(args) {
+    const { inputs, backend } = args;
+    const { x } = inputs;
+    backend.incRef(x.dataId);
+    return { dataId: x.dataId, shape: x.shape, dtype: x.dtype };
+}
+const identityConfig$1 = {
+    kernelName: Identity$1,
+    backendName: 'cpu',
+    kernelFunc: identity$1
+};
+
+
+function real$1(args) {
+    const { inputs, backend } = args;
+    const { input } = inputs;
+    const real = backend.data.get(input.dataId).complexTensorInfos.real;
+    const realVal = backend.data.get(real.dataId).values;
+    
+    
+    
+    return backend.makeTensorInfo(real.shape, real.dtype, realVal);
+}
+const realConfig$1 = {
+    kernelName: Real,
+    backendName: 'cpu',
+    kernelFunc: real$1
+};
+
+
 function castImpl(values, shape, inputType, dtype) {
     if (dtype === 'int32') {
         const resultValues = Int32Array.from(values);
@@ -15081,9 +15207,158 @@ function castImpl(values, shape, inputType, dtype) {
     }
     throw new Error(`Error in Cast: failed to cast ${inputType} to ${dtype}`);
 }
+function cast$2(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { dtype } = attrs;
+    
+    if (dtype === 'complex64') {
+        if (x.dtype === 'complex64') {
+            return identity$1({ inputs: { x }, backend });
+        }
+        const zerosTensorInfo = zeros(backend, x.shape, x.dtype);
+        const floatX = cast$2({ inputs: { x }, backend, attrs: { dtype: 'float32' } });
+        const result = complex$1({ inputs: { real: floatX, imag: zerosTensorInfo }, backend });
+        backend.disposeIntermediateTensorInfo(zerosTensorInfo);
+        backend.disposeIntermediateTensorInfo(floatX);
+        return result;
+    }
+    
+    if (x.dtype === 'complex64') {
+        const realPart = real$1({ inputs: { input: x }, backend });
+        const result = cast$2({ inputs: { x: realPart }, backend, attrs: { dtype } });
+        backend.disposeIntermediateTensorInfo(realPart);
+        return result;
+    }
+    if (!hasEncodingLoss(x.dtype, dtype)) {
+        
+        
+        const result = identity$1({ inputs: { x }, backend });
+        return { dataId: result.dataId, shape: result.shape, dtype };
+    }
+    const values = backend.data.get(x.dataId).values;
+    const [resultShape, resultType, resultData] = castImpl(values, x.shape, x.dtype, dtype);
+    return backend.makeTensorInfo(resultShape, resultType, resultData);
+}
+const castConfig$1 = {
+    kernelName: Cast,
+    backendName: 'cpu',
+    kernelFunc: cast$2
+};
+
+
+
+function binaryKernelFunc$1(name, simpleImpl, complexImpl, dtype) {
+    if (complexImpl == null) {
+        return ({ inputs, backend }) => {
+            const { a, b } = inputs;
+            const cpuBackend = backend;
+            assertNotComplex([a, b], name);
+            const aVals = cpuBackend.data.get(a.dataId).values;
+            const bVals = cpuBackend.data.get(b.dataId).values;
+            const decodedAVals = a.dtype === 'string' ?
+                
+                fromUint8ToStringArray(aVals) :
+                aVals;
+            const decodedBVals = a.dtype === 'string' ?
+                
+                fromUint8ToStringArray(bVals) :
+                bVals;
+            const $dtype = dtype || a.dtype;
+            const [resultData, resultShape] = simpleImpl(a.shape, b.shape, decodedAVals, decodedBVals, $dtype);
+            return cpuBackend.makeTensorInfo(resultShape, $dtype, resultData);
+        };
+    }
+    return ({ inputs, backend }) => {
+        const { a, b } = inputs;
+        const cpuBackend = backend;
+        if (a.dtype === 'complex64' || b.dtype === 'complex64') {
+            const $aComplex = cast$2({ inputs: { x: a }, backend: cpuBackend, attrs: { dtype: 'complex64' } });
+            const $aComplexVals = cpuBackend.data.get($aComplex.dataId);
+            const aReal = $aComplexVals.complexTensorInfos.real;
+            const aImag = $aComplexVals.complexTensorInfos.imag;
+            const aRealVals = cpuBackend.data.get(aReal.dataId).values;
+            const aImagVals = cpuBackend.data.get(aImag.dataId).values;
+            const $bComplex = cast$2({ inputs: { x: b }, backend: cpuBackend, attrs: { dtype: 'complex64' } });
+            const $bComplexVals = cpuBackend.data.get($bComplex.dataId);
+            const bReal = $bComplexVals.complexTensorInfos.real;
+            const bImag = $bComplexVals.complexTensorInfos.imag;
+            const bRealVals = cpuBackend.data.get(bReal.dataId).values;
+            const bImagVals = cpuBackend.data.get(bImag.dataId).values;
+            const [resultRealData, resultImagData, resultShape] = complexImpl(a.shape, b.shape, aRealVals, aImagVals, bRealVals, bImagVals);
+            const resultReal = cpuBackend.makeTensorInfo(resultShape, 'float32', resultRealData);
+            const resultImag = cpuBackend.makeTensorInfo(resultShape, 'float32', resultImagData);
+            const result = complex$1({ inputs: { real: resultReal, imag: resultImag }, backend: cpuBackend });
+            cpuBackend.disposeIntermediateTensorInfo($aComplex);
+            cpuBackend.disposeIntermediateTensorInfo($bComplex);
+            cpuBackend.disposeIntermediateTensorInfo(resultReal);
+            cpuBackend.disposeIntermediateTensorInfo(resultImag);
+            return result;
+        }
+        else {
+            const aVals = cpuBackend.data.get(a.dataId).values;
+            const bVals = cpuBackend.data.get(b.dataId).values;
+            const $dtype = dtype || a.dtype;
+            const [resultData, resultShape] = simpleImpl(a.shape, b.shape, aVals, bVals, $dtype);
+            return cpuBackend.makeTensorInfo(resultShape, $dtype, resultData);
+        }
+    };
+}
+
+function createComplexBinaryKernelImpl(op) {
+    return (aShape, bShape, aRealVals, aImagVals, bRealVals, bImagVals) => {
+        const resultShape = assertAndGetBroadcastShape(aShape, bShape);
+        const resultSize = sizeFromShape(resultShape);
+        const resultRank = resultShape.length;
+        const resultStrides = computeStrides(resultShape);
+        const resultRealVals = getTypedArrayFromDType('float32', resultSize);
+        const resultImagVals = getTypedArrayFromDType('float32', resultSize);
+        const aBroadcastDims = getBroadcastDims$1(aShape, resultShape);
+        const bBroadcastDims = getBroadcastDims$1(bShape, resultShape);
+        const aVals = mergeRealAndImagArrays(aRealVals, aImagVals);
+        const bVals = mergeRealAndImagArrays(bRealVals, bImagVals);
+        const aRank = aShape.length;
+        const aStrides = computeStrides(aShape);
+        const bRank = bShape.length;
+        const bStrides = computeStrides(bShape);
+        if (aBroadcastDims.length + bBroadcastDims.length === 0) {
+            for (let i = 0; i < resultRealVals.length; i++) {
+                const aIdx = i % aVals.length;
+                const bIdx = i % bVals.length;
+                const result = op(aVals[aIdx * 2], aVals[aIdx * 2 + 1], bVals[bIdx * 2], bVals[bIdx * 2 + 1]);
+                resultRealVals[i] = result.real;
+                resultImagVals[i] = result.imag;
+            }
+        }
+        else {
+            for (let i = 0; i < resultRealVals.length; i++) {
+                const loc = indexToLoc(i, resultRank, resultStrides);
+                const aLoc = loc.slice(-aRank);
+                aBroadcastDims.forEach(d => aLoc[d] = 0);
+                const aIndex = locToIndex(aLoc, aRank, aStrides);
+                const bLoc = loc.slice(-bRank);
+                bBroadcastDims.forEach(d => bLoc[d] = 0);
+                const bIndex = locToIndex(bLoc, bRank, bStrides);
+                const opResult = op(aVals[aIndex * 2], aVals[aIndex * 2 + 1], bVals[bIndex * 2], bVals[bIndex * 2 + 1]);
+                resultRealVals[i] = opResult.real;
+                resultImagVals[i] = opResult.imag;
+            }
+        }
+        return [resultRealVals, resultImagVals, resultShape];
+    };
+}
 
 
 const addImpl = createSimpleBinaryKernelImpl(((a, b) => a + b));
+const addComplexImpl = createComplexBinaryKernelImpl(((aReal, aImag, bReal, bImag) => {
+    return { real: aReal + bReal, imag: aImag + bImag };
+}));
+const add = binaryKernelFunc$1(Add, addImpl, addComplexImpl);
+const addConfig$1 = {
+    kernelName: Add,
+    backendName: 'cpu',
+    kernelFunc: add
+};
 
 
 function bincountImpl(xVals, weightsVals, weightsDtype, weightsShape, size) {
@@ -15137,6 +15412,12 @@ function bincountReduceImpl(xBuf, weightsBuf, size, binaryOutput = false) {
 
 
 const bitwiseAndImpl = createSimpleBinaryKernelImpl(((a, b) => a & b));
+const bitwiseAnd$1 = binaryKernelFunc$1(BitwiseAnd, bitwiseAndImpl);
+const bitwiseAndConfig$1 = {
+    kernelName: BitwiseAnd,
+    backendName: 'cpu',
+    kernelFunc: bitwiseAnd$1
+};
 
 
 
@@ -15151,7 +15432,42 @@ function createSimpleUnaryImpl(op) {
 }
 
 
+
+function unaryKernelFunc$1(name, op, dtype) {
+    const impl = createSimpleUnaryImpl(op);
+    return unaryKernelFuncFromImpl(name, impl, dtype);
+}
+
+function unaryKernelFuncFromImpl(name, unaryImpl, dtype) {
+    return ({ inputs, attrs, backend }) => {
+        const { x } = inputs;
+        assertNotComplex(x, name);
+        const cpuBackend = backend;
+        const values = cpuBackend.data.get(x.dataId).values;
+        let decoded;
+        if (x.dtype === 'string') {
+            if (!Array.isArray(values)) {
+                throw new Error('String tensor\'s value was not an instance of Array');
+            }
+            decoded = fromUint8ToStringArray(values);
+        }
+        else {
+            decoded = values;
+        }
+        const $dtype = dtype || x.dtype;
+        const newValues = unaryImpl(decoded, $dtype, attrs);
+        return cpuBackend.makeTensorInfo(x.shape, $dtype, newValues);
+    };
+}
+
+
 const ceilImpl = createSimpleUnaryImpl((xi) => Math.ceil(xi));
+const ceil$1 = unaryKernelFuncFromImpl(Ceil, ceilImpl);
+const ceilConfig$1 = {
+    kernelName: Ceil,
+    backendName: 'cpu',
+    kernelFunc: ceil$1,
+};
 
 
 function concatImpl$1(inputs, outShape, dtype, simplyConcat) {
@@ -15186,18 +15502,48 @@ function concatImpl$1(inputs, outShape, dtype, simplyConcat) {
 
 
 const equalImpl = createSimpleBinaryKernelImpl((a, b) => (a === b) ? 1 : 0);
+const equal$1 = binaryKernelFunc$1(Equal, equalImpl, null , 'bool');
+const equalConfig$1 = {
+    kernelName: Equal,
+    backendName: 'cpu',
+    kernelFunc: equal$1
+};
 
 
 const expImpl = createSimpleUnaryImpl((xi) => Math.exp(xi));
+const exp$1 = unaryKernelFuncFromImpl(Exp, expImpl, 'float32');
+const expConfig$1 = {
+    kernelName: Exp,
+    backendName: 'cpu',
+    kernelFunc: exp$1,
+};
 
 
 const expm1Impl = createSimpleUnaryImpl((xi) => Math.expm1(xi));
+const expm1$1 = unaryKernelFuncFromImpl(Expm1, expm1Impl);
+const expm1Config$1 = {
+    kernelName: Expm1,
+    backendName: 'cpu',
+    kernelFunc: expm1$1,
+};
 
 
 const floorImpl = createSimpleUnaryImpl((xi) => Math.floor(xi));
+const floor$1 = unaryKernelFuncFromImpl(Floor, floorImpl);
+const floorConfig$1 = {
+    kernelName: Floor,
+    backendName: 'cpu',
+    kernelFunc: floor$1,
+};
 
 
 const floorDivImpl = createSimpleBinaryKernelImpl((a, b) => Math.floor(a / b));
+const floorDiv$1 = binaryKernelFunc$1(FloorDiv, floorDivImpl, null , 'int32');
+const floorDivConfig$1 = {
+    kernelName: FloorDiv,
+    backendName: 'cpu',
+    kernelFunc: floorDiv$1
+};
 
 
 function gatherNdImpl(indicesData, paramsBuf, dtype, numSlices, sliceRank, sliceSize, strides, paramsShape, paramsSize) {
@@ -15241,15 +15587,39 @@ function gatherV2Impl(xBuf, indicesBuf, flattenOutputShape) {
 
 
 const greaterImpl = createSimpleBinaryKernelImpl((a, b) => (a > b) ? 1 : 0);
+const greater$1 = binaryKernelFunc$1(Greater, greaterImpl, null , 'bool');
+const greaterConfig$1 = {
+    kernelName: Greater,
+    backendName: 'cpu',
+    kernelFunc: greater$1
+};
 
 
 const greaterEqualImpl = createSimpleBinaryKernelImpl((a, b) => (a >= b) ? 1 : 0);
+const greaterEqual$1 = binaryKernelFunc$1(GreaterEqual, greaterEqualImpl, null , 'bool');
+const greaterEqualConfig$1 = {
+    kernelName: GreaterEqual,
+    backendName: 'cpu',
+    kernelFunc: greaterEqual$1
+};
 
 
 const lessImpl = createSimpleBinaryKernelImpl((a, b) => (a < b) ? 1 : 0);
+const less$1 = binaryKernelFunc$1(Less, lessImpl, null , 'bool');
+const lessConfig$1 = {
+    kernelName: Less,
+    backendName: 'cpu',
+    kernelFunc: less$1
+};
 
 
 const lessEqualImpl = createSimpleBinaryKernelImpl((a, b) => (a <= b) ? 1 : 0);
+const lessEqual$1 = binaryKernelFunc$1(LessEqual, lessEqualImpl, null , 'bool');
+const lessEqualConfig$1 = {
+    kernelName: LessEqual,
+    backendName: 'cpu',
+    kernelFunc: lessEqual$1
+};
 
 
 function linSpaceImpl(start, stop, num) {
@@ -15264,6 +15634,12 @@ function linSpaceImpl(start, stop, num) {
 
 
 const logImpl = createSimpleUnaryImpl((xi) => Math.log(xi));
+const log$1 = unaryKernelFuncFromImpl(Log, logImpl);
+const logConfig$1 = {
+    kernelName: Log,
+    backendName: 'cpu',
+    kernelFunc: log$1,
+};
 
 
 function maxImpl$1(aVals, reduceSize, outShape, dtype) {
@@ -15285,21 +15661,64 @@ function maxImpl$1(aVals, reduceSize, outShape, dtype) {
 
 
 const maximumImpl = createSimpleBinaryKernelImpl(((aValue, bValue) => Math.max(aValue, bValue)));
+const maximum$1 = binaryKernelFunc$1(Maximum, maximumImpl);
+const maximumConfig$1 = {
+    kernelName: Maximum,
+    backendName: 'cpu',
+    kernelFunc: maximum$1
+};
 
 
 const minimumImpl = createSimpleBinaryKernelImpl(((aValue, bValue) => Math.min(aValue, bValue)));
+const minimum$1 = binaryKernelFunc$1(Minimum, minimumImpl);
+const minimumConfig$1 = {
+    kernelName: Minimum,
+    backendName: 'cpu',
+    kernelFunc: minimum$1
+};
 
 
 const multiplyImpl = createSimpleBinaryKernelImpl(((aValue, bValue) => aValue * bValue));
+const multiplyComplexImpl = createComplexBinaryKernelImpl(((aReal, aImag, bReal, bImag) => {
+    return {
+        real: aReal * bReal - aImag * bImag,
+        imag: aReal * bImag + aImag * bReal
+    };
+}));
+const multiply$1 = binaryKernelFunc$1(Multiply, multiplyImpl, multiplyComplexImpl);
+const multiplyConfig$1 = {
+    kernelName: Multiply,
+    backendName: 'cpu',
+    kernelFunc: multiply$1
+};
 
 
 function negImpl(xVals, xShape, xDtype) {
     const minusOne = createScalarValue(-1, xDtype);
     return multiplyImpl([], xShape, minusOne, xVals, xDtype);
 }
+function neg$1(args) {
+    const { inputs, backend } = args;
+    const { x } = inputs;
+    assertNotComplex(x, 'neg');
+    const xVals = backend.data.get(x.dataId).values;
+    const [res, newShape] = negImpl(xVals, x.shape, x.dtype);
+    return backend.makeTensorInfo(newShape, x.dtype, res);
+}
+const negConfig$1 = {
+    kernelName: Neg,
+    backendName: 'cpu',
+    kernelFunc: neg$1
+};
 
 
 const notEqualImpl = createSimpleBinaryKernelImpl(((a, b) => (a !== b) ? 1 : 0));
+const notEqual$1 = binaryKernelFunc$1(NotEqual, notEqualImpl, null , 'bool');
+const notEqualConfig$1 = {
+    kernelName: NotEqual,
+    backendName: 'cpu',
+    kernelFunc: notEqual$1
+};
 
 
 function transposeImpl$1(xVals, xShape, dtype, perm, newShape) {
@@ -15322,6 +15741,28 @@ function transposeImpl$1(xVals, xShape, dtype, perm, newShape) {
 }
 
 
+function transpose$1(args) {
+    const { inputs, attrs, backend } = args;
+    const { x } = inputs;
+    const { perm } = attrs;
+    assertNotComplex(x, 'transpose');
+    const xRank = x.shape.length;
+    const newShape = new Array(xRank);
+    for (let i = 0; i < newShape.length; i++) {
+        newShape[i] = x.shape[perm[i]];
+    }
+    const values = backend.data.get(x.dataId).values;
+    const result = transposeImpl$1(values, x.shape, x.dtype, perm, newShape);
+    const dataId = backend.write(result, newShape, x.dtype);
+    return { dataId, shape: newShape, dtype: x.dtype };
+}
+const transposeConfig$1 = {
+    kernelName: Transpose,
+    backendName: 'cpu',
+    kernelFunc: transpose$1
+};
+
+
 function prodImpl(xShape, xDtype, xVals, reductionAxes) {
     const [outShape, reduceShape] = computeOutAndReduceShapes(xShape, reductionAxes);
     const outDtype = upcastType(xDtype, 'int32');
@@ -15337,6 +15778,36 @@ function prodImpl(xShape, xDtype, xVals, reductionAxes) {
     }
     return { outVals, outShape, outDtype };
 }
+function prod$1(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, keepDims } = attrs;
+    assertNotComplex(x, 'prod');
+    const xRank = x.shape.length;
+    const axes = parseAxisParam(axis, x.shape);
+    const permutation = getAxesPermutation(axes, xRank);
+    let reductionAxes = axes;
+    let permutedX = x;
+    const intermediateTensorInfos = [];
+    if (permutation != null) {
+        permutedX = transpose$1({ inputs: { x }, backend, attrs: { perm: permutation } });
+        intermediateTensorInfos.push(permutedX);
+        reductionAxes = getInnerMostAxes(reductionAxes.length, xRank);
+    }
+    const xVals = backend.data.get(permutedX.dataId).values;
+    const { outVals, outShape, outDtype } = prodImpl(permutedX.shape, permutedX.dtype, xVals, reductionAxes);
+    let resultShape = outShape;
+    if (keepDims) {
+        resultShape = expandShapeToKeepDim(outShape, axes);
+    }
+    intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return backend.makeTensorInfo(resultShape, outDtype, outVals);
+}
+const prodConfig$1 = {
+    kernelName: Prod,
+    backendName: 'cpu',
+    kernelFunc: prod$1
+};
 
 
 function validateIndices(indices, indicesShape, numParams) {
@@ -15849,7 +16320,7 @@ class RaggedTensorToTensorOp {
         if (defaultValue.length !== valueElementSize && defaultValue.length !== 1) {
             const srcShape = this.defaultValueShape;
             tidy(() => {
-                const defaultValueTensor = reshape$1(defaultValue, srcShape);
+                const defaultValueTensor = reshape$2(defaultValue, srcShape);
                 const bCastDefault = broadcastTo(defaultValueTensor, elementShape);
                 defaultValue = bCastDefault.dataSync();
             });
@@ -15967,6 +16438,12 @@ function rangeImpl(start, stop, step, dtype) {
 
 
 const rsqrtImpl = createSimpleUnaryImpl((xi) => 1 / Math.sqrt(xi));
+const rsqrt$1 = unaryKernelFuncFromImpl(Rsqrt, rsqrtImpl);
+const rsqrtConfig$1 = {
+    kernelName: Rsqrt,
+    backendName: 'cpu',
+    kernelFunc: rsqrt$1,
+};
 
 
 function scatterImpl(indices, updates, shape, outputSize, sliceSize, numUpdates, sliceRank, strides, defaultValue, sumDupeIndices) {
@@ -16016,6 +16493,12 @@ function scatterImpl(indices, updates, shape, outputSize, sliceSize, numUpdates,
 
 
 const sigmoidImpl = createSimpleUnaryImpl((xi) => 1 / (1 + Math.exp(-xi)));
+const sigmoid$1 = unaryKernelFunc$1(Sigmoid$1, (xi) => 1 / (1 + Math.exp(-xi)));
+const sigmoidConfig$1 = {
+    kernelName: Sigmoid$1,
+    backendName: 'cpu',
+    kernelFunc: sigmoid$1,
+};
 
 
 function sliceImpl(vals, begin, size, shape, dtype) {
@@ -16044,6 +16527,22 @@ function sliceImpl(vals, begin, size, shape, dtype) {
     }
     return outBuf.values;
 }
+function slice$1(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { begin, size } = attrs;
+    assertNotComplex(x, 'slice');
+    const [$begin, $size] = parseSliceParams(x, begin, size);
+    assertParamsValid(x, $begin, $size);
+    const vals = backend.data.get(x.dataId).values;
+    const outVals = sliceImpl(vals, $begin, $size, x.shape, x.dtype);
+    return backend.makeTensorInfo($size, x.dtype, outVals);
+}
+const sliceConfig$1 = {
+    kernelName: Slice,
+    backendName: 'cpu',
+    kernelFunc: slice$1
+};
 
 
 function sparseFillEmptyRowsImpl(indices, indicesShape, indicesDType, values, valuesDType, denseShape, defaultValue) {
@@ -16307,12 +16806,24 @@ function sparseSegmentReductionImpl(input, inputShape, inputDType, indices, segm
 
 
 const sqrtImpl = createSimpleUnaryImpl((xi) => Math.sqrt(xi));
+const sqrt$1 = unaryKernelFunc$1(Sqrt, (xi) => Math.sqrt(xi));
+const sqrtConfig$1 = {
+    kernelName: Sqrt,
+    backendName: 'cpu',
+    kernelFunc: sqrt$1,
+};
 
 
 const squaredDifferenceImpl = createSimpleBinaryKernelImpl(((a, b) => {
     const diff = a - b;
     return diff * diff;
 }));
+const squaredDifference$1 = binaryKernelFunc$1(SquaredDifference, squaredDifferenceImpl);
+const squaredDifferenceConfig$1 = {
+    kernelName: SquaredDifference,
+    backendName: 'cpu',
+    kernelFunc: squaredDifference$1
+};
 
 
 const staticRegexReplaceImpl = createSimpleUnaryImpl((x, attrs) => {
@@ -16320,6 +16831,12 @@ const staticRegexReplaceImpl = createSimpleUnaryImpl((x, attrs) => {
     
     return x.replace(new RegExp(pattern, replaceGlobal ? 'g' : ''), rewrite);
 });
+const staticRegexReplace$1 = unaryKernelFuncFromImpl(StaticRegexReplace, staticRegexReplaceImpl);
+const staticRegexReplaceConfig$1 = {
+    kernelName: StaticRegexReplace,
+    backendName: 'cpu',
+    kernelFunc: staticRegexReplace$1,
+};
 
 
 function stridedSliceImpl(outShape, xBuf, strides, begin) {
@@ -16586,6 +17103,15 @@ function stringToHashBucketFastImpl(input, numBuckets) {
 
 
 const subImpl = createSimpleBinaryKernelImpl(((aValue, bValue) => aValue - bValue));
+const subComplexImpl = createComplexBinaryKernelImpl(((aReal, aImag, bReal, bImag) => {
+    return { real: aReal - bReal, imag: aImag - bImag };
+}));
+const sub$1 = binaryKernelFunc$1(Sub, subImpl, subComplexImpl);
+const subConfig$1 = {
+    kernelName: Sub,
+    backendName: 'cpu',
+    kernelFunc: sub$1
+};
 
 
 
@@ -16614,7 +17140,7 @@ const comparePair = (a, b) => {
     return valueDiff === 0 ? a.index - b.index : valueDiff;
 };
 
-function select$1(array, k, left = 0, right = array.length - 1) {
+function select$2(array, k, left = 0, right = array.length - 1) {
     while (right > left) {
         
         
@@ -16627,7 +17153,7 @@ function select$1(array, k, left = 0, right = array.length - 1) {
             const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * Math.sign(i - n / 2);
             const newLeft = Math.max(left, Math.floor(k - i * s / n + sd));
             const newRight = Math.min(right, Math.floor(k + (n - i) * s / n + sd));
-            select$1(array, k, newLeft, newRight);
+            select$2(array, k, newLeft, newRight);
         }
         
         const t = array[k];
@@ -16677,7 +17203,7 @@ function topKImpl(x, xShape, xDtype, k, sorted) {
         let valAndInd = new Array(vals.length);
         vals.forEach((value, index) => valAndInd[index] = { value, index });
         if (k < valAndInd.length) {
-            select$1(valAndInd, k);
+            select$2(valAndInd, k);
             valAndInd = valAndInd.slice(0, k);
         }
         if (sorted) {
@@ -17422,7 +17948,7 @@ class UnpackProgram {
 
 
 
-const whereImpl = whereImpl$1;
+const whereImpl$1 = whereImpl$2;
 const EPSILON_FLOAT32 = 1e-7;
 const EPSILON_FLOAT16 = 1e-4;
 const binaryCaches = {};
@@ -17831,7 +18357,7 @@ class MathBackendWebGL extends KernelBackend {
             if (env().getNumber('WEBGL_DISJOINT_QUERY_TIMER_EXTENSION_RELIABLE') >
                 0) {
                 const kernelMs = await Promise.all(flattenedActiveTimerQueries);
-                res['kernelMs'] = sum$2(kernelMs);
+                res['kernelMs'] = sum$3(kernelMs);
                 res['getExtraProfileInfo'] = () => kernelMs
                     .map((d, i) => ({ name: flattenedActiveTimerNames[i], ms: d }))
                     .map(d => `${d.name}: ${d.ms}`)
@@ -17952,7 +18478,7 @@ class MathBackendWebGL extends KernelBackend {
         warn('tf.where() in webgl locks the UI thread. ' +
             'Call tf.whereAsync() instead');
         const condVals = condition.dataSync();
-        return whereImpl(condition.shape, condVals);
+        return whereImpl$1(condition.shape, condVals);
     }
     packedUnaryOp(x, op, dtype) {
         const program = new UnaryOpPackedProgram(x.shape, op);
@@ -18586,7 +19112,7 @@ const LEAKYRELU_PACKED = `
   vec4 aLessThanZero = vec4(lessThan(a, vec4(0.)));
   return (aLessThanZero * (b * a)) + ((vec4(1.0) - aLessThanZero) * a);
 `;
-function leakyRelu(args) {
+function leakyRelu$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { alpha } = attrs;
@@ -18598,10 +19124,10 @@ function leakyRelu(args) {
     backend.disposeIntermediateTensorInfo($alpha);
     return result;
 }
-const leakyReluConfig = {
+const leakyReluConfig$1 = {
     kernelName: LeakyRelu,
     backendName: 'webgl',
-    kernelFunc: leakyRelu
+    kernelFunc: leakyRelu$1
 };
 
 
@@ -18610,7 +19136,7 @@ const PRELU_PACKED = `
   vec4 aLessThanZero = vec4(lessThan(a, vec4(0.)));
   return (aLessThanZero * (b * a)) + ((vec4(1.0) - aLessThanZero) * a);
 `;
-function prelu(args) {
+function prelu$1(args) {
     const { inputs, backend } = args;
     const { x, alpha } = inputs;
     const program = env().getBool('WEBGL_PACK_BINARY_OPERATIONS') ?
@@ -18618,10 +19144,10 @@ function prelu(args) {
         new BinaryOpProgram(PRELU, x.shape, alpha.shape);
     return backend.runWebGLProgram(program, [x, alpha], 'float32');
 }
-const preluConfig = {
+const preluConfig$1 = {
     kernelName: Prelu,
     backendName: 'webgl',
-    kernelFunc: prelu
+    kernelFunc: prelu$1
 };
 
 
@@ -18960,7 +19486,7 @@ function packedReshape(input, afterShape, backend) {
 }
 
 
-function reshape(args) {
+function reshape$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { shape } = attrs;
@@ -18979,10 +19505,10 @@ function reshape(args) {
     webglBackend.incRef(x.dataId);
     return { dataId: x.dataId, shape: $shape, dtype: x.dtype };
 }
-const reshapeConfig = {
+const reshapeConfig$1 = {
     kernelName: Reshape$1,
     backendName: 'webgl',
-    kernelFunc: reshape
+    kernelFunc: reshape$1
 };
 
 
@@ -19358,10 +19884,10 @@ function sumImpl(x, axis, keepDims, backend) {
     const inSize = sizeFromShape(reduceShape);
     const xSize = sizeFromShape(x.shape);
     const batchSize = xSize / inSize;
-    const reshapedInput = reshape({ inputs: { x: sumInput }, attrs: { shape: [batchSize, inSize] }, backend });
+    const reshapedInput = reshape$1({ inputs: { x: sumInput }, attrs: { shape: [batchSize, inSize] }, backend });
     const outType = sumOutType(x.dtype);
     const reduced = reduce(reshapedInput, outType, 'sum', backend);
-    const out = reshape({ inputs: { x: reduced }, attrs: { shape: outShape }, backend });
+    const out = reshape$1({ inputs: { x: reduced }, attrs: { shape: outShape }, backend });
     backend.disposeIntermediateTensorInfo(reshapedInput);
     backend.disposeIntermediateTensorInfo(reduced);
     if (sumInputIsTransposed) {
@@ -19371,16 +19897,16 @@ function sumImpl(x, axis, keepDims, backend) {
 }
 
 
-function sum(args) {
+function sum$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis, keepDims } = attrs;
     return sumImpl(x, axis, keepDims, backend);
 }
-const sumConfig = {
+const sumConfig$1 = {
     kernelName: Sum,
     backendName: 'webgl',
-    kernelFunc: sum
+    kernelFunc: sum$1
 };
 
 
@@ -19443,8 +19969,8 @@ function batchMatMulImpl({ a, b, transposeA, transposeB, backend, bias = null, p
         [batchDimB, outerShapeB, innerShapeB] :
         [batchDimB, innerShapeB, outerShapeB];
     
-    const a3d = reshape({ inputs: { x: a }, backend, attrs: { shape: a3dShape } });
-    const b3d = reshape({ inputs: { x: b }, backend, attrs: { shape: b3dShape } });
+    const a3d = reshape$1({ inputs: { x: a }, backend, attrs: { shape: a3dShape } });
+    const b3d = reshape$1({ inputs: { x: b }, backend, attrs: { shape: b3dShape } });
     const intermediates = [a3d, b3d];
     const batchDim = Math.max(batchDimA, batchDimB);
     const sharedDim = transposeA ? a3d.shape[1] : a3d.shape[2];
@@ -19475,7 +20001,7 @@ function batchMatMulImpl({ a, b, transposeA, transposeB, backend, bias = null, p
         const shouldReshapeB = outerShapeB === 1;
         let aVec3d = aVec;
         if (shouldReshapeA) {
-            aVec3d = reshape({
+            aVec3d = reshape$1({
                 inputs: { x: aVec },
                 backend,
                 attrs: { shape: [batchDim, sharedDim, 1] }
@@ -19485,7 +20011,7 @@ function batchMatMulImpl({ a, b, transposeA, transposeB, backend, bias = null, p
         const axis = outerShapeB === 1 ? 2 : 1;
         let bVec3d = bVec;
         if (shouldReshapeB) {
-            bVec3d = reshape({
+            bVec3d = reshape$1({
                 inputs: { x: bVec },
                 backend,
                 attrs: { shape: [batchDim, 1, sharedDim] }
@@ -19493,7 +20019,7 @@ function batchMatMulImpl({ a, b, transposeA, transposeB, backend, bias = null, p
             intermediates.push(bVec3d);
         }
         const product = multiply({ inputs: { a: aVec3d, b: bVec3d }, backend });
-        out = sum({ inputs: { x: product }, backend, attrs: { axis, keepDims: true } });
+        out = sum$1({ inputs: { x: product }, backend, attrs: { axis, keepDims: true } });
         intermediates.push(product);
     }
     else {
@@ -19513,7 +20039,7 @@ function batchMatMulImpl({ a, b, transposeA, transposeB, backend, bias = null, p
         }
         out = backend.runWebGLProgram(program, inputs, dtype);
     }
-    const outReshaped = reshape({ inputs: { x: out }, backend, attrs: { shape: outShape } });
+    const outReshaped = reshape$1({ inputs: { x: out }, backend, attrs: { shape: outShape } });
     intermediates.push(out);
     for (const i of intermediates) {
         backend.disposeIntermediateTensorInfo(i);
@@ -19522,7 +20048,7 @@ function batchMatMulImpl({ a, b, transposeA, transposeB, backend, bias = null, p
 }
 
 
-function _fusedMatMul(args) {
+function _fusedMatMul$1(args) {
     const { inputs, backend, attrs } = args;
     const { a, b, bias, preluActivationWeights } = inputs;
     const { transposeA, transposeB, activation, leakyreluAlpha } = attrs;
@@ -19538,10 +20064,10 @@ function _fusedMatMul(args) {
         activation
     });
 }
-const _fusedMatMulConfig = {
+const _fusedMatMulConfig$1 = {
     kernelName: _FusedMatMul,
     backendName: 'webgl',
-    kernelFunc: _fusedMatMul,
+    kernelFunc: _fusedMatMul$1,
 };
 
 
@@ -19578,22 +20104,22 @@ const ACOS = CHECK_NAN_SNIPPET$1 + `
   }
   return acos(x);
 `;
-const acos = unaryKernelFunc({ opSnippet: ACOS });
-const acosConfig = {
+const acos$1 = unaryKernelFunc({ opSnippet: ACOS });
+const acosConfig$1 = {
     kernelName: Acos,
     backendName: 'webgl',
-    kernelFunc: acos,
+    kernelFunc: acos$1,
 };
 
 
 const ACOSH = CHECK_NAN_SNIPPET$1 + `
   if (x < 1.0) return NAN;
 return log(x + sqrt(x * x - 1.0));`;
-const acosh = unaryKernelFunc({ opSnippet: ACOSH });
-const acoshConfig = {
+const acosh$1 = unaryKernelFunc({ opSnippet: ACOSH });
+const acoshConfig$1 = {
     kernelName: Acosh,
     backendName: 'webgl',
-    kernelFunc: acosh,
+    kernelFunc: acosh$1,
 };
 
 
@@ -19669,7 +20195,7 @@ class AddNPackedProgram {
 }
 
 
-function addN(args) {
+function addN$1(args) {
     const { inputs, backend } = args;
     const tensors = inputs;
     if (tensors.length === 1) {
@@ -19678,9 +20204,9 @@ function addN(args) {
     
     if (tensors.length > env().getNumber('WEBGL_MAX_TEXTURES_IN_SHADER')) {
         const midIndex = Math.floor(tensors.length / 2);
-        const leftSide = addN({ inputs: tensors.slice(0, midIndex), backend });
-        const rightSide = addN({ inputs: tensors.slice(midIndex), backend });
-        return addN({ inputs: [leftSide, rightSide], backend });
+        const leftSide = addN$1({ inputs: tensors.slice(0, midIndex), backend });
+        const rightSide = addN$1({ inputs: tensors.slice(midIndex), backend });
+        return addN$1({ inputs: [leftSide, rightSide], backend });
     }
     const dtype = tensors.map(t => t.dtype).reduce((d1, d2) => upcastType(d1, d2));
     const shapes = tensors.map(t => t.shape);
@@ -19691,14 +20217,14 @@ function addN(args) {
         new AddNProgram(tensors[0].shape, shapes);
     return backend.runWebGLProgram(program, tensors, dtype);
 }
-const addNConfig = {
+const addNConfig$1 = {
     kernelName: AddN,
     backendName: 'webgl',
-    kernelFunc: addN
+    kernelFunc: addN$1
 };
 
 
-function all(args) {
+function all$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis, keepDims } = attrs;
@@ -19714,15 +20240,15 @@ function all(args) {
     assertAxesAreInnerMostDims('all', axes, xRank);
     const [outShape, reduceShape] = computeOutAndReduceShapes(permutedX.shape, axes);
     const inSize = sizeFromShape(reduceShape);
-    const a2D = reshape({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
+    const a2D = reshape$1({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
     const reduced = reduce(a2D, a2D.dtype, 'all', backend);
     let res;
     if (keepDims) {
         const newShape = expandShapeToKeepDim(outShape, origAxes);
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: newShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: newShape } });
     }
     else {
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
     }
     backend.disposeIntermediateTensorInfo(a2D);
     backend.disposeIntermediateTensorInfo(reduced);
@@ -19731,14 +20257,14 @@ function all(args) {
     }
     return res;
 }
-const allConfig = {
+const allConfig$1 = {
     kernelName: All,
     backendName: 'webgl',
-    kernelFunc: all
+    kernelFunc: all$1
 };
 
 
-function any(args) {
+function any$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis, keepDims } = attrs;
@@ -19754,15 +20280,15 @@ function any(args) {
     assertAxesAreInnerMostDims('any', axes, xRank);
     const [outShape, reduceShape] = computeOutAndReduceShapes(permutedX.shape, axes);
     const inSize = sizeFromShape(reduceShape);
-    const a2D = reshape({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
+    const a2D = reshape$1({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
     const reduced = reduce(a2D, a2D.dtype, 'any', backend);
     let res;
     if (keepDims) {
         const newShape = expandShapeToKeepDim(outShape, origAxes);
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: newShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: newShape } });
     }
     else {
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
     }
     backend.disposeIntermediateTensorInfo(a2D);
     backend.disposeIntermediateTensorInfo(reduced);
@@ -19771,10 +20297,10 @@ function any(args) {
     }
     return res;
 }
-const anyConfig = {
+const anyConfig$1 = {
     kernelName: Any,
     backendName: 'webgl',
-    kernelFunc: any
+    kernelFunc: any$1
 };
 
 
@@ -19977,11 +20503,11 @@ function argMinMaxReduce(backend, x, axis, reduceType) {
         }
         const [outShape, reduceShape] = computeOutAndReduceShapes(xUnPacked.shape, axes);
         const inSize = sizeFromShape(reduceShape);
-        const a2D = reshape({ inputs: { x: xUnPacked }, backend, attrs: { shape: [-1, inSize] } });
+        const a2D = reshape$1({ inputs: { x: xUnPacked }, backend, attrs: { shape: [-1, inSize] } });
         intermediateTensorInfos.push(a2D);
         const reduced = argReduce(backend, a2D, reduceType);
         intermediateTensorInfos.push(reduced);
-        const reshaped = reshape({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
+        const reshaped = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
         intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
         return reshaped;
     }
@@ -19989,7 +20515,7 @@ function argMinMaxReduce(backend, x, axis, reduceType) {
 }
 
 
-function argMax(args) {
+function argMax$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis } = attrs;
@@ -20007,14 +20533,14 @@ function argMax(args) {
     intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return out;
 }
-const argMaxConfig = {
+const argMaxConfig$1 = {
     kernelName: ArgMax,
     backendName: 'webgl',
-    kernelFunc: argMax
+    kernelFunc: argMax$1
 };
 
 
-function argMin(args) {
+function argMin$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis } = attrs;
@@ -20032,10 +20558,10 @@ function argMin(args) {
     intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return out;
 }
-const argMinConfig = {
+const argMinConfig$1 = {
     kernelName: ArgMin,
     backendName: 'webgl',
-    kernelFunc: argMin
+    kernelFunc: argMin$1
 };
 
 
@@ -20045,31 +20571,31 @@ const ASIN = CHECK_NAN_SNIPPET$1 + `
   }
   return asin(x);
 `;
-const asin = unaryKernelFunc({ opSnippet: ASIN });
-const asinConfig = {
+const asin$1 = unaryKernelFunc({ opSnippet: ASIN });
+const asinConfig$1 = {
     kernelName: Asin,
     backendName: 'webgl',
-    kernelFunc: asin,
+    kernelFunc: asin$1,
 };
 
 
 const ASINH = CHECK_NAN_SNIPPET$1 + `return log(x + sqrt(x * x + 1.0));`;
-const asinh = unaryKernelFunc({ opSnippet: ASINH });
-const asinhConfig = {
+const asinh$1 = unaryKernelFunc({ opSnippet: ASINH });
+const asinhConfig$1 = {
     kernelName: Asinh,
     backendName: 'webgl',
-    kernelFunc: asinh,
+    kernelFunc: asinh$1,
 };
 
 
 const ATAN = CHECK_NAN_SNIPPET$1 + `
   return atan(x);
 `;
-const atan = unaryKernelFunc({ opSnippet: ATAN });
-const atanConfig = {
+const atan$1 = unaryKernelFunc({ opSnippet: ATAN });
+const atanConfig$1 = {
     kernelName: Atan,
     backendName: 'webgl',
-    kernelFunc: atan,
+    kernelFunc: atan$1,
 };
 
 
@@ -20085,22 +20611,22 @@ const ATAN2_PACKED = `
     CHECK_NAN_SNIPPET_PACKED + `
   return result;
 `;
-const atan2 = binaryKernelFunc({ opSnippet: ATAN2, packedOpSnippet: ATAN2_PACKED });
-const atan2Config = {
+const atan2$1 = binaryKernelFunc({ opSnippet: ATAN2, packedOpSnippet: ATAN2_PACKED });
+const atan2Config$1 = {
     kernelName: Atan2,
     backendName: 'webgl',
-    kernelFunc: atan2,
+    kernelFunc: atan2$1,
 };
 
 
 const ATANH = CHECK_NAN_SNIPPET$1 + `
   if ((x < -1.0) || (x > 1.0)) return NAN;
 return (log(1.0 + x) - log(1.0 - x)) / 2.0;`;
-const atanh = unaryKernelFunc({ opSnippet: ATANH });
-const atanhConfig = {
+const atanh$1 = unaryKernelFunc({ opSnippet: ATANH });
+const atanhConfig$1 = {
     kernelName: Atanh,
     backendName: 'webgl',
-    kernelFunc: atanh,
+    kernelFunc: atanh$1,
 };
 
 
@@ -20503,10 +21029,10 @@ class Pool3DProgram {
 }
 
 
-function avgPool(args) {
+function avgPool$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
-    assertNotComplex(x, 'avgPool');
+    assertNotComplex$1(x, 'avgPool');
     const { filterSize, strides, pad, dimRoundingMode } = attrs;
     const dilations = 1;
     assert$1(eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in avgPool: Either strides or dilations must be 1. ' +
@@ -20519,14 +21045,14 @@ function avgPool(args) {
     const avgPoolProgram = new Pool2DProgram(convInfo, 'avg', false);
     return backend.runWebGLProgram(avgPoolProgram, [x], 'float32');
 }
-const avgPoolConfig = {
+const avgPoolConfig$1 = {
     kernelName: AvgPool,
     backendName: 'webgl',
-    kernelFunc: avgPool
+    kernelFunc: avgPool$1
 };
 
 
-function avgPool3D(args) {
+function avgPool3D$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { filterSize, strides, pad, dimRoundingMode, dataFormat } = attrs;
@@ -20535,10 +21061,10 @@ function avgPool3D(args) {
     const avgPoolProgram = new Pool3DProgram(convInfo, 'avg', false);
     return backend.runWebGLProgram(avgPoolProgram, [x], 'float32');
 }
-const avgPool3DConfig = {
+const avgPool3DConfig$1 = {
     kernelName: AvgPool3D,
     backendName: 'webgl',
-    kernelFunc: avgPool3D
+    kernelFunc: avgPool3D$1
 };
 
 
@@ -20683,7 +21209,7 @@ class AvgPool3DBackpropProgram {
 }
 
 
-function avgPool3DGrad(args) {
+function avgPool3DGrad$1(args) {
     const { inputs, backend, attrs } = args;
     const { dy, input } = inputs;
     const x = input;
@@ -20693,40 +21219,40 @@ function avgPool3DGrad(args) {
     const avgPoolBackpropProgram = new AvgPool3DBackpropProgram(convInfo);
     return backend.runWebGLProgram(avgPoolBackpropProgram, [dy], x.dtype);
 }
-const avgPool3DGradConfig$1 = {
+const avgPool3DGradConfig$2 = {
     kernelName: AvgPool3DGrad,
     backendName: 'webgl',
-    kernelFunc: avgPool3DGrad
+    kernelFunc: avgPool3DGrad$1
 };
 
 
-function avgPoolGrad$1(args) {
+function avgPoolGrad$2(args) {
     const { inputs, backend, attrs } = args;
     const { dy, input } = inputs;
     const x = input;
-    assertNotComplex([dy, input], 'avgPoolGrad');
+    assertNotComplex$1([dy, input], 'avgPoolGrad');
     const { filterSize, strides, pad } = attrs;
     const convInfo = computePool2DInfo(x.shape, filterSize, strides, 1 , pad);
     const avgPoolBackpropProgram = new AvgPool2DBackpropProgram(convInfo);
     return backend.runWebGLProgram(avgPoolBackpropProgram, [dy], x.dtype);
 }
-const avgPoolGradConfig$1 = {
+const avgPoolGradConfig$2 = {
     kernelName: AvgPoolGrad,
     backendName: 'webgl',
-    kernelFunc: avgPoolGrad$1
+    kernelFunc: avgPoolGrad$2
 };
 
 
-function batchMatMul(args) {
+function batchMatMul$1(args) {
     const { inputs, backend, attrs } = args;
     const { a, b } = inputs;
     const { transposeA, transposeB } = attrs;
     return batchMatMulImpl({ a, b, transposeA, transposeB, backend });
 }
-const batchMatMulConfig = {
+const batchMatMulConfig$1 = {
     kernelName: BatchMatMul,
     backendName: 'webgl',
-    kernelFunc: batchMatMul,
+    kernelFunc: batchMatMul$1,
 };
 
 
@@ -20802,7 +21328,7 @@ class BatchNormPackedProgram {
 }
 
 
-const batchNorm = ({ inputs, backend, attrs }) => {
+const batchNorm$1 = ({ inputs, backend, attrs }) => {
     const { x, mean, variance, offset, scale } = inputs;
     assert$1(mean.shape.length === variance.shape.length, () => 'Batch normalization gradient requires mean and variance to have ' +
         'equal ranks.');
@@ -20831,10 +21357,10 @@ const batchNorm = ({ inputs, backend, attrs }) => {
     const output = backend.runWebGLProgram(program, finalInputs, finalInputs[0].dtype);
     return output;
 };
-const batchNormConfig = {
+const batchNormConfig$1 = {
     kernelName: FusedBatchNorm,
     backendName: 'webgl',
-    kernelFunc: batchNorm,
+    kernelFunc: batchNorm$1,
 };
 
 
@@ -20993,7 +21519,7 @@ const sliceConfig = {
 };
 
 
-const batchToSpaceND = (args) => {
+const batchToSpaceND$1 = (args) => {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { blockShape, crops } = attrs;
@@ -21006,9 +21532,9 @@ const batchToSpaceND = (args) => {
     const sliceBeginCoords = getSliceBeginCoords(crops, blockShape.length);
     const sliceSize = getSliceSize(reshapedPermuted, crops, blockShape.length);
     const toDispose = [];
-    const reshapedIntermediate = reshape({ inputs: { x }, backend, attrs: { shape: reshaped } });
+    const reshapedIntermediate = reshape$1({ inputs: { x }, backend, attrs: { shape: reshaped } });
     const transposedIntermediate = transpose({ inputs: { x: reshapedIntermediate }, backend, attrs: { perm: permuted } });
-    const reshapedIntermediate2 = reshape({
+    const reshapedIntermediate2 = reshape$1({
         inputs: { x: transposedIntermediate },
         backend,
         attrs: { shape: reshapedPermuted }
@@ -21024,14 +21550,14 @@ const batchToSpaceND = (args) => {
     toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return sliced;
 };
-const batchToSpaceNDConfig = {
+const batchToSpaceNDConfig$1 = {
     kernelName: BatchToSpaceND,
     backendName: 'webgl',
-    kernelFunc: batchToSpaceND
+    kernelFunc: batchToSpaceND$1
 };
 
 
-function bincount(args) {
+function bincount$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, weights } = inputs;
     const { size } = attrs;
@@ -21040,10 +21566,10 @@ function bincount(args) {
     const outVals = bincountImplCPU(xVals, weightsVals, weights.dtype, weights.shape, size);
     return backend.makeTensorInfo([size], weights.dtype, outVals);
 }
-const bincountConfig = {
+const bincountConfig$1 = {
     kernelName: Bincount,
     backendName: 'webgl',
-    kernelFunc: bincount
+    kernelFunc: bincount$1
 };
 
 
@@ -21089,7 +21615,7 @@ const bitwiseAndConfig = {
 };
 
 
-function broadcastArgs(args) {
+function broadcastArgs$1(args) {
     const { inputs, backend } = args;
     const { s0, s1 } = inputs;
     const s0Vals = backend.readSync(s0.dataId);
@@ -21097,10 +21623,10 @@ function broadcastArgs(args) {
     const broadcastShape = assertAndGetBroadcastShape(Array.from(s0Vals), Array.from(s1Vals));
     return backend.makeTensorInfo([broadcastShape.length], 'int32', Int32Array.from(broadcastShape));
 }
-const broadcastArgsConfig = {
+const broadcastArgsConfig$1 = {
     kernelName: BroadcastArgs,
     backendName: 'webgl',
-    kernelFunc: broadcastArgs
+    kernelFunc: broadcastArgs$1
 };
 
 
@@ -21144,7 +21670,7 @@ function cast$1(args) {
             return identity({ inputs: { x }, backend });
         }
         
-        const zerosTensor = zeros(x.shape);
+        const zerosTensor = zeros$1(x.shape);
         const floatX = cast$1({ inputs: { x }, backend, attrs: { dtype: 'float32' } });
         const result = complex({ inputs: { real: floatX, imag: zerosTensor }, backend });
         zerosTensor.dispose();
@@ -21247,7 +21773,7 @@ class ClipPackedProgram {
 }
 
 
-function clipByValue(args) {
+function clipByValue$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { clipValueMin, clipValueMax } = attrs;
@@ -21261,10 +21787,10 @@ function clipByValue(args) {
     const customValues = [[clipValueMin], [clipValueMax]];
     return backend.runWebGLProgram(program, [x], x.dtype, customValues);
 }
-const clipByValueConfig = {
+const clipByValueConfig$1 = {
     kernelName: ClipByValue,
     backendName: 'webgl',
-    kernelFunc: clipByValue
+    kernelFunc: clipByValue$1
 };
 
 
@@ -21300,7 +21826,7 @@ function makeComplexComponentTensorInfo(complexTensor, complexPart) {
         shape: complexTensor.shape
     };
 }
-function complexAbs(args) {
+function complexAbs$1(args) {
     const { inputs, backend } = args;
     const { x } = inputs;
     const xData = backend.texData.get(x.dataId);
@@ -21311,10 +21837,10 @@ function complexAbs(args) {
     ];
     return backend.runWebGLProgram(program, programInputs, programInputs[0].dtype);
 }
-const complexAbsConfig = {
+const complexAbsConfig$1 = {
     kernelName: ComplexAbs,
     backendName: 'webgl',
-    kernelFunc: complexAbs
+    kernelFunc: complexAbs$1
 };
 
 
@@ -21438,16 +21964,16 @@ function shiftedChannels(channels, channel, shift) {
 }
 
 
-function imag(args) {
+function imag$1(args) {
     const { inputs, backend } = args;
     const { input } = inputs;
     const inputData = backend.texData.get(input.dataId);
     return identity({ inputs: { x: inputData.complexTensorInfos.imag }, backend });
 }
-const imagConfig = {
+const imagConfig$1 = {
     kernelName: Imag,
     backendName: 'webgl',
-    kernelFunc: imag
+    kernelFunc: imag$1
 };
 
 
@@ -21455,7 +21981,7 @@ function concatImpl(inputs, axis, backend) {
     const dtype = inputs[0].dtype;
     if (dtype === 'complex64') {
         const reals = inputs.map((t) => real({ inputs: { input: t }, backend }));
-        const imags = inputs.map((t) => imag({ inputs: { input: t }, backend }));
+        const imags = inputs.map((t) => imag$1({ inputs: { input: t }, backend }));
         const realConcated = concatImpl(reals, axis, backend);
         const imagConcated = concatImpl(imags, axis, backend);
         const result = complex({ inputs: { real: realConcated, imag: imagConcated }, backend });
@@ -21486,7 +22012,7 @@ function concatImpl(inputs, axis, backend) {
         const tensors2D = inputs.map(t => {
             const innerSize = sizeFromShape(t.shape.slice(axis));
             const shape = [-1, innerSize];
-            return reshape({ inputs: { x: t }, backend, attrs: { shape } });
+            return reshape$1({ inputs: { x: t }, backend, attrs: { shape } });
         });
         const inputsValShapes = tensors2D.map(t => {
             return { vals: backend.readSync(t.dataId), shape: t.shape };
@@ -21532,7 +22058,7 @@ function concatImpl(inputs, axis, backend) {
     const program = new ConcatProgram(tensors2D.map(t => t.shape));
     const result = backend.runWebGLProgram(program, tensors2D, dtype);
     tensors2D.forEach(r => backend.disposeIntermediateTensorInfo(r));
-    const reshapedResult = reshape({ inputs: { x: result }, attrs: { shape: outShape }, backend });
+    const reshapedResult = reshape$1({ inputs: { x: result }, attrs: { shape: outShape }, backend });
     backend.disposeIntermediateTensorInfo(result);
     return reshapedResult;
 }
@@ -21545,7 +22071,7 @@ function computeTensors2D(inputs, axis, backend) {
     
     
     const outShape = computeOutShape$1(inputs.map(t => t.shape), axis);
-    const tensors2D = inputs.map(x => reshape({
+    const tensors2D = inputs.map(x => reshape$1({
         inputs: { x },
         attrs: { shape: [-1, sizeFromShape(x.shape.slice(axis))] },
         backend
@@ -21554,7 +22080,7 @@ function computeTensors2D(inputs, axis, backend) {
 }
 
 
-function concat(args) {
+function concat$1(args) {
     const { inputs, backend, attrs } = args;
     const { axis } = attrs;
     const $axis = parseAxisParam(axis, inputs[0].shape)[0];
@@ -21571,10 +22097,10 @@ function concat(args) {
     }
     return concatImpl($inputs, $axis, backend);
 }
-const concatConfig = {
+const concatConfig$1 = {
     kernelName: Concat,
     backendName: 'webgl',
-    kernelFunc: concat
+    kernelFunc: concat$1
 };
 
 
@@ -22354,7 +22880,7 @@ function conv2dByMatMul({ x, filter, convInfo, backend, bias = null, preluActiva
     if (preluActivationWeights != null) {
         const targetShape = getShapeForBatchMatMul(preluActivationWeights.shape, isChannelsLast);
         if (targetShape != null) {
-            preluActivationWeights = reshape({
+            preluActivationWeights = reshape$1({
                 inputs: { x: preluActivationWeights },
                 backend,
                 attrs: { shape: targetShape }
@@ -22365,7 +22891,7 @@ function conv2dByMatMul({ x, filter, convInfo, backend, bias = null, preluActiva
     if (bias != null) {
         const targetShape = getShapeForBatchMatMul(bias.shape, isChannelsLast);
         if (targetShape != null) {
-            bias = reshape({ inputs: { x: bias }, backend, attrs: { shape: targetShape } });
+            bias = reshape$1({ inputs: { x: bias }, backend, attrs: { shape: targetShape } });
             intermediates.push(bias);
         }
     }
@@ -22405,7 +22931,7 @@ function conv2dByMatMul({ x, filter, convInfo, backend, bias = null, preluActiva
         xTexData.shape = xTexData.shape.slice();
         xTexData.shape[xTexData.shape.length - 2]++;
         assert$1(isReshapeFree(xTexData.shape, xReshaped.shape), () => `packed reshape ${xTexData.shape} to ${xReshaped.shape} isn't free`);
-        const filterReshaped = reshape({
+        const filterReshaped = reshape$1({
             inputs: { x: filter },
             backend,
             attrs: { shape: [1, convInfo.inChannels, convInfo.outChannels] }
@@ -22435,7 +22961,7 @@ function conv2dByMatMul({ x, filter, convInfo, backend, bias = null, preluActiva
     }
     else {
         const numCols = convInfo.outHeight * convInfo.outWidth;
-        const xReshaped = reshape({
+        const xReshaped = reshape$1({
             inputs: { x },
             backend,
             attrs: {
@@ -22444,7 +22970,7 @@ function conv2dByMatMul({ x, filter, convInfo, backend, bias = null, preluActiva
                     [convInfo.batchSize, convInfo.inChannels, numCols]
             }
         });
-        const filterReshaped = reshape({
+        const filterReshaped = reshape$1({
             inputs: { x: filter },
             backend,
             attrs: { shape: [1, convInfo.inChannels, convInfo.outChannels] }
@@ -22460,7 +22986,7 @@ function conv2dByMatMul({ x, filter, convInfo, backend, bias = null, preluActiva
             preluActivationWeights,
             leakyreluAlpha
         });
-        out = reshape({ inputs: { x: result }, backend, attrs: { shape: convInfo.outShape } });
+        out = reshape$1({ inputs: { x: result }, backend, attrs: { shape: convInfo.outShape } });
         intermediates.push(xReshaped);
         intermediates.push(filterReshaped);
         intermediates.push(result);
@@ -22490,7 +23016,7 @@ function conv2dWithIm2Row({ x, filter, convInfo, backend, bias = null, preluActi
     if (preluActivationWeights != null) {
         const targetShape = getShapeForBatchMatMul(preluActivationWeights.shape, isChannelsLast);
         if (targetShape != null) {
-            preluActivationWeights = reshape({
+            preluActivationWeights = reshape$1({
                 inputs: { x: preluActivationWeights },
                 backend,
                 attrs: { shape: targetShape }
@@ -22501,11 +23027,11 @@ function conv2dWithIm2Row({ x, filter, convInfo, backend, bias = null, preluActi
     if (bias != null) {
         const targetShape = getShapeForBatchMatMul(bias.shape, isChannelsLast);
         if (targetShape != null) {
-            bias = reshape({ inputs: { x: bias }, backend, attrs: { shape: targetShape } });
+            bias = reshape$1({ inputs: { x: bias }, backend, attrs: { shape: targetShape } });
             intermediates.push(bias);
         }
     }
-    const w2Row = reshape({
+    const w2Row = reshape$1({
         inputs: { x: filter },
         backend,
         attrs: { shape: [1, sharedDim, sizeFromShape(filter.shape) / sharedDim] }
@@ -22519,7 +23045,7 @@ function conv2dWithIm2Row({ x, filter, convInfo, backend, bias = null, preluActi
         [convInfo.filterWidth * convInfo.inChannels], [convInfo.outWidth]
     ];
     const im2Col = backend.runWebGLProgram(im2ColProgram, [x], 'float32', customValues);
-    const im2ColReshaped = reshape({ inputs: { x: im2Col }, backend, attrs: { shape: x2ColShape } });
+    const im2ColReshaped = reshape$1({ inputs: { x: im2Col }, backend, attrs: { shape: x2ColShape } });
     intermediates.push(im2Col);
     intermediates.push(im2ColReshaped);
     const hasBias = bias != null;
@@ -22543,7 +23069,7 @@ function conv2dWithIm2Row({ x, filter, convInfo, backend, bias = null, preluActi
         intermediates.push($leakyreluAlpha);
     }
     const product = backend.runWebGLProgram(matmulProgram, inputs, 'float32');
-    const out = reshape({ inputs: { x: product }, backend, attrs: { shape: convInfo.outShape } });
+    const out = reshape$1({ inputs: { x: product }, backend, attrs: { shape: convInfo.outShape } });
     intermediates.push(product);
     for (const i of intermediates) {
         backend.disposeIntermediateTensorInfo(i);
@@ -22584,11 +23110,11 @@ function conv2d(args) {
         const program = new Conv2DProgram(convInfo);
         out = backend.runWebGLProgram(program, [x, filter], 'float32');
     }
-    const outReshaped = reshape({ inputs: { x: out }, backend, attrs: { shape: convInfo.outShape } });
+    const outReshaped = reshape$1({ inputs: { x: out }, backend, attrs: { shape: convInfo.outShape } });
     backend.disposeIntermediateTensorInfo(out);
     return outReshaped;
 }
-const conv2DConfig = {
+const conv2DConfig$1 = {
     kernelName: Conv2D,
     backendName: 'webgl',
     kernelFunc: conv2d,
@@ -22846,7 +23372,7 @@ class Conv3DDerInputProgram {
 }
 
 
-function conv2DBackpropFilter(args) {
+function conv2DBackpropFilter$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, dy } = inputs;
     const { strides, pad, dataFormat, dimRoundingMode, filterShape } = attrs;
@@ -22855,10 +23381,10 @@ function conv2DBackpropFilter(args) {
     const program = new Conv2DDerFilterProgram(convInfo);
     return backend.runWebGLProgram(program, [x, dy], 'float32');
 }
-const conv2DBackpropFilterConfig = {
+const conv2DBackpropFilterConfig$1 = {
     kernelName: Conv2DBackpropFilter,
     backendName: 'webgl',
-    kernelFunc: conv2DBackpropFilter,
+    kernelFunc: conv2DBackpropFilter$1,
 };
 
 
@@ -22955,7 +23481,7 @@ class Conv2DDerInputPackedProgram {
 }
 
 
-function conv2DBackpropInput(args) {
+function conv2DBackpropInput$1(args) {
     const { inputs, backend, attrs } = args;
     const { dy, filter } = inputs;
     const { inputShape, strides, pad, dataFormat, dimRoundingMode } = attrs;
@@ -22974,14 +23500,14 @@ function conv2DBackpropInput(args) {
         return backend.runWebGLProgram(program, [dy, filter], 'float32');
     }
 }
-const conv2DBackpropInputConfig = {
+const conv2DBackpropInputConfig$1 = {
     kernelName: Conv2DBackpropInput,
     backendName: 'webgl',
-    kernelFunc: conv2DBackpropInput,
+    kernelFunc: conv2DBackpropInput$1,
 };
 
 
-function conv3D(args) {
+function conv3D$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, filter } = inputs;
     const { strides, pad, dilations } = attrs;
@@ -22989,14 +23515,14 @@ function conv3D(args) {
     const program = new Conv3DProgram(convInfo);
     return backend.runWebGLProgram(program, [x, filter], 'float32');
 }
-const conv3DConfig = {
+const conv3DConfig$1 = {
     kernelName: Conv3D,
     backendName: 'webgl',
-    kernelFunc: conv3D,
+    kernelFunc: conv3D$1,
 };
 
 
-function conv3DBackpropFilterV2(args) {
+function conv3DBackpropFilterV2$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, dy } = inputs;
     const { strides, pad, filterShape } = attrs;
@@ -23004,10 +23530,10 @@ function conv3DBackpropFilterV2(args) {
     const program = new Conv3DDerFilterProgram(convInfo);
     return backend.runWebGLProgram(program, [x, dy], 'float32');
 }
-const conv3DBackpropFilterV2Config = {
+const conv3DBackpropFilterV2Config$1 = {
     kernelName: Conv3DBackpropFilterV2,
     backendName: 'webgl',
-    kernelFunc: conv3DBackpropFilterV2
+    kernelFunc: conv3DBackpropFilterV2$1
 };
 
 
@@ -23035,11 +23561,11 @@ const COS_PACKED = `
   ${CHECK_NAN_SNIPPET_PACKED}
   return result;
 `;
-const cos = unaryKernelFunc({ opSnippet: COS, packedOpSnippet: COS_PACKED });
-const cosConfig = {
+const cos$1 = unaryKernelFunc({ opSnippet: COS, packedOpSnippet: COS_PACKED });
+const cosConfig$1 = {
     kernelName: Cos,
     backendName: 'webgl',
-    kernelFunc: cos,
+    kernelFunc: cos$1,
 };
 
 
@@ -23047,11 +23573,11 @@ const COSH = `
   float e2x = exp(-x);
   return (e2x + 1.0 / e2x) / 2.0;
 `;
-const cosh = unaryKernelFunc({ opSnippet: COSH });
-const coshConfig = {
+const cosh$1 = unaryKernelFunc({ opSnippet: COSH });
+const coshConfig$1 = {
     kernelName: Cosh,
     backendName: 'webgl',
-    kernelFunc: cosh,
+    kernelFunc: cosh$1,
 };
 
 
@@ -23156,17 +23682,17 @@ class CropAndResizeProgram {
 }
 
 
-const cropAndResize = (args) => {
+const cropAndResize$1 = (args) => {
     const { inputs, backend, attrs } = args;
     const { image, boxes, boxInd } = inputs;
     const { cropSize, method, extrapolationValue } = attrs;
     const program = new CropAndResizeProgram(image.shape, boxes.shape, cropSize, method, extrapolationValue);
     return backend.runWebGLProgram(program, [image, boxes, boxInd], 'float32');
 };
-const cropAndResizeConfig = {
+const cropAndResizeConfig$1 = {
     kernelName: CropAndResize,
     backendName: 'webgl',
-    kernelFunc: cropAndResize
+    kernelFunc: cropAndResize$1
 };
 
 var CumOpType;
@@ -23294,33 +23820,33 @@ function cumImpl(op, x, backend, axis, exclusive, reverse) {
 }
 
 
-function cumprod(args) {
+function cumprod$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis, exclusive, reverse } = attrs;
     return cumImpl(CumOpType.Prod, x, backend, axis, exclusive, reverse);
 }
-const cumprodConfig = {
+const cumprodConfig$1 = {
     kernelName: Cumprod,
     backendName: 'webgl',
-    kernelFunc: cumprod
+    kernelFunc: cumprod$1
 };
 
 
-function cumsum(args) {
+function cumsum$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis, exclusive, reverse } = attrs;
     return cumImpl(CumOpType.Sum, x, backend, axis, exclusive, reverse);
 }
-const cumsumConfig = {
+const cumsumConfig$1 = {
     kernelName: Cumsum,
     backendName: 'webgl',
-    kernelFunc: cumsum
+    kernelFunc: cumsum$1
 };
 
 
-function denseBincount(args) {
+function denseBincount$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, weights } = inputs;
     const { size, binaryOutput } = attrs;
@@ -23339,10 +23865,10 @@ function denseBincount(args) {
     throw new Error(`Error in denseBincount: input must be at most rank 2, but got rank` +
         `${x.shape.length}.`);
 }
-const denseBincountConfig = {
+const denseBincountConfig$1 = {
     kernelName: DenseBincount,
     backendName: 'webgl',
-    kernelFunc: denseBincount
+    kernelFunc: denseBincount$1
 };
 
 
@@ -23417,7 +23943,7 @@ class DepthToSpaceProgram {
 }
 
 
-function depthToSpace(args) {
+function depthToSpace$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { blockSize, dataFormat } = attrs;
@@ -23434,10 +23960,10 @@ function depthToSpace(args) {
     const program = new DepthToSpaceProgram(outputShape, blockSize, dataFormat);
     return backend.runWebGLProgram(program, [x], x.dtype);
 }
-const depthToSpaceConfig = {
+const depthToSpaceConfig$1 = {
     kernelName: DepthToSpace,
     backendName: 'webgl',
-    kernelFunc: depthToSpace
+    kernelFunc: depthToSpace$1
 };
 
 
@@ -23882,7 +24408,7 @@ class DepthwiseConvPacked2DProgram {
 }
 
 
-function depthwiseConv2dNative(args) {
+function depthwiseConv2dNative$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, filter } = inputs;
     const { strides, pad, dilations, dimRoundingMode } = attrs;
@@ -23909,10 +24435,10 @@ function depthwiseConv2dNative(args) {
     ];
     return backend.runWebGLProgram(program, [x, filter], 'float32', customValues);
 }
-const depthwiseConv2dNativeConfig = {
+const depthwiseConv2dNativeConfig$1 = {
     kernelName: DepthwiseConv2dNative,
     backendName: 'webgl',
-    kernelFunc: depthwiseConv2dNative,
+    kernelFunc: depthwiseConv2dNative$1,
 };
 
 
@@ -24024,7 +24550,7 @@ class DepthwiseConv2DDerInputProgram {
 }
 
 
-function depthwiseConv2dNativeBackpropFilter(args) {
+function depthwiseConv2dNativeBackpropFilter$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, dy } = inputs;
     const { strides, dilations, pad, dimRoundingMode, filterShape } = attrs;
@@ -24032,14 +24558,14 @@ function depthwiseConv2dNativeBackpropFilter(args) {
     const program = new DepthwiseConv2DDerFilterProgram(convInfo);
     return backend.runWebGLProgram(program, [x, dy], 'float32');
 }
-const depthwiseConv2dNativeBackpropFilterConfig = {
+const depthwiseConv2dNativeBackpropFilterConfig$1 = {
     kernelName: DepthwiseConv2dNativeBackpropFilter,
     backendName: 'webgl',
-    kernelFunc: depthwiseConv2dNativeBackpropFilter
+    kernelFunc: depthwiseConv2dNativeBackpropFilter$1
 };
 
 
-function depthwiseConv2dNativeBackpropInput(args) {
+function depthwiseConv2dNativeBackpropInput$1(args) {
     const { inputs, backend, attrs } = args;
     const { dy, filter } = inputs;
     const { strides, dilations, pad, dimRoundingMode, inputShape } = attrs;
@@ -24047,10 +24573,10 @@ function depthwiseConv2dNativeBackpropInput(args) {
     const program = new DepthwiseConv2DDerInputProgram(convInfo);
     return backend.runWebGLProgram(program, [dy, filter], 'float32');
 }
-const depthwiseConv2dNativeBackpropInputConfig = {
+const depthwiseConv2dNativeBackpropInputConfig$1 = {
     kernelName: DepthwiseConv2dNativeBackpropInput,
     backendName: 'webgl',
-    kernelFunc: depthwiseConv2dNativeBackpropInput
+    kernelFunc: depthwiseConv2dNativeBackpropInput$1
 };
 
 
@@ -24069,23 +24595,23 @@ class DiagProgram {
 }
 
 
-function diag(args) {
+function diag$1(args) {
     const { inputs, backend } = args;
     const { x } = inputs;
     const outShape = [...x.shape, ...x.shape];
     const xSize = sizeFromShape(x.shape);
-    const flat = reshape({ inputs: { x }, backend, attrs: { shape: [xSize] } });
+    const flat = reshape$1({ inputs: { x }, backend, attrs: { shape: [xSize] } });
     const program = new DiagProgram(xSize);
     const res = backend.runWebGLProgram(program, [flat], flat.dtype);
-    const out = reshape({ inputs: { x: res }, backend, attrs: { shape: outShape } });
+    const out = reshape$1({ inputs: { x: res }, backend, attrs: { shape: outShape } });
     backend.disposeIntermediateTensorInfo(flat);
     backend.disposeIntermediateTensorInfo(res);
     return out;
 }
-const diagConfig = {
+const diagConfig$1 = {
     kernelName: Diag,
     backendName: 'webgl',
-    kernelFunc: diag
+    kernelFunc: diag$1
 };
 
 
@@ -24146,18 +24672,18 @@ function dilation2D(args) {
     let out;
     const program = new Dilation2DProgram(convInfo);
     out = backend.runWebGLProgram(program, [x, filter], 'float32');
-    const outReshaped = reshape({ inputs: { x: out }, backend, attrs: { shape: convInfo.outShape } });
+    const outReshaped = reshape$1({ inputs: { x: out }, backend, attrs: { shape: convInfo.outShape } });
     backend.disposeIntermediateTensorInfo(out);
     return outReshaped;
 }
-const dilation2DConfig = {
+const dilation2DConfig$1 = {
     kernelName: Dilation2D,
     backendName: 'webgl',
     kernelFunc: dilation2D,
 };
 
 
-function einsum(args) {
+function einsum$1(args) {
     const { inputs, backend, attrs } = args;
     const { equation } = attrs;
     const tensors = inputs;
@@ -24184,7 +24710,7 @@ function einsum(args) {
                 targetShape.splice(dimsToExpand[k], 0, 1);
             }
             if (!arraysEqual(x.shape, targetShape)) {
-                x = reshape({ inputs: { x }, backend, attrs: { shape: targetShape } });
+                x = reshape$1({ inputs: { x }, backend, attrs: { shape: targetShape } });
                 tensorsToDispose.push(x);
             }
             if (out === null) {
@@ -24198,7 +24724,7 @@ function einsum(args) {
         }
         if (i < nSteps - 1) {
             if (path[i] >= 0) {
-                out = sum({
+                out = sum$1({
                     inputs: { x: out },
                     backend,
                     attrs: {
@@ -24220,10 +24746,10 @@ function einsum(args) {
     }
     return out;
 }
-const einsumConfig = {
+const einsumConfig$1 = {
     kernelName: Einsum,
     backendName: 'webgl',
-    kernelFunc: einsum
+    kernelFunc: einsum$1
 };
 
 
@@ -24238,11 +24764,11 @@ const ELU_PACKED = `
 
   return result;
 `;
-const elu$1 = unaryKernelFunc({ opSnippet: ELU, packedOpSnippet: ELU_PACKED });
-const eluConfig = {
+const elu$2 = unaryKernelFunc({ opSnippet: ELU, packedOpSnippet: ELU_PACKED });
+const eluConfig$1 = {
     kernelName: Elu$1,
     backendName: 'webgl',
-    kernelFunc: elu$1
+    kernelFunc: elu$2
 };
 
 
@@ -24251,7 +24777,7 @@ const ELU_DER_PACKED = `
   vec4 bGTEZero = vec4(greaterThanEqual(b, vec4(0.)));
   return (bGTEZero * a) + ((vec4(1.0) - bGTEZero) * (a * (b + vec4(1.0))));
 `;
-const eluGrad = (args) => {
+const eluGrad$1 = (args) => {
     const { inputs, backend } = args;
     const { dy, y } = inputs;
     const program = env().getBool('WEBGL_PACK_BINARY_OPERATIONS') ?
@@ -24259,10 +24785,10 @@ const eluGrad = (args) => {
         new BinaryOpProgram(ELU_DER, dy.shape, y.shape);
     return backend.runWebGLProgram(program, [dy, y], dy.dtype);
 };
-const eluGradConfig$1 = {
+const eluGradConfig$2 = {
     kernelName: EluGrad,
     backendName: 'webgl',
-    kernelFunc: eluGrad
+    kernelFunc: eluGrad$1
 };
 
 
@@ -24299,11 +24825,11 @@ const ERF = `
   float t = 1.0 / (1.0 + p * x);
   return sign * (1.0 - (((((a5*t + a4)*t) + a3)*t + a2)*t + a1)*t*exp(-x*x));
 `;
-const erf = unaryKernelFunc({ opSnippet: ERF });
-const erfConfig = {
+const erf$1 = unaryKernelFunc({ opSnippet: ERF });
+const erfConfig$1 = {
     kernelName: Erf,
     backendName: 'webgl',
-    kernelFunc: erf,
+    kernelFunc: erf$1,
 };
 
 
@@ -24333,7 +24859,7 @@ const expConfig = {
 };
 
 
-function expandDims$1(args) {
+function expandDims$2(args) {
     const { inputs, attrs, backend } = args;
     const { dim } = attrs;
     const { input } = inputs;
@@ -24346,12 +24872,12 @@ function expandDims$1(args) {
         $dim = inputRank + dim + 1;
     }
     newShape.splice($dim, 0, 1);
-    return reshape({ inputs: { x: input }, backend, attrs: { shape: newShape } });
+    return reshape$1({ inputs: { x: input }, backend, attrs: { shape: newShape } });
 }
-const expandDimsConfig = {
+const expandDimsConfig$1 = {
     kernelName: ExpandDims,
     backendName: 'webgl',
-    kernelFunc: expandDims$1,
+    kernelFunc: expandDims$2,
 };
 
 
@@ -24419,13 +24945,13 @@ class FFTProgram {
 }
 
 
-function fftImpl(x, inverse, backend) {
+function fftImpl$1(x, inverse, backend) {
     const xData = backend.texData.get(x.dataId);
     const inputSize = sizeFromShape(x.shape);
     
     const innerDimensionSize = x.shape[x.shape.length - 1];
     const batch = inputSize / innerDimensionSize;
-    const input2D = reshape({ inputs: { x }, backend, attrs: { shape: [batch, innerDimensionSize] } });
+    const input2D = reshape$1({ inputs: { x }, backend, attrs: { shape: [batch, innerDimensionSize] } });
     const xShape = input2D.shape;
     const realProgram = new FFTProgram('real', xShape, inverse);
     const imagProgram = new FFTProgram('imag', xShape, inverse);
@@ -24446,22 +24972,22 @@ function fftImpl(x, inverse, backend) {
     const complexOutput = complex({ inputs: { real: realPart, imag: imagPart }, backend });
     backend.disposeIntermediateTensorInfo(realPart);
     backend.disposeIntermediateTensorInfo(imagPart);
-    const complexOutputReshaped = reshape({ inputs: { x: complexOutput }, backend, attrs: { shape: x.shape } });
+    const complexOutputReshaped = reshape$1({ inputs: { x: complexOutput }, backend, attrs: { shape: x.shape } });
     backend.disposeIntermediateTensorInfo(input2D);
     backend.disposeIntermediateTensorInfo(complexOutput);
     return complexOutputReshaped;
 }
 
 
-function fft(args) {
+function fft$1(args) {
     const { inputs, backend } = args;
     const { input } = inputs;
-    return fftImpl(input, false , backend);
+    return fftImpl$1(input, false , backend);
 }
-const fftConfig = {
+const fftConfig$1 = {
     kernelName: FFT,
     backendName: 'webgl',
-    kernelFunc: fft
+    kernelFunc: fft$1
 };
 
 
@@ -24481,7 +25007,7 @@ class FillProgram {
 }
 
 
-function fill(args) {
+function fill$1(args) {
     const { backend, attrs } = args;
     const { shape, value } = attrs;
     let { dtype } = attrs;
@@ -24498,10 +25024,10 @@ function fill(args) {
         return backend.runWebGLProgram(program, [], dtype, customValues);
     }
 }
-const fillConfig = {
+const fillConfig$1 = {
     kernelName: Fill,
     backendName: 'webgl',
-    kernelFunc: fill
+    kernelFunc: fill$1
 };
 
 
@@ -24530,7 +25056,7 @@ class FlipLeftRightProgram {
 }
 
 
-const flipLeftRightConfig = {
+const flipLeftRightConfig$1 = {
     kernelName: FlipLeftRight,
     backendName: 'webgl',
     kernelFunc: ({ inputs, backend }) => {
@@ -24749,7 +25275,7 @@ function fusedConv2d(args) {
         const alignInputWithDataFormat = (input, dataFormat) => {
             if (dataFormat === 'NCHW' && input.shape.length === 1 &&
                 input.shape[0] !== 1) {
-                const alignedInput = reshape({
+                const alignedInput = reshape$1({
                     inputs: { x: input },
                     backend,
                     attrs: { shape: [input.shape[0], 1, 1] }
@@ -24818,19 +25344,19 @@ function fusedConv2d(args) {
         const inputs = prepareInputs();
         out = backend.runWebGLProgram(program, inputs, 'float32');
     }
-    const outReshaped = reshape({ inputs: { x: out }, backend, attrs: { shape: convInfo.outShape } });
+    const outReshaped = reshape$1({ inputs: { x: out }, backend, attrs: { shape: convInfo.outShape } });
     intermediates.push(out);
     intermediates.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return outReshaped;
 }
-const fusedConv2DConfig = {
+const fusedConv2DConfig$1 = {
     kernelName: FusedConv2D,
     backendName: 'webgl',
     kernelFunc: fusedConv2d,
 };
 
 
-function fusedDepthwiseConv2D(args) {
+function fusedDepthwiseConv2D$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, filter, bias, preluActivationWeights } = inputs;
     const { strides, pad, dilations, dimRoundingMode, activation, leakyreluAlpha } = attrs;
@@ -24880,10 +25406,10 @@ function fusedDepthwiseConv2D(args) {
     intermediates.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return result;
 }
-const fusedDepthwiseConv2DConfig = {
+const fusedDepthwiseConv2DConfig$1 = {
     kernelName: FusedDepthwiseConv2D,
     backendName: 'webgl',
-    kernelFunc: fusedDepthwiseConv2D,
+    kernelFunc: fusedDepthwiseConv2D$1,
 };
 
 class GatherNDProgram {
@@ -24918,15 +25444,15 @@ class GatherNDProgram {
 }
 
 
-function gatherNd(args) {
+function gatherNd$1(args) {
     const { inputs, backend } = args;
     const { params, indices } = inputs;
     const indicesShape = indices.shape;
     const sliceRank = indicesShape[indicesShape.length - 1];
     const paramsSize = sizeFromShape(params.shape);
     const [resultShape, numSlices, sliceSize, strides] = prepareAndValidate(params, indices);
-    const flattenIndices = reshape({ inputs: { x: indices }, backend, attrs: { shape: [numSlices, sliceRank] } });
-    const flattenX = reshape({
+    const flattenIndices = reshape$1({ inputs: { x: indices }, backend, attrs: { shape: [numSlices, sliceRank] } });
+    const flattenX = reshape$1({
         inputs: { x: params },
         backend,
         attrs: { shape: [(sizeFromShape(params.shape) / sliceSize), sliceSize] }
@@ -24940,16 +25466,16 @@ function gatherNd(args) {
     }
     const program = new GatherNDProgram(sliceRank, strides, [numSlices, sliceSize], params.shape);
     const res = backend.runWebGLProgram(program, [flattenX, flattenIndices], flattenX.dtype);
-    const reshaped = reshape({ inputs: { x: res }, backend, attrs: { shape: resultShape } });
+    const reshaped = reshape$1({ inputs: { x: res }, backend, attrs: { shape: resultShape } });
     backend.disposeIntermediateTensorInfo(flattenIndices);
     backend.disposeIntermediateTensorInfo(flattenX);
     backend.disposeIntermediateTensorInfo(res);
     return reshaped;
 }
-const gatherNdConfig = {
+const gatherNdConfig$1 = {
     kernelName: GatherNd,
     backendName: 'webgl',
-    kernelFunc: gatherNd
+    kernelFunc: gatherNd$1
 };
 
 
@@ -24986,7 +25512,7 @@ function getSourceCoords$1(aShape, axis) {
 }
 
 
-function gatherV2(args) {
+function gatherV2$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, indices } = inputs;
     const { axis, batchDims } = attrs;
@@ -25004,7 +25530,7 @@ function gatherV2(args) {
     const shapeInfo = collectGatherOpShapeInfo(x, indices, parsedAxis, batchDims);
     const indicesSize = sizeFromShape(indices.shape);
     const toDispose = [];
-    const flattenX = reshape({
+    const flattenX = reshape$1({
         inputs: { x },
         backend,
         attrs: {
@@ -25014,7 +25540,7 @@ function gatherV2(args) {
             ]
         }
     });
-    const flattenIndex = reshape({
+    const flattenIndex = reshape$1({
         inputs: { x: indices },
         backend,
         attrs: { shape: [shapeInfo.batchSize, indicesSize / shapeInfo.batchSize] }
@@ -25035,14 +25561,14 @@ function gatherV2(args) {
     const program = new GatherProgram(flattenX.shape, flattenOutputShape);
     const res = backend.runWebGLProgram(program, [flattenX, flattenIndex], flattenX.dtype);
     toDispose.push(res);
-    const reshaped = reshape({ inputs: { x: res }, backend, attrs: { shape: shapeInfo.outputShape } });
+    const reshaped = reshape$1({ inputs: { x: res }, backend, attrs: { shape: shapeInfo.outputShape } });
     toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return reshaped;
 }
-const gatherV2Config = {
+const gatherV2Config$1 = {
     kernelName: GatherV2,
     backendName: 'webgl',
-    kernelFunc: gatherV2
+    kernelFunc: gatherV2$1
 };
 
 
@@ -25080,42 +25606,42 @@ const greaterEqualConfig = {
 };
 
 
-function ifft(args) {
+function ifft$1(args) {
     const { inputs, backend } = args;
     const { input } = inputs;
-    return fftImpl(input, true , backend);
+    return fftImpl$1(input, true , backend);
 }
-const ifftConfig = {
+const ifftConfig$1 = {
     kernelName: IFFT,
     backendName: 'webgl',
-    kernelFunc: ifft
+    kernelFunc: ifft$1
 };
 
 
 const IS_FINITE = `return float(!isnan(x) && !isinf(x));`;
-const isFinite$1 = unaryKernelFunc({ opSnippet: IS_FINITE, dtype: 'bool' });
-const isFiniteConfig = {
+const isFinite$2 = unaryKernelFunc({ opSnippet: IS_FINITE, dtype: 'bool' });
+const isFiniteConfig$1 = {
     kernelName: IsFinite,
     backendName: 'webgl',
-    kernelFunc: isFinite$1,
+    kernelFunc: isFinite$2,
 };
 
 
 const IS_INF = `return float(isinf(x));`;
-const isInf = unaryKernelFunc({ opSnippet: IS_INF, dtype: 'bool' });
-const isInfConfig = {
+const isInf$1 = unaryKernelFunc({ opSnippet: IS_INF, dtype: 'bool' });
+const isInfConfig$1 = {
     kernelName: IsInf,
     backendName: 'webgl',
-    kernelFunc: isInf,
+    kernelFunc: isInf$1,
 };
 
 
 const IS_NAN = `return float(isnan(x));`;
-const isNaN$1 = unaryKernelFunc({ opSnippet: IS_NAN, dtype: 'bool' });
-const isNaNConfig = {
+const isNaN$2 = unaryKernelFunc({ opSnippet: IS_NAN, dtype: 'bool' });
+const isNaNConfig$1 = {
     kernelName: IsNan,
     backendName: 'webgl',
-    kernelFunc: isNaN$1,
+    kernelFunc: isNaN$2,
 };
 
 
@@ -25153,17 +25679,17 @@ const lessEqualConfig = {
 };
 
 
-function linSpace(args) {
+function linSpace$1(args) {
     const { backend, attrs } = args;
     const { start, stop, num } = attrs;
     
     const outVals = linSpaceImplCPU(start, stop, num);
     return backend.makeTensorInfo([outVals.length], 'float32', outVals);
 }
-const linSpaceConfig = {
+const linSpaceConfig$1 = {
     kernelName: LinSpace,
     backendName: 'webgl',
-    kernelFunc: linSpace
+    kernelFunc: linSpace$1
 };
 
 
@@ -25192,11 +25718,11 @@ const logConfig = {
 const LOG1P = CHECK_NAN_SNIPPET_UNARY + `
   return log(1.0 + x);
 `;
-const log1p = unaryKernelFunc({ opSnippet: LOG1P });
-const log1pConfig = {
+const log1p$1 = unaryKernelFunc({ opSnippet: LOG1P });
+const log1pConfig$1 = {
     kernelName: Log1p,
     backendName: 'webgl',
-    kernelFunc: log1p,
+    kernelFunc: log1p$1,
 };
 
 
@@ -25206,24 +25732,24 @@ const LOGICAL_AND_PACKED = `
     vec4(greaterThanEqual(a, vec4(1.0))) *
     vec4(greaterThanEqual(b, vec4(1.0))));
 `;
-const logicalAnd = binaryKernelFunc({
+const logicalAnd$1 = binaryKernelFunc({
     opSnippet: LOGICAL_AND,
     packedOpSnippet: LOGICAL_AND_PACKED,
     dtype: 'bool'
 });
-const logicalAndConfig = {
+const logicalAndConfig$1 = {
     kernelName: LogicalAnd,
     backendName: 'webgl',
-    kernelFunc: logicalAnd
+    kernelFunc: logicalAnd$1
 };
 
 
 const LOGICAL_NOT = `return float(!(x >= 1.0));`;
-const logicalNot = unaryKernelFunc({ opSnippet: LOGICAL_NOT });
-const logicalNotConfig = {
+const logicalNot$1 = unaryKernelFunc({ opSnippet: LOGICAL_NOT });
+const logicalNotConfig$1 = {
     kernelName: LogicalNot,
     backendName: 'webgl',
-    kernelFunc: logicalNot,
+    kernelFunc: logicalNot$1,
 };
 
 
@@ -25234,11 +25760,11 @@ const LOGICAL_OR_PACKED = `
     vec4(greaterThanEqual(b, vec4(1.0))),
     vec4(1.0));
 `;
-const logicalOr = binaryKernelFunc({ opSnippet: LOGICAL_OR, packedOpSnippet: LOGICAL_OR_PACKED, dtype: 'bool' });
-const logicalOrConfig = {
+const logicalOr$1 = binaryKernelFunc({ opSnippet: LOGICAL_OR, packedOpSnippet: LOGICAL_OR_PACKED, dtype: 'bool' });
+const logicalOrConfig$1 = {
     kernelName: LogicalOr,
     backendName: 'webgl',
-    kernelFunc: logicalOr
+    kernelFunc: logicalOr$1
 };
 
 
@@ -25389,7 +25915,7 @@ const lrn = (args) => {
     return backend.runWebGLProgram(program, [x], x.dtype);
 };
 
-const LRNConfig = {
+const LRNConfig$1 = {
     kernelName: LRN,
     backendName: 'webgl',
     kernelFunc: lrn
@@ -25474,7 +26000,7 @@ const lrnGrad = (args) => {
     return backend.runWebGLProgram(program, [x, y, dy], x.dtype);
 };
 
-const LRNGradConfig = {
+const LRNGradConfig$1 = {
     kernelName: LRNGrad,
     backendName: 'webgl',
     kernelFunc: lrnGrad
@@ -25485,16 +26011,16 @@ function maxImpl(x, reduceShape, outShape, backend) {
     const inSize = sizeFromShape(reduceShape);
     const xSize = sizeFromShape(x.shape);
     const batchSize = xSize / inSize;
-    const reshapedInput = reshape({ inputs: { x }, attrs: { shape: [batchSize, inSize] }, backend });
+    const reshapedInput = reshape$1({ inputs: { x }, attrs: { shape: [batchSize, inSize] }, backend });
     const reduced = reduce(reshapedInput, x.dtype, 'max', backend);
-    const reshapedOutput = reshape({ inputs: { x: reduced }, attrs: { shape: outShape }, backend });
+    const reshapedOutput = reshape$1({ inputs: { x: reduced }, attrs: { shape: outShape }, backend });
     backend.disposeIntermediateTensorInfo(reshapedInput);
     backend.disposeIntermediateTensorInfo(reduced);
     return reshapedOutput;
 }
 
 
-function max(args) {
+function max$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { reductionIndices, keepDims } = attrs;
@@ -25547,10 +26073,10 @@ function max(args) {
     }
     return out;
 }
-const maxConfig = {
+const maxConfig$1 = {
     kernelName: Max,
     backendName: 'webgl',
-    kernelFunc: max
+    kernelFunc: max$1
 };
 
 
@@ -25578,10 +26104,10 @@ const maximumConfig = {
 };
 
 
-function maxPool(args) {
+function maxPool$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
-    assertNotComplex(x, 'maxPool');
+    assertNotComplex$1(x, 'maxPool');
     const { filterSize, strides, pad, dimRoundingMode } = attrs;
     const dilations = 1;
     assert$1(eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in maxPool: Either strides or dilations must be 1. ' +
@@ -25594,10 +26120,10 @@ function maxPool(args) {
     const maxPoolProgram = new Pool2DProgram(convInfo, 'max', false);
     return backend.runWebGLProgram(maxPoolProgram, [x], x.dtype);
 }
-const maxPoolConfig = {
+const maxPoolConfig$1 = {
     kernelName: MaxPool,
     backendName: 'webgl',
-    kernelFunc: maxPool
+    kernelFunc: maxPool$1
 };
 
 
@@ -25610,7 +26136,7 @@ function maxPool3d(args) {
     const maxPoolProgram = new Pool3DProgram(convInfo, 'max', false);
     return backend.runWebGLProgram(maxPoolProgram, [x], x.dtype);
 }
-const maxPool3DConfig = {
+const maxPool3DConfig$1 = {
     kernelName: MaxPool3D,
     backendName: 'webgl',
     kernelFunc: maxPool3d
@@ -25764,7 +26290,7 @@ class MaxPool3DBackpropProgram {
 }
 
 
-function maxPool3DGrad(args) {
+function maxPool3DGrad$1(args) {
     const { inputs, backend, attrs } = args;
     const { dy, input } = inputs;
     const x = input;
@@ -25778,18 +26304,18 @@ function maxPool3DGrad(args) {
     backend.disposeIntermediateTensorInfo(maxPool3dPositions);
     return result;
 }
-const maxPool3DGradConfig$1 = {
+const maxPool3DGradConfig$2 = {
     kernelName: MaxPool3DGrad,
     backendName: 'webgl',
-    kernelFunc: maxPool3DGrad
+    kernelFunc: maxPool3DGrad$1
 };
 
 
-function maxPoolGrad$1(args) {
+function maxPoolGrad$2(args) {
     const { inputs, backend, attrs } = args;
     const { dy, input, output } = inputs;
     const x = input;
-    assertNotComplex([input, output], 'maxPoolGrad');
+    assertNotComplex$1([input, output], 'maxPoolGrad');
     const { filterSize, strides, pad, dimRoundingMode } = attrs;
     const convInfo = computePool2DInfo(x.shape, filterSize, strides, 1 , pad, dimRoundingMode);
     const getPositions = true;
@@ -25800,14 +26326,14 @@ function maxPoolGrad$1(args) {
     backend.disposeIntermediateTensorInfo(maxPoolPositions);
     return result;
 }
-const maxPoolGradConfig$1 = {
+const maxPoolGradConfig$2 = {
     kernelName: MaxPoolGrad,
     backendName: 'webgl',
-    kernelFunc: maxPoolGrad$1
+    kernelFunc: maxPoolGrad$2
 };
 
 
-function maxPoolWithArgmaxImpl(x, includeBatchInIndex, convInfo, backend) {
+function maxPoolWithArgmaxImpl$1(x, includeBatchInIndex, convInfo, backend) {
     let program = new Pool2DProgram(convInfo, 'max', false);
     const poolOutput = backend.runWebGLProgram(program, [x], 'float32');
     program = new Pool2DProgram(convInfo, 'max', true, true, includeBatchInIndex);
@@ -25816,7 +26342,7 @@ function maxPoolWithArgmaxImpl(x, includeBatchInIndex, convInfo, backend) {
 }
 
 
-const maxPoolWithArgmaxConfig = {
+const maxPoolWithArgmaxConfig$1 = {
     kernelName: MaxPoolWithArgmax,
     backendName: 'webgl',
     kernelFunc: ({ inputs, attrs, backend }) => {
@@ -25828,7 +26354,7 @@ const maxPoolWithArgmaxConfig = {
         assert$1(eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in maxPool: Either strides or dilations must be 1. ' +
             `Got strides ${strides} and dilations '${dilations}'`);
         const convInfo = computePool2DInfo(x.shape, filterSize, strides, dilations, pad);
-        const [result, indexes] = maxPoolWithArgmaxImpl(x, includeBatchInIndex, convInfo, webglBackend);
+        const [result, indexes] = maxPoolWithArgmaxImpl$1(x, includeBatchInIndex, convInfo, webglBackend);
         return [result, indexes];
     }
 };
@@ -25838,16 +26364,16 @@ function meanImpl(x, reduceShape, outShape, backend) {
     const inSize = sizeFromShape(reduceShape);
     const xSize = sizeFromShape(x.shape);
     const batchSize = xSize / inSize;
-    const reshapedInput = reshape({ inputs: { x }, attrs: { shape: [batchSize, inSize] }, backend });
+    const reshapedInput = reshape$1({ inputs: { x }, attrs: { shape: [batchSize, inSize] }, backend });
     const reduced = reduce(reshapedInput, 'float32', 'mean', backend);
-    const reshapedOutput = reshape({ inputs: { x: reduced }, attrs: { shape: outShape }, backend });
+    const reshapedOutput = reshape$1({ inputs: { x: reduced }, attrs: { shape: outShape }, backend });
     backend.disposeIntermediateTensorInfo(reshapedInput);
     backend.disposeIntermediateTensorInfo(reduced);
     return reshapedOutput;
 }
 
 
-const meanConfig = {
+const meanConfig$1 = {
     kernelName: Mean,
     backendName: 'webgl',
     kernelFunc: ({ inputs, attrs, backend }) => {
@@ -25897,7 +26423,7 @@ const meanConfig = {
 };
 
 
-function min(args) {
+function min$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis, keepDims } = attrs;
@@ -25913,15 +26439,15 @@ function min(args) {
     assertAxesAreInnerMostDims('min', axes, xRank);
     const [outShape, reduceShape] = computeOutAndReduceShapes(permutedX.shape, axes);
     const inSize = sizeFromShape(reduceShape);
-    const a2D = reshape({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
+    const a2D = reshape$1({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
     const reduced = reduce(a2D, a2D.dtype, 'min', backend);
     let res;
     if (keepDims) {
         const newShape = expandShapeToKeepDim(outShape, origAxes);
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: newShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: newShape } });
     }
     else {
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
     }
     backend.disposeIntermediateTensorInfo(a2D);
     backend.disposeIntermediateTensorInfo(reduced);
@@ -25930,10 +26456,10 @@ function min(args) {
     }
     return res;
 }
-const minConfig = {
+const minConfig$1 = {
     kernelName: Min,
     backendName: 'webgl',
-    kernelFunc: min
+    kernelFunc: min$1
 };
 
 
@@ -26104,7 +26630,7 @@ const mirrorPadKernelFunc = ({ inputs, backend, attrs }) => {
     const output = backend.runWebGLProgram(program, [x], x.dtype);
     return output;
 };
-const mirrorPadConfig = {
+const mirrorPadConfig$1 = {
     kernelName: MirrorPad,
     backendName: 'webgl',
     kernelFunc: mirrorPadKernelFunc,
@@ -26120,14 +26646,14 @@ const MOD_PACKED = `
     CHECK_NAN_SNIPPET_PACKED + `
   return result;
 `;
-const mod = binaryKernelFunc({
+const mod$1 = binaryKernelFunc({
     opSnippet: MOD,
     packedOpSnippet: MOD_PACKED,
 });
-const modConfig = {
+const modConfig$1 = {
     kernelName: Mod,
     backendName: 'webgl',
-    kernelFunc: mod
+    kernelFunc: mod$1
 };
 
 
@@ -26190,7 +26716,7 @@ const DIV_PACKED = `
   return result;
 `;
 const realDiv = binaryKernelFunc({ opSnippet: DIV, packedOpSnippet: DIV_PACKED, checkOutOfBounds: true });
-const realDivConfig = {
+const realDivConfig$1 = {
     kernelName: RealDiv,
     backendName: 'webgl',
     kernelFunc: realDiv,
@@ -26211,22 +26737,22 @@ const subConfig = {
 };
 
 
-function softmax(args) {
+function softmax$1(args) {
     const { inputs, backend, attrs } = args;
     const { logits } = inputs;
     const { dim } = attrs;
     const axes = parseAxisParam([dim], logits.shape);
-    const maxLogit = max({
+    const maxLogit = max$1({
         inputs: { x: logits },
         backend,
         attrs: { reductionIndices: axes, keepDims: false }
     });
     const expandedShape = expandShapeToKeepDim(maxLogit.shape, axes);
-    const maxLogitsReshaped = reshape({ inputs: { x: maxLogit }, backend, attrs: { shape: expandedShape } });
+    const maxLogitsReshaped = reshape$1({ inputs: { x: maxLogit }, backend, attrs: { shape: expandedShape } });
     const a = sub({ inputs: { a: logits, b: maxLogitsReshaped }, backend });
     const b = exp({ inputs: { x: a }, backend });
-    const sumExp = sum({ inputs: { x: b }, backend, attrs: { axis: axes, keepDims: false } });
-    const sumExpReshaped = reshape({ inputs: { x: sumExp }, backend, attrs: { shape: expandedShape } });
+    const sumExp = sum$1({ inputs: { x: b }, backend, attrs: { axis: axes, keepDims: false } });
+    const sumExpReshaped = reshape$1({ inputs: { x: sumExp }, backend, attrs: { shape: expandedShape } });
     const res = realDiv({ inputs: { a: b, b: sumExpReshaped }, backend });
     backend.disposeIntermediateTensorInfo(maxLogit);
     backend.disposeIntermediateTensorInfo(maxLogitsReshaped);
@@ -26236,20 +26762,20 @@ function softmax(args) {
     backend.disposeIntermediateTensorInfo(sumExpReshaped);
     return res;
 }
-const softmaxConfig = {
+const softmaxConfig$1 = {
     kernelName: Softmax$1,
     backendName: 'webgl',
-    kernelFunc: softmax
+    kernelFunc: softmax$1
 };
 
 
-function multinomial(args) {
+function multinomial$1(args) {
     const { inputs, backend, attrs } = args;
     const { logits } = inputs;
     const { numSamples, seed, normalized } = attrs;
     const probs = normalized ?
         logits :
-        softmax({ inputs: { logits }, backend, attrs: { dim: logits.shape.length - 1 } });
+        softmax$1({ inputs: { logits }, backend, attrs: { dim: logits.shape.length - 1 } });
     const batchSize = probs.shape[0];
     const numOutcomes = probs.shape[1];
     const program = new MultinomialProgram(batchSize, numOutcomes, numSamples);
@@ -26260,10 +26786,10 @@ function multinomial(args) {
     }
     return res;
 }
-const multinomialConfig = {
+const multinomialConfig$1 = {
     kernelName: Multinomial,
     backendName: 'webgl',
-    kernelFunc: multinomial
+    kernelFunc: multinomial$1
 };
 
 
@@ -26307,8 +26833,8 @@ const negConfig = {
 };
 
 
-const nonMaxSuppressionV3Impl = nonMaxSuppressionV3Impl$1;
-function nonMaxSuppressionV3(args) {
+const nonMaxSuppressionV3Impl$1 = nonMaxSuppressionV3Impl$2;
+function nonMaxSuppressionV3$1(args) {
     warn('tf.nonMaxSuppression() in webgl locks the UI thread. ' +
         'Call tf.nonMaxSuppressionAsync() instead');
     const { inputs, backend, attrs } = args;
@@ -26316,18 +26842,18 @@ function nonMaxSuppressionV3(args) {
     const { maxOutputSize, iouThreshold, scoreThreshold } = attrs;
     const boxesVals = backend.readSync(boxes.dataId);
     const scoresVals = backend.readSync(scores.dataId);
-    const { selectedIndices } = nonMaxSuppressionV3Impl(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold);
+    const { selectedIndices } = nonMaxSuppressionV3Impl$1(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold);
     return backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices));
 }
-const nonMaxSuppressionV3Config = {
+const nonMaxSuppressionV3Config$1 = {
     kernelName: NonMaxSuppressionV3,
     backendName: 'webgl',
-    kernelFunc: nonMaxSuppressionV3
+    kernelFunc: nonMaxSuppressionV3$1
 };
 
 
-const nonMaxSuppressionV4Impl = nonMaxSuppressionV4Impl$1;
-function nonMaxSuppressionV4(args) {
+const nonMaxSuppressionV4Impl$1 = nonMaxSuppressionV4Impl$2;
+function nonMaxSuppressionV4$1(args) {
     warn('tf.nonMaxSuppression() in webgl locks the UI thread. ' +
         'Call tf.nonMaxSuppressionAsync() instead');
     const { inputs, backend, attrs } = args;
@@ -26335,21 +26861,21 @@ function nonMaxSuppressionV4(args) {
     const { maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize } = attrs;
     const boxesVals = backend.readSync(boxes.dataId);
     const scoresVals = backend.readSync(scores.dataId);
-    const { selectedIndices, validOutputs } = nonMaxSuppressionV4Impl(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize);
+    const { selectedIndices, validOutputs } = nonMaxSuppressionV4Impl$1(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize);
     return [
         backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices)),
         backend.makeTensorInfo([], 'int32', new Int32Array([validOutputs]))
     ];
 }
-const nonMaxSuppressionV4Config = {
+const nonMaxSuppressionV4Config$1 = {
     kernelName: NonMaxSuppressionV4,
     backendName: 'webgl',
-    kernelFunc: nonMaxSuppressionV4
+    kernelFunc: nonMaxSuppressionV4$1
 };
 
 
-const nonMaxSuppressionV5Impl = nonMaxSuppressionV5Impl$1;
-function nonMaxSuppressionV5(args) {
+const nonMaxSuppressionV5Impl$1 = nonMaxSuppressionV5Impl$2;
+function nonMaxSuppressionV5$1(args) {
     warn('tf.nonMaxSuppression() in webgl locks the UI thread. ' +
         'Call tf.nonMaxSuppressionAsync() instead');
     const { inputs, backend, attrs } = args;
@@ -26361,16 +26887,16 @@ function nonMaxSuppressionV5(args) {
     const iouThresholdVal = iouThreshold;
     const scoreThresholdVal = scoreThreshold;
     const softNmsSigmaVal = softNmsSigma;
-    const { selectedIndices, selectedScores } = nonMaxSuppressionV5Impl(boxesVals, scoresVals, maxOutputSizeVal, iouThresholdVal, scoreThresholdVal, softNmsSigmaVal);
+    const { selectedIndices, selectedScores } = nonMaxSuppressionV5Impl$1(boxesVals, scoresVals, maxOutputSizeVal, iouThresholdVal, scoreThresholdVal, softNmsSigmaVal);
     return [
         backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices)),
         backend.makeTensorInfo([selectedScores.length], 'float32', new Float32Array(selectedScores))
     ];
 }
-const nonMaxSuppressionV5Config = {
+const nonMaxSuppressionV5Config$1 = {
     kernelName: NonMaxSuppressionV5,
     backendName: 'webgl',
-    kernelFunc: nonMaxSuppressionV5
+    kernelFunc: nonMaxSuppressionV5$1
 };
 
 
@@ -26390,35 +26916,35 @@ class OneHotProgram {
 }
 
 
-const oneHot = (args) => {
+const oneHot$1 = (args) => {
     const { inputs, backend, attrs } = args;
     const { indices } = inputs;
     const { dtype, depth, onValue, offValue } = attrs;
     const indicesSize = sizeFromShape(indices.shape);
     const program = new OneHotProgram(indicesSize, depth, onValue, offValue);
-    const reshaped = reshape({ inputs: { x: indices }, backend, attrs: { shape: [indicesSize] } });
+    const reshaped = reshape$1({ inputs: { x: indices }, backend, attrs: { shape: [indicesSize] } });
     const result = backend.runWebGLProgram(program, [reshaped], dtype);
     backend.disposeIntermediateTensorInfo(reshaped);
     const outShape = [...indices.shape, depth];
-    const out = reshape({ inputs: { x: result }, backend, attrs: { shape: outShape } });
+    const out = reshape$1({ inputs: { x: result }, backend, attrs: { shape: outShape } });
     backend.disposeIntermediateTensorInfo(result);
     return out;
 };
-const oneHotConfig = {
+const oneHotConfig$1 = {
     kernelName: OneHot,
     backendName: 'webgl',
-    kernelFunc: oneHot
+    kernelFunc: oneHot$1
 };
 
 
-function zerosLike(args) {
+function zerosLike$1(args) {
     const { inputs, backend } = args;
     const { x } = inputs;
     if (x.dtype === 'complex64') {
         const realPart = real({ inputs: { input: x }, backend });
-        const r = zerosLike({ inputs: { x: realPart }, backend });
-        const imagPart = imag({ inputs: { input: x }, backend });
-        const i = zerosLike({ inputs: { x: imagPart }, backend });
+        const r = zerosLike$1({ inputs: { x: realPart }, backend });
+        const imagPart = imag$1({ inputs: { input: x }, backend });
+        const i = zerosLike$1({ inputs: { x: imagPart }, backend });
         const result = complex({ inputs: { real: r, imag: i }, backend });
         backend.disposeIntermediateTensorInfo(realPart);
         backend.disposeIntermediateTensorInfo(r);
@@ -26427,7 +26953,7 @@ function zerosLike(args) {
         return result;
     }
     else {
-        return fill({
+        return fill$1({
             attrs: {
                 shape: x.shape,
                 dtype: x.dtype,
@@ -26437,14 +26963,14 @@ function zerosLike(args) {
         });
     }
 }
-const zerosLikeConfig = {
+const zerosLikeConfig$1 = {
     kernelName: ZerosLike,
     backendName: 'webgl',
-    kernelFunc: zerosLike
+    kernelFunc: zerosLike$1
 };
 
 
-function onesLike(args) {
+function onesLike$1(args) {
     const { inputs, backend } = args;
     const { x } = inputs;
     if (x.dtype === 'string') {
@@ -26452,9 +26978,9 @@ function onesLike(args) {
     }
     else if (x.dtype === 'complex64') {
         const realPart = real({ inputs: { input: x }, backend });
-        const r = onesLike({ inputs: { x: realPart }, backend });
-        const imagPart = imag({ inputs: { input: x }, backend });
-        const i = zerosLike({ inputs: { x: imagPart }, backend });
+        const r = onesLike$1({ inputs: { x: realPart }, backend });
+        const imagPart = imag$1({ inputs: { input: x }, backend });
+        const i = zerosLike$1({ inputs: { x: imagPart }, backend });
         const result = complex({ inputs: { real: r, imag: i }, backend });
         backend.disposeIntermediateTensorInfo(realPart);
         backend.disposeIntermediateTensorInfo(r);
@@ -26465,21 +26991,21 @@ function onesLike(args) {
     else {
         
         
-        return fill({ attrs: { shape: x.shape, dtype: x.dtype, value: 1 }, backend });
+        return fill$1({ attrs: { shape: x.shape, dtype: x.dtype, value: 1 }, backend });
     }
 }
-const onesLikeConfig = {
+const onesLikeConfig$1 = {
     kernelName: OnesLike,
     backendName: 'webgl',
-    kernelFunc: onesLike
+    kernelFunc: onesLike$1
 };
 
 
-function pack(args) {
+function pack$1(args) {
     const { inputs, backend, attrs } = args;
     const { axis } = attrs;
     if (inputs.length === 1) {
-        return expandDims$1({ inputs: { input: inputs[0] }, backend, attrs: { dim: axis } });
+        return expandDims$2({ inputs: { input: inputs[0] }, backend, attrs: { dim: axis } });
     }
     const shape = inputs[0].shape;
     const dtype = inputs[0].dtype;
@@ -26489,18 +27015,18 @@ function pack(args) {
     });
     const intermediateTensorInfos = [];
     const expandedTensors = inputs.map(t => {
-        const expandedT = expandDims$1({ inputs: { input: t }, backend, attrs: { dim: axis } });
+        const expandedT = expandDims$2({ inputs: { input: t }, backend, attrs: { dim: axis } });
         intermediateTensorInfos.push(expandedT);
         return expandedT;
     });
-    const result = concat({ inputs: expandedTensors, backend, attrs: { axis } });
+    const result = concat$1({ inputs: expandedTensors, backend, attrs: { axis } });
     intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return result;
 }
-const packConfig = {
+const packConfig$1 = {
     kernelName: Pack,
     backendName: 'webgl',
-    kernelFunc: pack
+    kernelFunc: pack$1
 };
 
 
@@ -26605,7 +27131,7 @@ class PadPackedProgram {
 }
 
 
-const padV2 = (args) => {
+const padV2$1 = (args) => {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { paddings, constantValue } = attrs;
@@ -26613,7 +27139,7 @@ const padV2 = (args) => {
         
         
         const outputShape = paddings.map((p, i) => p[0]  + x.shape[i] + p[1] );
-        return fill({
+        return fill$1({
             backend,
             attrs: { shape: outputShape, value: constantValue, dtype: x.dtype }
         });
@@ -26624,10 +27150,10 @@ const padV2 = (args) => {
     const customValues = [[constantValue]];
     return backend.runWebGLProgram(program, [x], x.dtype, customValues);
 };
-const padV2Config = {
+const padV2Config$1 = {
     kernelName: PadV2,
     backendName: 'webgl',
-    kernelFunc: padV2
+    kernelFunc: padV2$1
 };
 
 
@@ -26661,11 +27187,11 @@ const POW_PACKED = `
     CHECK_NAN_SNIPPET_PACKED + `
   return result;
 `;
-const pow = binaryKernelFunc({ opSnippet: POW, packedOpSnippet: POW_PACKED });
-const powConfig = {
+const pow$1 = binaryKernelFunc({ opSnippet: POW, packedOpSnippet: POW_PACKED });
+const powConfig$1 = {
     kernelName: Pow,
     backendName: 'webgl',
-    kernelFunc: pow
+    kernelFunc: pow$1
 };
 
 
@@ -26694,17 +27220,17 @@ function prod(args) {
     else {
         const [outShape, reduceShape] = computeOutAndReduceShapes(permutedX.shape, axes);
         const inSize = sizeFromShape(reduceShape);
-        const a2D = reshape({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
+        const a2D = reshape$1({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
         const outputDType = sumOutType(x.dtype);
         const reduced = reduce(a2D, outputDType, 'prod', backend);
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
         toDispose.push(a2D);
         toDispose.push(reduced);
     }
     if (keepDims) {
         toDispose.push(res);
         const newShape = expandShapeToKeepDim(res.shape, origAxes);
-        res = reshape({ inputs: { x: res }, backend, attrs: { shape: newShape } });
+        res = reshape$1({ inputs: { x: res }, backend, attrs: { shape: newShape } });
     }
     toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return res;
@@ -26716,7 +27242,7 @@ const prodConfig = {
 };
 
 
-function raggedGather(args) {
+function raggedGather$1(args) {
     const { inputs, backend, attrs } = args;
     const { paramsNestedSplits, paramsDenseValues, indices } = inputs;
     const { outputRaggedRank } = attrs;
@@ -26729,14 +27255,14 @@ function raggedGather(args) {
     const outputDenseValuesTensor = backend.makeTensorInfo(outputDenseValuesShape, paramsDenseValues.dtype, outputDenseValues);
     return outputNestedSplitsTensors.concat([outputDenseValuesTensor]);
 }
-const raggedGatherConfig = {
+const raggedGatherConfig$1 = {
     kernelName: RaggedGather,
     backendName: 'webgl',
-    kernelFunc: raggedGather,
+    kernelFunc: raggedGather$1,
 };
 
 
-function raggedRange(args) {
+function raggedRange$1(args) {
     const { inputs, backend } = args;
     const { starts, limits, deltas } = inputs;
     const $starts = backend.readSync(starts.dataId);
@@ -26747,14 +27273,14 @@ function raggedRange(args) {
     const rtDenseValues = backend.makeTensorInfo([rtDenseValuesData.length], starts.dtype, rtDenseValuesData);
     return [rtNestedSplits, rtDenseValues];
 }
-const raggedRangeConfig = {
+const raggedRangeConfig$1 = {
     kernelName: RaggedRange,
     backendName: 'webgl',
-    kernelFunc: raggedRange,
+    kernelFunc: raggedRange$1,
 };
 
 
-function raggedTensorToTensor(args) {
+function raggedTensorToTensor$1(args) {
     const { inputs, backend, attrs } = args;
     const { shape, values, defaultValue, rowPartitionTensors } = inputs;
     const { rowPartitionTypes } = attrs;
@@ -26766,32 +27292,32 @@ function raggedTensorToTensor(args) {
     const [outputShape, output] = raggedTensorToTensorImplCPU($shape, shape.shape, $values, values.shape, values.dtype, $defaultValue, defaultValue.shape, $rowPartitionValues, rowPartitionValuesShapes, rowPartitionTypes);
     return backend.makeTensorInfo(outputShape, values.dtype, output);
 }
-const raggedTensorToTensorConfig = {
+const raggedTensorToTensorConfig$1 = {
     kernelName: RaggedTensorToTensor,
     backendName: 'webgl',
-    kernelFunc: raggedTensorToTensor,
+    kernelFunc: raggedTensorToTensor$1,
 };
 
 
-const range$1 = (args) => {
+const range$2 = (args) => {
     const { backend, attrs } = args;
     const { start, stop, step, dtype } = attrs;
     const values = rangeImplCPU(start, stop, step, dtype);
     return backend.makeTensorInfo([values.length], dtype, values);
 };
-const rangeConfig = {
+const rangeConfig$1 = {
     kernelName: Range,
     backendName: 'webgl',
-    kernelFunc: range$1
+    kernelFunc: range$2
 };
 
 
 const RECIPROCAL = `return 1.0 / x;`;
-const reciprocal = unaryKernelFunc({ opSnippet: RECIPROCAL });
-const reciprocalConfig = {
+const reciprocal$1 = unaryKernelFunc({ opSnippet: RECIPROCAL });
+const reciprocalConfig$1 = {
     kernelName: Reciprocal,
     backendName: 'webgl',
-    kernelFunc: reciprocal,
+    kernelFunc: reciprocal$1,
 };
 
 
@@ -26809,11 +27335,11 @@ const RELU_PACKED = `
 
   return result;
 `;
-const relu = unaryKernelFunc({ opSnippet: RELU, packedOpSnippet: RELU_PACKED });
-const reluConfig = {
+const relu$1 = unaryKernelFunc({ opSnippet: RELU, packedOpSnippet: RELU_PACKED });
+const reluConfig$1 = {
     kernelName: Relu$1,
     backendName: 'webgl',
-    kernelFunc: relu
+    kernelFunc: relu$1
 };
 
 
@@ -26831,11 +27357,11 @@ const RELU6_PACKED = `
 
   return result;
 `;
-const relu6 = unaryKernelFunc({ opSnippet: RELU6, packedOpSnippet: RELU6_PACKED });
-const relu6Config = {
+const relu6$1 = unaryKernelFunc({ opSnippet: RELU6, packedOpSnippet: RELU6_PACKED });
+const relu6Config$1 = {
     kernelName: Relu6$1,
     backendName: 'webgl',
-    kernelFunc: relu6
+    kernelFunc: relu6$1
 };
 
 
@@ -27006,7 +27532,7 @@ class ResizeBilinearPackedProgram {
 }
 
 
-function resizeBilinear(args) {
+function resizeBilinear$1(args) {
     const { inputs, backend, attrs } = args;
     const { images } = inputs;
     const { alignCorners, halfPixelCenters, size } = attrs;
@@ -27016,10 +27542,10 @@ function resizeBilinear(args) {
         new ResizeBilinearProgram(images.shape, newHeight, newWidth, alignCorners, halfPixelCenters);
     return backend.runWebGLProgram(program, [images], 'float32');
 }
-const resizeBilinearConfig = {
+const resizeBilinearConfig$1 = {
     kernelName: ResizeBilinear,
     backendName: 'webgl',
-    kernelFunc: resizeBilinear
+    kernelFunc: resizeBilinear$1
 };
 
 
@@ -27135,17 +27661,17 @@ class ResizeBilinearBackpropProgram {
 }
 
 
-function resizeBilinearGrad(args) {
+function resizeBilinearGrad$1(args) {
     const { inputs, backend, attrs } = args;
     const { images, dy } = inputs;
     const { alignCorners } = attrs;
     const program = new ResizeBilinearBackpropProgram(dy.shape, images.shape, alignCorners);
     return backend.runWebGLProgram(program, [dy], dy.dtype);
 }
-const resizeBilinearGradConfig$1 = {
+const resizeBilinearGradConfig$2 = {
     kernelName: ResizeBilinearGrad,
     backendName: 'webgl',
-    kernelFunc: resizeBilinearGrad
+    kernelFunc: resizeBilinearGrad$1
 };
 
 
@@ -27273,7 +27799,7 @@ class ResizeNearestNeighborPackedProgram {
 }
 
 
-function resizeNearestNeighbor(args) {
+function resizeNearestNeighbor$1(args) {
     const { inputs, backend, attrs } = args;
     const { images } = inputs;
     const { alignCorners, halfPixelCenters, size } = attrs;
@@ -27283,10 +27809,10 @@ function resizeNearestNeighbor(args) {
         new ResizeNearestNeighborProgram(images.shape, newHeight, newWidth, alignCorners, halfPixelCenters);
     return backend.runWebGLProgram(program, [images], images.dtype);
 }
-const resizeNearestNeighborConfig = {
+const resizeNearestNeighborConfig$1 = {
     kernelName: ResizeNearestNeighbor,
     backendName: 'webgl',
-    kernelFunc: resizeNearestNeighbor
+    kernelFunc: resizeNearestNeighbor$1
 };
 
 
@@ -27391,17 +27917,17 @@ class ResizeNearestNeigborBackpropProgram {
 }
 
 
-function resizeNearestNeighborGrad(args) {
+function resizeNearestNeighborGrad$1(args) {
     const { inputs, backend, attrs } = args;
     const { images, dy } = inputs;
     const { alignCorners } = attrs;
     const program = new ResizeNearestNeigborBackpropProgram(dy.shape, images.shape, alignCorners);
     return backend.runWebGLProgram(program, [dy], dy.dtype);
 }
-const resizeNearestNeighborGradConfig$1 = {
+const resizeNearestNeighborGradConfig$2 = {
     kernelName: ResizeNearestNeighborGrad,
     backendName: 'webgl',
-    kernelFunc: resizeNearestNeighborGrad
+    kernelFunc: resizeNearestNeighborGrad$1
 };
 
 
@@ -27522,7 +28048,7 @@ class ReversePackedProgram {
 }
 
 
-function reverse(args) {
+function reverse$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { dims } = attrs;
@@ -27536,10 +28062,10 @@ function reverse(args) {
         new ReverseProgram(x.shape, $dims);
     return backend.runWebGLProgram(program, [x], x.dtype);
 }
-const reverseConfig = {
+const reverseConfig$1 = {
     kernelName: Reverse,
     backendName: 'webgl',
-    kernelFunc: reverse
+    kernelFunc: reverse$1
 };
 
 
@@ -27582,7 +28108,7 @@ class RotateProgram {
 }
 
 
-const rotateWithOffsetConfig = {
+const rotateWithOffsetConfig$1 = {
     kernelName: RotateWithOffset,
     backendName: 'webgl',
     kernelFunc: ({ inputs, attrs, backend }) => {
@@ -27614,11 +28140,11 @@ const ROUND = `
     }
   }
 `;
-const round = unaryKernelFunc({ opSnippet: ROUND });
-const roundConfig = {
+const round$1 = unaryKernelFunc({ opSnippet: ROUND });
+const roundConfig$1 = {
     kernelName: Round,
     backendName: 'webgl',
-    kernelFunc: round,
+    kernelFunc: round$1,
 };
 
 
@@ -27757,7 +28283,7 @@ class ScatterPackedProgram {
 }
 
 
-function scatterNd(args) {
+function scatterNd$1(args) {
     const { inputs, backend, attrs } = args;
     const { indices, updates } = inputs;
     const { shape } = attrs;
@@ -27766,8 +28292,8 @@ function scatterNd(args) {
     if (outputSize === 0) {
         return backend.makeTensorInfo(shape, indices.dtype);
     }
-    const flattenIndices = reshape({ inputs: { x: indices }, backend, attrs: { shape: [numUpdates, sliceRank] } });
-    const flattenX = reshape({ inputs: { x: updates }, backend, attrs: { shape: [numUpdates, sliceSize] } });
+    const flattenIndices = reshape$1({ inputs: { x: indices }, backend, attrs: { shape: [numUpdates, sliceRank] } });
+    const flattenX = reshape$1({ inputs: { x: updates }, backend, attrs: { shape: [numUpdates, sliceSize] } });
     const defaultValue = backend.makeTensorInfo([], 'float32', new Float32Array([0])); 
     let program;
     if (env().getBool('WEBGL_PACK')) {
@@ -27777,17 +28303,17 @@ function scatterNd(args) {
         program = new ScatterProgram(numUpdates, sliceRank, flattenIndices.shape.length, flattenX.shape.length, strides, flattenShape);
     }
     const res = backend.runWebGLProgram(program, [flattenX, flattenIndices, defaultValue], flattenX.dtype);
-    const reshaped = reshape({ inputs: { x: res }, backend, attrs: { shape } });
+    const reshaped = reshape$1({ inputs: { x: res }, backend, attrs: { shape } });
     backend.disposeIntermediateTensorInfo(flattenIndices);
     backend.disposeIntermediateTensorInfo(flattenX);
     backend.disposeIntermediateTensorInfo(res);
     backend.disposeIntermediateTensorInfo(defaultValue);
     return reshaped;
 }
-const scatterNdConfig = {
+const scatterNdConfig$1 = {
     kernelName: ScatterNd,
     backendName: 'webgl',
-    kernelFunc: scatterNd
+    kernelFunc: scatterNd$1
 };
 
 
@@ -27834,7 +28360,7 @@ class SearchSortedProgram {
 }
 
 
-function searchSorted(args) {
+function searchSorted$1(args) {
     const { inputs, backend, attrs } = args;
     const { sortedSequence, values } = inputs;
     const { side } = attrs;
@@ -27842,10 +28368,10 @@ function searchSorted(args) {
     const customValues = [[sortedSequence.shape[1]]];
     return backend.runWebGLProgram(program, [sortedSequence, values], 'int32', customValues);
 }
-const searchSortedConfig = {
+const searchSortedConfig$1 = {
     kernelName: SearchSorted,
     backendName: 'webgl',
-    kernelFunc: searchSorted,
+    kernelFunc: searchSorted$1,
 };
 
 
@@ -27891,16 +28417,16 @@ class SelectProgram {
 }
 
 
-function select(args) {
+function select$1(args) {
     const { inputs, backend } = args;
     const { condition, t, e } = inputs;
     const program = new SelectProgram(condition.shape.length, t.shape, t.shape.length);
     return backend.runWebGLProgram(program, [condition, t, e], upcastType(t.dtype, e.dtype));
 }
-const selectConfig = {
+const selectConfig$1 = {
     kernelName: Select,
     backendName: 'webgl',
-    kernelFunc: select
+    kernelFunc: select$1
 };
 
 
@@ -27911,11 +28437,11 @@ const SELU = `
   float scale = ${SELU_SCALE};
   return (x >= 0.0) ? scale * x : scaleAlpha * (exp(x) - 1.0);
 `;
-const selu = unaryKernelFunc({ opSnippet: SELU });
-const seluConfig = {
+const selu$1 = unaryKernelFunc({ opSnippet: SELU });
+const seluConfig$1 = {
     kernelName: Selu$1,
     backendName: 'webgl',
-    kernelFunc: selu,
+    kernelFunc: selu$1,
 };
 
 
@@ -27950,11 +28476,11 @@ const SIGN = `
   if (isnan(x)) { return 0.0; }
   return sign(x);
 `;
-const sign = unaryKernelFunc({ opSnippet: SIGN });
-const signConfig = {
+const sign$1 = unaryKernelFunc({ opSnippet: SIGN });
+const signConfig$1 = {
     kernelName: Sign,
     backendName: 'webgl',
-    kernelFunc: sign,
+    kernelFunc: sign$1,
 };
 
 
@@ -27967,11 +28493,11 @@ const SIN_PACKED = `
   ${CHECK_NAN_SNIPPET_PACKED}
   return result;
 `;
-const sin = unaryKernelFunc({ opSnippet: SIN, packedOpSnippet: SIN_PACKED });
-const sinConfig = {
+const sin$1 = unaryKernelFunc({ opSnippet: SIN, packedOpSnippet: SIN_PACKED });
+const sinConfig$1 = {
     kernelName: Sin,
     backendName: 'webgl',
-    kernelFunc: sin,
+    kernelFunc: sin$1,
 };
 
 
@@ -27979,11 +28505,11 @@ const SINH = `
   float e2x = exp(x);
   return (e2x - 1.0 / e2x) / 2.0;
 `;
-const sinh = unaryKernelFunc({ opSnippet: SINH });
-const sinhConfig = {
+const sinh$1 = unaryKernelFunc({ opSnippet: SINH });
+const sinhConfig$1 = {
     kernelName: Sinh,
     backendName: 'webgl',
-    kernelFunc: sinh,
+    kernelFunc: sinh$1,
 };
 
 
@@ -28008,15 +28534,15 @@ const SOFTPLUS = `
   }
   return result;
 `;
-const softplus = unaryKernelFunc({ opSnippet: SOFTPLUS });
-const softplusConfig = {
+const softplus$1 = unaryKernelFunc({ opSnippet: SOFTPLUS });
+const softplusConfig$1 = {
     kernelName: Softplus$1,
     backendName: 'webgl',
-    kernelFunc: softplus,
+    kernelFunc: softplus$1,
 };
 
 
-const spaceToBatchND = (args) => {
+const spaceToBatchND$1 = (args) => {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { blockShape, paddings } = attrs;
@@ -28029,7 +28555,7 @@ const spaceToBatchND = (args) => {
         completePaddings.push([0, 0]);
     }
     const toDispose = [];
-    const paddedX = padV2({
+    const paddedX = padV2$1({
         inputs: { x },
         backend,
         attrs: { paddings: completePaddings, constantValue: 0 }
@@ -28037,27 +28563,27 @@ const spaceToBatchND = (args) => {
     const reshapedPaddedShape = getReshaped(paddedX.shape, blockShape, prod, false);
     const permutedReshapedPaddedPermutation = getPermuted(reshapedPaddedShape.length, blockShape.length, false);
     const flattenShape = getReshapedPermuted(paddedX.shape, blockShape, prod, false);
-    const reshapedPaddedX = reshape({ inputs: { x: paddedX }, backend, attrs: { shape: reshapedPaddedShape } });
+    const reshapedPaddedX = reshape$1({ inputs: { x: paddedX }, backend, attrs: { shape: reshapedPaddedShape } });
     const paddedXT = transpose({
         inputs: { x: reshapedPaddedX },
         backend,
         attrs: { perm: permutedReshapedPaddedPermutation }
     });
-    const result = reshape({ inputs: { x: paddedXT }, backend, attrs: { shape: flattenShape } });
+    const result = reshape$1({ inputs: { x: paddedXT }, backend, attrs: { shape: flattenShape } });
     toDispose.push(paddedX);
     toDispose.push(reshapedPaddedX);
     toDispose.push(paddedXT);
     toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return result;
 };
-const spaceToBatchNDConfig = {
+const spaceToBatchNDConfig$1 = {
     kernelName: SpaceToBatchND,
     backendName: 'webgl',
-    kernelFunc: spaceToBatchND
+    kernelFunc: spaceToBatchND$1
 };
 
 
-function sparseFillEmptyRows(args) {
+function sparseFillEmptyRows$1(args) {
     const { inputs, backend } = args;
     const { indices, values, denseShape, defaultValue } = inputs;
     if (denseShape.shape.length !== 1) {
@@ -28088,14 +28614,14 @@ function sparseFillEmptyRows(args) {
         backend.makeTensorInfo([reverseIndexMap.length], indices.dtype, new Int32Array(reverseIndexMap)),
     ];
 }
-const sparseFillEmptyRowsConfig = {
+const sparseFillEmptyRowsConfig$1 = {
     kernelName: SparseFillEmptyRows,
     backendName: 'webgl',
-    kernelFunc: sparseFillEmptyRows,
+    kernelFunc: sparseFillEmptyRows$1,
 };
 
 
-function sparseReshape(args) {
+function sparseReshape$1(args) {
     const { inputs, backend } = args;
     const { inputIndices, inputShape, newShape } = inputs;
     if (inputIndices.shape.length !== 2) {
@@ -28116,14 +28642,14 @@ function sparseReshape(args) {
         backend.makeTensorInfo([outputShape.length], newShape.dtype, new Int32Array(outputShape)),
     ];
 }
-const sparseReshapeConfig = {
+const sparseReshapeConfig$1 = {
     kernelName: SparseReshape,
     backendName: 'webgl',
-    kernelFunc: sparseReshape,
+    kernelFunc: sparseReshape$1,
 };
 
 
-function sparseSegmentMean(args) {
+function sparseSegmentMean$1(args) {
     const { inputs, backend } = args;
     const { data, indices, segmentIds } = inputs;
     if (data.shape.length < 1) {
@@ -28143,14 +28669,14 @@ function sparseSegmentMean(args) {
     const [outputData, outputDataShape] = sparseSegmentReductionImplCPU($data, data.shape, data.dtype, $indices, $segmentIds, true);
     return backend.makeTensorInfo(outputDataShape, data.dtype, outputData);
 }
-const sparseSegmentMeanConfig = {
+const sparseSegmentMeanConfig$1 = {
     kernelName: SparseSegmentMean,
     backendName: 'webgl',
-    kernelFunc: sparseSegmentMean,
+    kernelFunc: sparseSegmentMean$1,
 };
 
 
-function sparseSegmentSum(args) {
+function sparseSegmentSum$1(args) {
     const { inputs, backend } = args;
     const { data, indices, segmentIds } = inputs;
     if (data.shape.length < 1) {
@@ -28170,14 +28696,14 @@ function sparseSegmentSum(args) {
     const [outputData, outputDataShape] = sparseSegmentReductionImplCPU($data, data.shape, data.dtype, $indices, $segmentIds);
     return backend.makeTensorInfo(outputDataShape, data.dtype, outputData);
 }
-const sparseSegmentSumConfig = {
+const sparseSegmentSumConfig$1 = {
     kernelName: SparseSegmentSum,
     backendName: 'webgl',
-    kernelFunc: sparseSegmentSum,
+    kernelFunc: sparseSegmentSum$1,
 };
 
 
-function sparseToDense(args) {
+function sparseToDense$1(args) {
     const { inputs, backend, attrs } = args;
     const { sparseIndices, sparseValues, defaultValue } = inputs;
     const { outputShape } = attrs;
@@ -28192,18 +28718,18 @@ function sparseToDense(args) {
     }
     const program = new ScatterProgram(numUpdates, sliceRank, sparseIndices.shape.length, sparseValues.shape.length, strides, [outputSize, 1], sumDupeIndices);
     const res = backend.runWebGLProgram(program, [sparseValues, sparseIndices, defaultValue], sparseValues.dtype);
-    const reshaped = reshape({ inputs: { x: res }, backend, attrs: { shape: outputShape } });
+    const reshaped = reshape$1({ inputs: { x: res }, backend, attrs: { shape: outputShape } });
     backend.disposeIntermediateTensorInfo(res);
     return reshaped;
 }
-const sparseToDenseConfig = {
+const sparseToDenseConfig$1 = {
     kernelName: SparseToDense,
     backendName: 'webgl',
-    kernelFunc: sparseToDense
+    kernelFunc: sparseToDense$1
 };
 
 
-function splitV(args) {
+function splitV$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { numOrSizeSplits, axis } = attrs;
@@ -28220,10 +28746,10 @@ function splitV(args) {
         return sliceT;
     });
 }
-const splitVConfig = {
+const splitVConfig$1 = {
     kernelName: SplitV,
     backendName: 'webgl',
-    kernelFunc: splitV
+    kernelFunc: splitV$1
 };
 
 
@@ -28238,7 +28764,7 @@ const sqrtConfig = {
 
 const SQUARE = `return x * x;`;
 const square$1 = unaryKernelFunc({ opSnippet: SQUARE });
-const squareConfig = {
+const squareConfig$1 = {
     kernelName: Square,
     backendName: 'webgl',
     kernelFunc: square$1,
@@ -28272,7 +28798,7 @@ const staticRegexReplaceConfig = {
 };
 
 
-function step({ inputs, attrs, backend }) {
+function step$1({ inputs, attrs, backend }) {
     const { x } = inputs;
     const opSnippet = CHECK_NAN_SNIPPET$1 + `
     return x > 0.0 ? 1.0 : float(${attrs.alpha});
@@ -28280,10 +28806,10 @@ function step({ inputs, attrs, backend }) {
     const program = new UnaryOpProgram(x.shape, opSnippet);
     return backend.runWebGLProgram(program, [x], x.dtype);
 }
-const stepConfig = {
+const stepConfig$1 = {
     kernelName: Step,
     backendName: 'webgl',
-    kernelFunc: step,
+    kernelFunc: step$1,
 };
 
 
@@ -28322,7 +28848,7 @@ class StridedSliceProgram {
 }
 
 
-function stridedSlice(args) {
+function stridedSlice$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { begin, end, strides, beginMask, endMask, ellipsisMask, newAxisMask, shrinkAxisMask } = attrs;
@@ -28330,7 +28856,7 @@ function stridedSlice(args) {
     let result;
     if (isIdentity) {
         
-        result = reshape({ inputs: { x }, backend, attrs: { shape: finalShape } });
+        result = reshape$1({ inputs: { x }, backend, attrs: { shape: finalShape } });
     }
     else if (sliceDim0 || isSimpleSlice) {
         
@@ -28339,7 +28865,7 @@ function stridedSlice(args) {
         
         const sliced = slice({ inputs: { x }, backend, attrs: { begin: $begin, size } });
         result =
-            reshape({ inputs: { x: sliced }, backend, attrs: { shape: finalShape } });
+            reshape$1({ inputs: { x: sliced }, backend, attrs: { shape: finalShape } });
         backend.disposeIntermediateTensorInfo(sliced);
     }
     else {
@@ -28357,18 +28883,18 @@ function stridedSlice(args) {
             result = backend.runWebGLProgram(program, [x], x.dtype);
         }
     }
-    const resultReshaped = reshape({ inputs: { x: result }, backend, attrs: { shape: finalShape } });
+    const resultReshaped = reshape$1({ inputs: { x: result }, backend, attrs: { shape: finalShape } });
     backend.disposeIntermediateTensorInfo(result);
     return resultReshaped;
 }
-const stridedSliceConfig = {
+const stridedSliceConfig$1 = {
     kernelName: StridedSlice,
     backendName: 'webgl',
-    kernelFunc: stridedSlice
+    kernelFunc: stridedSlice$1
 };
 
 
-function stringNGrams(args) {
+function stringNGrams$1(args) {
     const { inputs, backend, attrs } = args;
     const { separator, nGramWidths, leftPad, rightPad, padWidth, preserveShortSequences } = attrs;
     const { data, dataSplits } = inputs;
@@ -28380,14 +28906,14 @@ function stringNGrams(args) {
         backend.makeTensorInfo(dataSplits.shape, 'int32', nGramsSplits),
     ];
 }
-const stringNGramsConfig = {
+const stringNGramsConfig$1 = {
     kernelName: StringNGrams,
     backendName: 'webgl',
-    kernelFunc: stringNGrams,
+    kernelFunc: stringNGrams$1,
 };
 
 
-function stringSplit(args) {
+function stringSplit$1(args) {
     const { inputs, backend, attrs } = args;
     const { skipEmpty } = attrs;
     const { input, delimiter } = inputs;
@@ -28410,14 +28936,14 @@ function stringSplit(args) {
         backend.makeTensorInfo([2], 'int32', new Int32Array(shape))
     ];
 }
-const stringSplitConfig = {
+const stringSplitConfig$1 = {
     kernelName: StringSplit,
     backendName: 'webgl',
-    kernelFunc: stringSplit,
+    kernelFunc: stringSplit$1,
 };
 
 
-function stringToHashBucketFast(args) {
+function stringToHashBucketFast$1(args) {
     const { inputs, backend, attrs } = args;
     const { numBuckets } = attrs;
     const { input } = inputs;
@@ -28431,19 +28957,19 @@ function stringToHashBucketFast(args) {
     const output = stringToHashBucketFastImplCPU($input, numBuckets);
     return backend.makeTensorInfo(input.shape, 'int32', output);
 }
-const stringToHashBucketFastConfig = {
+const stringToHashBucketFastConfig$1 = {
     kernelName: StringToHashBucketFast,
     backendName: 'webgl',
-    kernelFunc: stringToHashBucketFast,
+    kernelFunc: stringToHashBucketFast$1,
 };
 
 
 const TAN = `return tan(x);`;
-const tan = unaryKernelFunc({ opSnippet: TAN });
-const tanConfig = {
+const tan$1 = unaryKernelFunc({ opSnippet: TAN });
+const tanConfig$1 = {
     kernelName: Tan,
     backendName: 'webgl',
-    kernelFunc: tan,
+    kernelFunc: tan$1,
 };
 
 
@@ -28451,15 +28977,15 @@ const TANH = `
   float e2x = exp(-2.0 * abs(x));
   return sign(x) * (1.0 - e2x) / (1.0 + e2x);
 `;
-const tanh = unaryKernelFunc({ opSnippet: TANH });
-const tanhConfig = {
+const tanh$1 = unaryKernelFunc({ opSnippet: TANH });
+const tanhConfig$1 = {
     kernelName: Tanh$1,
     backendName: 'webgl',
-    kernelFunc: tanh,
+    kernelFunc: tanh$1,
 };
 
 
-function tensorScatterUpdate(args) {
+function tensorScatterUpdate$1(args) {
     const { inputs, backend} = args;
     const { tensor, indices, updates } = inputs;
     const { sliceRank, numUpdates, sliceSize, strides, outputSize } = calculateShapes(updates, indices, tensor.shape);
@@ -28467,22 +28993,22 @@ function tensorScatterUpdate(args) {
     if (outputSize === 0) {
         return backend.makeTensorInfo(tensor.shape, indices.dtype);
     }
-    const flattenIndices = reshape({ inputs: { x: indices }, backend, attrs: { shape: [numUpdates, sliceRank] } });
-    const flattenX = reshape({ inputs: { x: updates }, backend, attrs: { shape: [numUpdates, sliceSize] } });
-    const flattenTensor = reshape({ inputs: { x: tensor }, backend, attrs: { shape: flattenShape } });
+    const flattenIndices = reshape$1({ inputs: { x: indices }, backend, attrs: { shape: [numUpdates, sliceRank] } });
+    const flattenX = reshape$1({ inputs: { x: updates }, backend, attrs: { shape: [numUpdates, sliceSize] } });
+    const flattenTensor = reshape$1({ inputs: { x: tensor }, backend, attrs: { shape: flattenShape } });
     const program = new ScatterProgram(numUpdates, sliceRank, flattenIndices.shape.length, flattenX.shape.length, strides, flattenShape, false, true);
     const res = backend.runWebGLProgram(program, [flattenX, flattenIndices, flattenTensor], flattenTensor.dtype);
-    const reshaped = reshape({ inputs: { x: res }, backend, attrs: { shape: tensor.shape } });
+    const reshaped = reshape$1({ inputs: { x: res }, backend, attrs: { shape: tensor.shape } });
     backend.disposeIntermediateTensorInfo(flattenIndices);
     backend.disposeIntermediateTensorInfo(flattenX);
     backend.disposeIntermediateTensorInfo(flattenTensor);
     backend.disposeIntermediateTensorInfo(res);
     return reshaped;
 }
-const tensorScatterUpdateConfig = {
+const tensorScatterUpdateConfig$1 = {
     kernelName: TensorScatterUpdate,
     backendName: 'webgl',
-    kernelFunc: tensorScatterUpdate
+    kernelFunc: tensorScatterUpdate$1
 };
 
 
@@ -28522,7 +29048,7 @@ function getSourceCoords(aShape) {
 }
 
 
-function tile$1(params) {
+function tile$2(params) {
     const { inputs, backend, attrs } = params;
     const { x } = inputs;
     const { reps } = attrs;
@@ -28542,10 +29068,10 @@ function tile$1(params) {
     const output = backend.runWebGLProgram(program, [x], x.dtype);
     return output;
 }
-const tileConfig = {
+const tileConfig$1 = {
     kernelName: Tile,
     backendName: 'webgl',
-    kernelFunc: tile$1,
+    kernelFunc: tile$2,
 };
 
 
@@ -28683,7 +29209,7 @@ function roundUpToPow2(num) {
 }
 
 
-function topK(args) {
+function topK$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { k, sorted } = attrs;
@@ -28714,7 +29240,7 @@ function topK(args) {
     }
     if (lastDim === 1 ) {
         return [
-            x, fill({ attrs: { shape: xShape, dtype: 'int32', value: 0 }, backend })
+            x, fill$1({ attrs: { shape: xShape, dtype: 'int32', value: 0 }, backend })
         ];
     }
     
@@ -28725,7 +29251,7 @@ function topK(args) {
     
     const xSize = sizeFromShape(xShape);
     const batch = xSize / lastDim;
-    const x2D = reshape({ inputs: { x: xUnPacked }, attrs: { shape: [batch, lastDim] }, backend });
+    const x2D = reshape$1({ inputs: { x: xUnPacked }, attrs: { shape: [batch, lastDim] }, backend });
     if (xIsPacked) {
         disposeIntermediateTensorInfoOrNull(backend, xUnPacked);
     }
@@ -28778,24 +29304,24 @@ function topK(args) {
     indices = slice({ inputs: { x: indices }, backend, attrs: { begin: 0, size: [batch, k] } });
     disposeIntermediateTensorInfoOrNull(backend, prevIndices);
     
-    let values = gatherV2({ inputs: { x: x2D, indices }, backend, attrs: { axis: 1, batchDims: 1 } });
+    let values = gatherV2$1({ inputs: { x: x2D, indices }, backend, attrs: { axis: 1, batchDims: 1 } });
     disposeIntermediateTensorInfoOrNull(backend, x2D);
     
     
     const newShape = xShape.slice(0, -1);
     newShape.push(k);
     prevIndices = indices;
-    indices = reshape({ inputs: { x: indices }, attrs: { shape: newShape }, backend });
+    indices = reshape$1({ inputs: { x: indices }, attrs: { shape: newShape }, backend });
     disposeIntermediateTensorInfoOrNull(backend, prevIndices);
     const prevValues = values;
-    values = reshape({ inputs: { x: values }, attrs: { shape: newShape }, backend });
+    values = reshape$1({ inputs: { x: values }, attrs: { shape: newShape }, backend });
     disposeIntermediateTensorInfoOrNull(backend, prevValues);
     return [values, indices];
 }
-const topKConfig = {
+const topKConfig$1 = {
     kernelName: TopK,
     backendName: 'webgl',
-    kernelFunc: topK
+    kernelFunc: topK$1
 };
 
 
@@ -28939,7 +29465,7 @@ class TransformProgram {
 }
 
 
-function transform(args) {
+function transform$1(args) {
     const { inputs, backend, attrs } = args;
     const { image, transforms } = inputs;
     const { interpolation, fillMode, fillValue, outputShape } = attrs;
@@ -28950,18 +29476,18 @@ function transform(args) {
     const program = new TransformProgram(imageHeight, imageWidth, interpolation, fillMode, fillValue, outShape);
     return backend.runWebGLProgram(program, [image, transforms], 'float32');
 }
-const transformConfig = {
+const transformConfig$1 = {
     kernelName: Transform,
     backendName: 'webgl',
-    kernelFunc: transform
+    kernelFunc: transform$1
 };
 
 
-function unique$1(args) {
+function unique$2(args) {
     const { inputs, attrs, backend } = args;
     const { axis } = attrs;
     const { x } = inputs;
-    assertNotComplex(x, 'unique');
+    assertNotComplex$1(x, 'unique');
     
     console.warn('WARNING: ', 'UI might be locked temporarily as data is being downloaded');
     const values = backend.readSync(x.dataId);
@@ -28971,14 +29497,14 @@ function unique$1(args) {
         backend.makeTensorInfo([indices.length], 'int32', indices),
     ];
 }
-const uniqueConfig = {
+const uniqueConfig$1 = {
     kernelName: Unique,
     backendName: 'webgl',
-    kernelFunc: unique$1,
+    kernelFunc: unique$2,
 };
 
 
-function unpack(args) {
+function unpack$1(args) {
     const { inputs, backend, attrs } = args;
     const { value } = inputs;
     let { axis } = attrs;
@@ -29003,17 +29529,17 @@ function unpack(args) {
     for (let i = 0; i < res.length; i++) {
         begin[axis] = i;
         const sliced = slice({ inputs: { x }, backend, attrs: { begin, size } });
-        const reshaped = reshape({ inputs: { x: sliced }, backend, attrs: { shape: outShape } });
+        const reshaped = reshape$1({ inputs: { x: sliced }, backend, attrs: { shape: outShape } });
         res[i] = reshaped;
         toDispose.push(sliced);
     }
     toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return res;
 }
-const unpackConfig = {
+const unpackConfig$1 = {
     kernelName: Unpack,
     backendName: 'webgl',
-    kernelFunc: unpack
+    kernelFunc: unpack$1
 };
 
 
@@ -29150,7 +29676,7 @@ class SegmentOpProgram {
 }
 
 
-function unsortedSegmentSum(args) {
+function unsortedSegmentSum$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, segmentIds } = inputs;
     const { numSegments } = attrs;
@@ -29166,7 +29692,7 @@ function unsortedSegmentSum(args) {
     }
     const outShape = computeOutShape(permutedX.shape, axis, numSegments);
     const inSize = sizeFromShape([permutedX.shape[axis]]);
-    const a2D = reshape({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
+    const a2D = reshape$1({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
     toDispose.push(a2D);
     const outputDType = sumOutType(x.dtype);
     const segOpCompute = (x, segOpType, segmentIds, dtype, numSegments) => {
@@ -29181,11 +29707,11 @@ function unsortedSegmentSum(args) {
         if (output.shape[1] === numSegments) {
             return output;
         }
-        const rangeInfo = range$1({
+        const rangeInfo = range$2({
             backend,
             attrs: { start: 0, stop: numSegments, step: 1, dtype: 'float32' }
         });
-        const tileInfo = tile$1({
+        const tileInfo = tile$2({
             inputs: { x: rangeInfo },
             backend,
             attrs: { reps: [inSize / windowSize] }
@@ -29196,7 +29722,7 @@ function unsortedSegmentSum(args) {
         return result;
     };
     const segOpResult = segOpCompute(a2D, 'unsortedSegmentSum', segmentIds, outputDType, numSegments);
-    const reshaped = reshape({ inputs: { x: segOpResult }, backend, attrs: { shape: outShape } });
+    const reshaped = reshape$1({ inputs: { x: segOpResult }, backend, attrs: { shape: outShape } });
     let result = reshaped;
     if (permutation != null) {
         toDispose.push(reshaped);
@@ -29206,20 +29732,5591 @@ function unsortedSegmentSum(args) {
     toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return result;
 }
-const unsortedSegmentSumConfig = {
+const unsortedSegmentSumConfig$1 = {
     kernelName: UnsortedSegmentSum,
     backendName: 'webgl',
+    kernelFunc: unsortedSegmentSum$1
+};
+
+
+
+const kernelConfigs$1 = [
+    _fusedMatMulConfig$1,
+    absConfig,
+    acosConfig$1,
+    acoshConfig$1,
+    addConfig,
+    addNConfig$1,
+    allConfig$1,
+    anyConfig$1,
+    argMaxConfig$1,
+    argMinConfig$1,
+    asinConfig$1,
+    asinhConfig$1,
+    atanConfig$1,
+    atan2Config$1,
+    atanhConfig$1,
+    avgPoolConfig$1,
+    avgPool3DConfig$1,
+    avgPool3DGradConfig$2,
+    avgPoolGradConfig$2,
+    batchMatMulConfig$1,
+    batchNormConfig$1,
+    batchToSpaceNDConfig$1,
+    bincountConfig$1,
+    bitwiseAndConfig,
+    broadcastArgsConfig$1,
+    castConfig,
+    ceilConfig,
+    clipByValueConfig$1,
+    complexConfig,
+    complexAbsConfig$1,
+    concatConfig$1,
+    conv2DConfig$1,
+    conv2DBackpropFilterConfig$1,
+    conv2DBackpropInputConfig$1,
+    conv3DConfig$1,
+    conv3DBackpropFilterV2Config$1,
+    conv3DBackpropInputConfig,
+    cosConfig$1,
+    coshConfig$1,
+    cropAndResizeConfig$1,
+    cumprodConfig$1,
+    cumsumConfig$1,
+    denseBincountConfig$1,
+    depthToSpaceConfig$1,
+    depthwiseConv2dNativeConfig$1,
+    depthwiseConv2dNativeBackpropFilterConfig$1,
+    depthwiseConv2dNativeBackpropInputConfig$1,
+    diagConfig$1,
+    dilation2DConfig$1,
+    einsumConfig$1,
+    eluConfig$1,
+    eluGradConfig$2,
+    equalConfig,
+    erfConfig$1,
+    expConfig,
+    expandDimsConfig$1,
+    expm1Config,
+    fftConfig$1,
+    fillConfig$1,
+    flipLeftRightConfig$1,
+    floorConfig,
+    floorDivConfig,
+    fromPixelsConfig,
+    fusedConv2DConfig$1,
+    fusedDepthwiseConv2DConfig$1,
+    gatherNdConfig$1,
+    gatherV2Config$1,
+    greaterConfig,
+    greaterEqualConfig,
+    identityConfig,
+    ifftConfig$1,
+    imagConfig$1,
+    isFiniteConfig$1,
+    isInfConfig$1,
+    isNaNConfig$1,
+    leakyReluConfig$1,
+    lessConfig,
+    lessEqualConfig,
+    linSpaceConfig$1,
+    logConfig,
+    log1pConfig$1,
+    logicalAndConfig$1,
+    logicalNotConfig$1,
+    logicalOrConfig$1,
+    LRNConfig$1,
+    LRNGradConfig$1,
+    maxConfig$1,
+    maximumConfig,
+    maxPoolConfig$1,
+    maxPool3DConfig$1,
+    maxPool3DGradConfig$2,
+    maxPoolGradConfig$2,
+    maxPoolWithArgmaxConfig$1,
+    meanConfig$1,
+    minConfig$1,
+    minimumConfig,
+    mirrorPadConfig$1,
+    modConfig$1,
+    multinomialConfig$1,
+    multiplyConfig,
+    negConfig,
+    nonMaxSuppressionV3Config$1,
+    nonMaxSuppressionV4Config$1,
+    nonMaxSuppressionV5Config$1,
+    notEqualConfig,
+    oneHotConfig$1,
+    onesLikeConfig$1,
+    packConfig$1,
+    padV2Config$1,
+    powConfig$1,
+    preluConfig$1,
+    prodConfig,
+    raggedGatherConfig$1,
+    raggedRangeConfig$1,
+    raggedTensorToTensorConfig$1,
+    rangeConfig$1,
+    realConfig,
+    realDivConfig$1,
+    reciprocalConfig$1,
+    reluConfig$1,
+    relu6Config$1,
+    reshapeConfig$1,
+    resizeBilinearConfig$1,
+    resizeBilinearGradConfig$2,
+    resizeNearestNeighborConfig$1,
+    resizeNearestNeighborGradConfig$2,
+    reverseConfig$1,
+    rotateWithOffsetConfig$1,
+    roundConfig$1,
+    rsqrtConfig,
+    scatterNdConfig$1,
+    searchSortedConfig$1,
+    selectConfig$1,
+    seluConfig$1,
+    sigmoidConfig,
+    signConfig$1,
+    sinConfig$1,
+    sinhConfig$1,
+    sliceConfig,
+    softmaxConfig$1,
+    softplusConfig$1,
+    spaceToBatchNDConfig$1,
+    sparseFillEmptyRowsConfig$1,
+    sparseReshapeConfig$1,
+    sparseSegmentMeanConfig$1,
+    sparseSegmentSumConfig$1,
+    sparseToDenseConfig$1,
+    splitVConfig$1,
+    sqrtConfig,
+    squareConfig$1,
+    squaredDifferenceConfig,
+    staticRegexReplaceConfig,
+    stepConfig$1,
+    stridedSliceConfig$1,
+    stringNGramsConfig$1,
+    stringSplitConfig$1,
+    stringToHashBucketFastConfig$1,
+    subConfig,
+    sumConfig$1,
+    tanConfig$1,
+    tanhConfig$1,
+    tensorScatterUpdateConfig$1,
+    tileConfig$1,
+    topKConfig$1,
+    transformConfig$1,
+    transposeConfig,
+    uniqueConfig$1,
+    unpackConfig$1,
+    unsortedSegmentSumConfig$1,
+    zerosLikeConfig$1
+];
+for (const kernelConfig of kernelConfigs$1) {
+    registerKernel(kernelConfig);
+}
+
+
+const whereImpl = whereImpl$2;
+class MathBackendCPU extends KernelBackend {
+    nextDataId() {
+        return MathBackendCPU.nextDataId++;
+    }
+    constructor() {
+        super();
+        this.blockSize = 48;
+        this.firstUse = true;
+        this.data = new DataStorage(this, engine());
+    }
+    write(values, shape, dtype) {
+        if (this.firstUse) {
+            this.firstUse = false;
+            if (env().get('IS_NODE')) {
+                warn('\n============================\n' +
+                    'Hi, looks like you are running TensorFlow.js in ' +
+                    'Node.js. To speed things up dramatically, install our node ' +
+                    'backend, visit https://github.com/tensorflow/tfjs-node for more details. ' +
+                    '\n============================');
+            }
+        }
+        const dataId = { id: this.nextDataId() };
+        this.data.set(dataId, { values, dtype, refCount: 1 });
+        return dataId;
+    }
+    
+    makeTensorInfo(shape, dtype, values) {
+        let outId;
+        if (dtype === 'string' && values != null && values.length > 0 &&
+            isString(values[0])) {
+            const encodedValues = values.map(d => encodeString(d));
+            outId = this.write(encodedValues, shape, dtype);
+        }
+        else {
+            outId = this.write(values, shape, dtype);
+        }
+        return { dataId: outId, shape, dtype };
+    }
+    
+    refCount(dataId) {
+        if (this.data.has(dataId)) {
+            const tensorData = this.data.get(dataId);
+            return tensorData.refCount;
+        }
+        return 0;
+    }
+    
+    incRef(dataId) {
+        const tensorData = this.data.get(dataId);
+        tensorData.refCount++;
+    }
+    
+    decRef(dataId) {
+        if (this.data.has(dataId)) {
+            const tensorData = this.data.get(dataId);
+            tensorData.refCount--;
+        }
+    }
+    move(dataId, values, shape, dtype, refCount) {
+        this.data.set(dataId, { values, dtype, refCount });
+    }
+    numDataIds() {
+        return this.data.numDataIds();
+    }
+    async read(dataId) {
+        return this.readSync(dataId);
+    }
+    readSync(dataId) {
+        const { dtype, complexTensorInfos } = this.data.get(dataId);
+        if (dtype === 'complex64') {
+            const realValues = this.readSync(complexTensorInfos.real.dataId);
+            const imagValues = this.readSync(complexTensorInfos.imag.dataId);
+            return mergeRealAndImagArrays(realValues, imagValues);
+        }
+        return convertBackendValuesAndArrayBuffer(this.data.get(dataId).values, dtype);
+    }
+    bufferSync(t) {
+        const data = this.readSync(t.dataId);
+        if (t.dtype === 'string') {
+            try {
+                
+                const strings = data.map(d => decodeString(d));
+                return buffer(t.shape, t.dtype, strings);
+            }
+            catch (_a) {
+                throw new Error('Failed to decode encoded string bytes into utf-8');
+            }
+        }
+        return buffer(t.shape, t.dtype, data);
+    }
+    makeOutput(values, shape, dtype) {
+        return engine().makeTensorFromTensorInfo(this.makeTensorInfo(shape, dtype, values), this);
+    }
+    
+    disposeData(dataId, force = false) {
+        if (this.data.has(dataId)) {
+            this.data.get(dataId).refCount--;
+            if (!force && this.data.get(dataId).refCount > 0) {
+                return false;
+            }
+            const { complexTensorInfos } = this.data.get(dataId);
+            if (complexTensorInfos != null) {
+                this.disposeData(complexTensorInfos.real.dataId, true);
+                this.disposeData(complexTensorInfos.imag.dataId, true);
+            }
+            this.data.delete(dataId);
+        }
+        return true;
+    }
+    disposeIntermediateTensorInfo(tensorInfo) {
+        this.disposeData(tensorInfo.dataId);
+    }
+    async time(f) {
+        const start = now();
+        f();
+        const kernelMs = now() - start;
+        return { kernelMs };
+    }
+    memory() {
+        return {
+            
+            unreliable: true,
+            reasons: ['The reported memory is an upper bound. Due to automatic garbage ' +
+                    'collection, the true allocated memory may be less.']
+        };
+    }
+    where(condition) {
+        assertNotComplex([condition], 'where');
+        const condVals = this.readSync(condition.dataId);
+        return whereImpl(condition.shape, condVals);
+    }
+    dispose() { }
+    floatPrecision() {
+        return 32;
+    }
+    
+    epsilon() {
+        return super.epsilon();
+    }
+}
+MathBackendCPU.nextDataId = 0;
+
+
+
+
+registerBackend('cpu', () => new MathBackendCPU(), 1 );
+
+
+const elu$1 = unaryKernelFunc$1(Elu$1, (xi) => xi >= 0 ? xi : (Math.exp(xi) - 1));
+const eluConfig = {
+    kernelName: Elu$1,
+    backendName: 'cpu',
+    kernelFunc: elu$1,
+};
+
+
+function leakyRelu(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { alpha } = attrs;
+    assertNotComplex([x], 'leakyRelu');
+    const xSize = sizeFromShape(x.shape);
+    const xVals = backend.data.get(x.dataId).values;
+    const outVals = getTypedArrayFromDType('float32', xSize);
+    for (let i = 0; i < xVals.length; i++) {
+        outVals[i] = xVals[i] < 0 ? alpha * xVals[i] : xVals[i];
+    }
+    return backend.makeTensorInfo(x.shape, 'float32', outVals);
+}
+const leakyReluConfig = {
+    kernelName: LeakyRelu,
+    backendName: 'cpu',
+    kernelFunc: leakyRelu
+};
+
+
+const preluImpl = createSimpleBinaryKernelImpl((xValue, aValue) => xValue < 0 ? aValue * xValue : xValue);
+function prelu(args) {
+    const { inputs, backend } = args;
+    const { x, alpha } = inputs;
+    assertNotComplex([x, alpha], 'prelu');
+    const aVals = backend.data.get(x.dataId).values;
+    const bVals = backend.data.get(alpha.dataId).values;
+    const [resultData, resultShape] = preluImpl(x.shape, alpha.shape, aVals, bVals, 'float32');
+    return backend.makeTensorInfo(resultShape, 'float32', resultData);
+}
+const preluConfig = {
+    kernelName: Prelu,
+    backendName: 'cpu',
+    kernelFunc: prelu,
+};
+
+
+const relu = unaryKernelFunc$1(Relu$1, (xi) => Math.max(0, xi));
+const reluConfig = {
+    kernelName: Relu$1,
+    backendName: 'cpu',
+    kernelFunc: relu,
+};
+
+
+const relu6 = unaryKernelFunc$1(Relu6$1, (xi) => Math.min(Math.max(0, xi), 6));
+const relu6Config = {
+    kernelName: Relu6$1,
+    backendName: 'cpu',
+    kernelFunc: relu6,
+};
+
+
+function applyActivation(backend, x, activation, preluActivationWeights, leakyreluAlpha) {
+    if (activation === 'linear') {
+        return identity$1({ inputs: { x }, backend });
+    }
+    else if (activation === 'relu') {
+        return relu({ inputs: { x }, backend });
+    }
+    else if (activation === 'elu') {
+        return elu$1({ inputs: { x }, backend });
+    }
+    else if (activation === 'relu6') {
+        return relu6({ inputs: { x }, backend });
+    }
+    else if (activation === 'prelu') {
+        return prelu({ inputs: { x, alpha: preluActivationWeights }, backend });
+    }
+    else if (activation === 'leakyrelu') {
+        return leakyRelu({ inputs: { x }, backend, attrs: { alpha: leakyreluAlpha } });
+    }
+    else if (activation === 'sigmoid') {
+        return sigmoid$1({ inputs: { x }, backend });
+    }
+    throw new Error(`Activation ${activation} has not been implemented for the CPU backend.`);
+}
+
+
+function reshape(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { shape } = attrs;
+    const xSize = sizeFromShape(x.shape);
+    const $shape = inferFromImplicitShape(shape, xSize);
+    const $xSize = sizeFromShape($shape);
+    assert$1(xSize === $xSize, () => `The new shape (${$shape}) has ${$xSize} elements and the old ` +
+        `shape (${x.shape}) has ${xSize} elements. The new shape and old ` +
+        `shape must have the same number of elements.`);
+    backend.incRef(x.dataId);
+    const xData = backend.data.get(x.dataId);
+    if (xData.complexTensorInfos != null) {
+        const real = xData.complexTensorInfos.real;
+        const imag = xData.complexTensorInfos.imag;
+        real.shape = $shape;
+        imag.shape = $shape;
+    }
+    return { dataId: x.dataId, shape: $shape, dtype: x.dtype };
+}
+const reshapeConfig = {
+    kernelName: Reshape$1,
+    backendName: 'cpu',
+    kernelFunc: reshape
+};
+
+
+function batchMatMul(args) {
+    const { inputs, backend, attrs } = args;
+    const { a, b } = inputs;
+    const { transposeA, transposeB } = attrs;
+    assertNotComplex([a, b], 'matMul');
+    const aRank = a.shape.length;
+    const bRank = b.shape.length;
+    const innerShapeA = transposeA ? a.shape[aRank - 2] : a.shape[aRank - 1];
+    const innerShapeB = transposeB ? b.shape[bRank - 1] : b.shape[bRank - 2];
+    const outerShapeA = transposeA ? a.shape[aRank - 1] : a.shape[aRank - 2];
+    const outerShapeB = transposeB ? b.shape[bRank - 2] : b.shape[bRank - 1];
+    const outerDimsA = a.shape.slice(0, -2);
+    const outerDimsB = b.shape.slice(0, -2);
+    const batchDimA = sizeFromShape(outerDimsA);
+    const batchDimB = sizeFromShape(outerDimsB);
+    const outShapeOuterDims = assertAndGetBroadcastShape(a.shape.slice(0, -2), b.shape.slice(0, -2));
+    const outShape = outShapeOuterDims.concat([outerShapeA, outerShapeB]);
+    assert$1(innerShapeA === innerShapeB, () => `Error in matMul: inner shapes (${innerShapeA}) and (` +
+        `${innerShapeB}) of Tensors with shapes ${a.shape} and ` +
+        `${b.shape} and transposeA=${transposeA}` +
+        ` and transposeB=${transposeB} must match.`);
+    const a3dShape = transposeA ? [batchDimA, innerShapeA, outerShapeA] :
+        [batchDimA, outerShapeA, innerShapeA];
+    const b3dShape = transposeB ? [batchDimB, outerShapeB, innerShapeB] :
+        [batchDimB, innerShapeB, outerShapeB];
+    
+    const a3d = reshape({ inputs: { x: a }, backend, attrs: { shape: a3dShape } });
+    const b3d = reshape({ inputs: { x: b }, backend, attrs: { shape: b3dShape } });
+    const sharedDim = transposeA ? a3d.shape[1] : a3d.shape[2];
+    const leftDim = transposeA ? a3d.shape[2] : a3d.shape[1];
+    const rightDim = transposeB ? b3d.shape[1] : b3d.shape[2];
+    const batchDim = Math.max(batchDimA, batchDimB);
+    const a3dValues = backend.data.get(a3d.dataId).values;
+    const b3dValues = backend.data.get(b3d.dataId).values;
+    const a3dStrides = computeStrides(a3d.shape);
+    const b3dStrides = computeStrides(b3d.shape);
+    const [aBatch, aOuterStep, aInnerStep] = transposeA ?
+        [a3dStrides[0], 1, a3dStrides[1]] :
+        [a3dStrides[0], a3dStrides[1], 1];
+    const [bInnerStep, bOuterStep, bBatch] = transposeB ?
+        [1, b3dStrides[1], b3dStrides[0]] :
+        [b3dStrides[1], 1, b3dStrides[0]];
+    const size = leftDim * rightDim;
+    const result = buffer([batchDim, leftDim, rightDim], a3d.dtype);
+    const resVals = result.values;
+    const blockSize = backend.blockSize;
+    for (let bi = 0; bi < batchDim; bi++) {
+        const batchIndexA = bi % batchDimA;
+        const batchIndexB = bi % batchDimB;
+        for (let i0 = 0; i0 < leftDim; i0 += blockSize) {
+            
+            const iBlock = Math.min(i0 + blockSize, leftDim);
+            for (let j0 = 0; j0 < rightDim; j0 += blockSize) {
+                const jBlock = Math.min(j0 + blockSize, rightDim);
+                for (let k0 = 0; k0 < sharedDim; k0 += blockSize) {
+                    const kBlock = Math.min(k0 + blockSize, sharedDim);
+                    for (let i = i0; i < iBlock; i++) {
+                        for (let j = j0; j < jBlock; j++) {
+                            let sum = 0.0;
+                            for (let k = k0; k < kBlock; k++) {
+                                const aVal = 
+                                
+                                a3dValues[batchIndexA * aBatch + i * aOuterStep + k * aInnerStep];
+                                const bVal = 
+                                
+                                b3dValues[k * bInnerStep + j * bOuterStep + batchIndexB * bBatch];
+                                sum += aVal * bVal;
+                            }
+                            resVals[bi * size + (i * rightDim + j)] += sum;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    backend.disposeIntermediateTensorInfo(a3d);
+    backend.disposeIntermediateTensorInfo(b3d);
+    
+    return backend.makeTensorInfo(outShape, result.dtype, result.values);
+}
+const batchMatMulConfig = {
+    kernelName: BatchMatMul,
+    backendName: 'cpu',
+    kernelFunc: batchMatMul,
+};
+
+
+function _fusedMatMul(args) {
+    const { inputs, backend, attrs } = args;
+    const { a, b, bias, preluActivationWeights } = inputs;
+    const { transposeA, transposeB, activation, leakyreluAlpha } = attrs;
+    let current;
+    let addRes;
+    let activationRes;
+    const intermediates = [];
+    const matMulRes = batchMatMul({ inputs: { a, b }, attrs: { transposeA, transposeB }, backend });
+    current = matMulRes;
+    if (bias) {
+        addRes = add({ inputs: { a: current, b: bias }, backend });
+        intermediates.push(current);
+        current = addRes;
+    }
+    if (activation) {
+        activationRes = applyActivation(backend, current, activation, preluActivationWeights, leakyreluAlpha);
+        intermediates.push(current);
+        current = activationRes;
+    }
+    for (const i of intermediates) {
+        backend.disposeIntermediateTensorInfo(i);
+    }
+    return current;
+}
+const _fusedMatMulConfig = {
+    kernelName: _FusedMatMul,
+    backendName: 'cpu',
+    kernelFunc: _fusedMatMul,
+};
+
+
+const acos = unaryKernelFunc$1(Acos, (xi) => Math.acos(xi));
+const acosConfig = {
+    kernelName: Acos,
+    backendName: 'cpu',
+    kernelFunc: acos,
+};
+
+
+const acosh = unaryKernelFunc$1(Acosh, (xi) => Math.acosh(xi));
+const acoshConfig = {
+    kernelName: Acosh,
+    backendName: 'cpu',
+    kernelFunc: acosh,
+};
+
+
+function addN(args) {
+    const { inputs, backend } = args;
+    const tensors = inputs;
+    assertNotComplex(inputs, 'addN');
+    const vals = tensors.map(t => backend.data.get(t.dataId).values);
+    const outBuf = buffer(tensors[0].shape, tensors[0].dtype);
+    const outVals = outBuf.values;
+    for (let i = 0; i < tensors.length; i++) {
+        const currVals = vals[i];
+        for (let j = 0; j < outVals.length; j++) {
+            outVals[j] += currVals[j];
+        }
+    }
+    return backend.makeTensorInfo(outBuf.shape, outBuf.dtype, outBuf.values);
+}
+const addNConfig = {
+    kernelName: AddN,
+    backendName: 'cpu',
+    kernelFunc: addN
+};
+
+
+function all(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, keepDims } = attrs;
+    assertNotComplex(x, 'all');
+    const origAxes = parseAxisParam(axis, x.shape);
+    let axes = origAxes;
+    const permutedAxes = getAxesPermutation(axes, x.shape.length);
+    let $x = x;
+    if (permutedAxes != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutedAxes } });
+        axes = getInnerMostAxes(axes.length, x.shape.length);
+    }
+    assertAxesAreInnerMostDims('all', axes, $x.shape.length);
+    const [outShape, reduceShape] = computeOutAndReduceShapes($x.shape, axes);
+    const reduceSize = sizeFromShape(reduceShape);
+    const vals = makeZerosTypedArray(sizeFromShape(outShape), $x.dtype);
+    const aVals = backend.data.get($x.dataId).values;
+    for (let i = 0; i < vals.length; ++i) {
+        const offset = i * reduceSize;
+        let all = aVals[offset];
+        for (let j = 0; j < reduceSize; ++j) {
+            const value = aVals[offset + j];
+            all = all && value;
+        }
+        vals[i] = all;
+    }
+    if (permutedAxes != null) {
+        backend.disposeIntermediateTensorInfo($x);
+    }
+    const result = backend.makeTensorInfo(outShape, $x.dtype, vals);
+    if (keepDims) {
+        const expandedShape = expandShapeToKeepDim(outShape, origAxes);
+        const reshapedResult = reshape({ inputs: { x: result }, backend, attrs: { shape: expandedShape } });
+        backend.disposeIntermediateTensorInfo(result);
+        return reshapedResult;
+    }
+    return result;
+}
+const allConfig = {
+    kernelName: All,
+    backendName: 'cpu',
+    kernelFunc: all
+};
+
+
+function any(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, keepDims } = attrs;
+    assertNotComplex(x, 'any');
+    const origAxes = parseAxisParam(axis, x.shape);
+    let axes = origAxes;
+    const permutedAxes = getAxesPermutation(axes, x.shape.length);
+    let $x = x;
+    if (permutedAxes != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutedAxes } });
+        axes = getInnerMostAxes(axes.length, x.shape.length);
+    }
+    assertAxesAreInnerMostDims('any', axes, $x.shape.length);
+    const [outShape, reduceShape] = computeOutAndReduceShapes($x.shape, axes);
+    const reduceSize = sizeFromShape(reduceShape);
+    const vals = makeZerosTypedArray(sizeFromShape(outShape), $x.dtype);
+    const aVals = backend.data.get($x.dataId).values;
+    for (let i = 0; i < vals.length; ++i) {
+        const offset = i * reduceSize;
+        let anyVal = aVals[offset];
+        for (let j = 0; j < reduceSize; ++j) {
+            const value = aVals[offset + j];
+            anyVal = anyVal || value;
+        }
+        vals[i] = anyVal;
+    }
+    if (permutedAxes != null) {
+        backend.disposeIntermediateTensorInfo($x);
+    }
+    const result = backend.makeTensorInfo(outShape, $x.dtype, vals);
+    if (keepDims) {
+        const expandedShape = expandShapeToKeepDim(outShape, origAxes);
+        const reshapedResult = reshape({ inputs: { x: result }, backend, attrs: { shape: expandedShape } });
+        backend.disposeIntermediateTensorInfo(result);
+        return reshapedResult;
+    }
+    return result;
+}
+const anyConfig = {
+    kernelName: Any,
+    backendName: 'cpu',
+    kernelFunc: any
+};
+
+
+function argMax(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis } = attrs;
+    assertNotComplex(x, 'argMax');
+    let axes = parseAxisParam(axis, x.shape);
+    const permutedAxes = getAxesPermutation(axes, x.shape.length);
+    let $x = x;
+    const intermediateTensorInfos = [];
+    if (permutedAxes != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutedAxes } });
+        intermediateTensorInfos.push($x);
+        axes = getInnerMostAxes(axes.length, $x.shape.length);
+    }
+    axes = [axes[0]];
+    assertAxesAreInnerMostDims('argMax', axes, $x.shape.length);
+    const [outShape, reduceShape] = computeOutAndReduceShapes($x.shape, axes);
+    const outSize = sizeFromShape(outShape);
+    const vals = makeZerosTypedArray(outSize, 'int32');
+    const reduceSize = sizeFromShape(reduceShape);
+    const aVals = backend.data.get($x.dataId).values;
+    for (let i = 0; i < vals.length; ++i) {
+        const offset = i * reduceSize;
+        let max = aVals[offset];
+        let maxIndex = 0;
+        for (let j = 0; j < reduceSize; ++j) {
+            const value = aVals[offset + j];
+            if (value > max) {
+                max = value;
+                maxIndex = j;
+            }
+        }
+        vals[i] = maxIndex;
+    }
+    intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return backend.makeTensorInfo(outShape, 'int32', vals);
+}
+const argMaxConfig = {
+    kernelName: ArgMax,
+    backendName: 'cpu',
+    kernelFunc: argMax
+};
+
+
+function argMin(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis } = attrs;
+    assertNotComplex(x, 'argMin');
+    let axes = parseAxisParam(axis, x.shape);
+    const permutedAxes = getAxesPermutation(axes, x.shape.length);
+    let $x = x;
+    const intermediateTensorInfos = [];
+    if (permutedAxes != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutedAxes } });
+        intermediateTensorInfos.push($x);
+        axes = getInnerMostAxes(axes.length, $x.shape.length);
+    }
+    axes = [axes[0]];
+    assertAxesAreInnerMostDims('argMin', axes, $x.shape.length);
+    const [outShape, reduceShape] = computeOutAndReduceShapes($x.shape, axes);
+    const outSize = sizeFromShape(outShape);
+    const vals = makeZerosTypedArray(outSize, 'int32');
+    const reduceSize = sizeFromShape(reduceShape);
+    const aVals = backend.data.get($x.dataId).values;
+    for (let i = 0; i < vals.length; ++i) {
+        const offset = i * reduceSize;
+        let min = aVals[offset];
+        let minIndex = 0;
+        for (let j = 0; j < reduceSize; ++j) {
+            const value = aVals[offset + j];
+            if (value < min) {
+                min = value;
+                minIndex = j;
+            }
+        }
+        vals[i] = minIndex;
+    }
+    intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return backend.makeTensorInfo(outShape, 'int32', vals);
+}
+const argMinConfig = {
+    kernelName: ArgMin,
+    backendName: 'cpu',
+    kernelFunc: argMin
+};
+
+
+const asin = unaryKernelFunc$1(Asin, (xi) => Math.asin(xi));
+const asinConfig = {
+    kernelName: Asin,
+    backendName: 'cpu',
+    kernelFunc: asin,
+};
+
+
+const asinh = unaryKernelFunc$1(Asinh, (xi) => Math.asinh(xi));
+const asinhConfig = {
+    kernelName: Asinh,
+    backendName: 'cpu',
+    kernelFunc: asinh,
+};
+
+
+const atan = unaryKernelFunc$1(Atan, (xi) => Math.atan(xi));
+const atanConfig = {
+    kernelName: Atan,
+    backendName: 'cpu',
+    kernelFunc: atan,
+};
+
+
+const atan2Impl = createSimpleBinaryKernelImpl((aValue, bValue) => Math.atan2(aValue, bValue));
+const atan2 = binaryKernelFunc$1(Atan2, atan2Impl);
+const atan2Config = {
+    kernelName: Atan2,
+    backendName: 'cpu',
+    kernelFunc: atan2,
+};
+
+
+const atanh = unaryKernelFunc$1(Atanh, (xi) => Math.atanh(xi));
+const atanhConfig = {
+    kernelName: Atanh,
+    backendName: 'cpu',
+    kernelFunc: atanh,
+};
+
+
+function pool(xValues, xShape, dtype, strides, convInfo, poolType) {
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padTop = convInfo.padInfo.top;
+    const padLeft = convInfo.padInfo.left;
+    const initialValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY :
+        Number.POSITIVE_INFINITY);
+    const output = buffer(convInfo.outShape, dtype);
+    const outputVals = output.values;
+    const outputBatchStrides = convInfo.outShape[1] * convInfo.outShape[2] * convInfo.outShape[3];
+    const outputRowStrides = convInfo.outShape[2] * convInfo.outShape[3];
+    const outputColStrides = convInfo.outShape[3];
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        const outputBatchOffset = b * outputBatchStrides;
+        const inputBatchOffset = b * strides[0];
+        for (let d = 0; d < convInfo.inChannels; ++d) {
+            for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+                const xRCorner = yR * strideHeight - padTop;
+                const xRMin = Math.max(0, xRCorner);
+                const xRMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRCorner);
+                const outputRowOffset = outputBatchOffset + yR * outputRowStrides;
+                for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+                    const xCCorner = yC * strideWidth - padLeft;
+                    const xCMin = Math.max(0, xCCorner);
+                    const xCMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xCCorner);
+                    let minMaxValue = initialValue;
+                    let avgValue = 0;
+                    let count = 0;
+                    for (let xR = xRMin; xR < xRMax; xR += dilationHeight) {
+                        const xROffset = inputBatchOffset + xR * strides[1];
+                        for (let xC = xCMin; xC < xCMax; xC += dilationWidth) {
+                            const xCOffset = xROffset + xC * strides[2];
+                            const pixel = xValues[xCOffset + d];
+                            if ((poolType === 'max' && pixel > minMaxValue)) {
+                                minMaxValue = pixel;
+                            }
+                            else if (poolType === 'avg') {
+                                avgValue += pixel;
+                                count++;
+                            }
+                        }
+                        if (isNaN(minMaxValue)) {
+                            break;
+                        }
+                    }
+                    const outputOffset = outputRowOffset + yC * outputColStrides + d;
+                    outputVals[outputOffset] =
+                        poolType === 'avg' ? avgValue / count : minMaxValue;
+                }
+            }
+        }
+    }
+    return output;
+}
+function maxPoolPositions(xValues, xShape, dtype, convInfo, flattenPositions = false, includeBatchInIndex = false) {
+    const maxPositions = buffer(convInfo.outShape, 'int32');
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padTop = convInfo.padInfo.top;
+    const padLeft = convInfo.padInfo.left;
+    const xBuf = buffer(xShape, dtype, xValues);
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        for (let d = 0; d < convInfo.inChannels; ++d) {
+            for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+                const xRCorner = yR * strideHeight - padTop;
+                let xRMin = xRCorner;
+                while (xRMin < 0) {
+                    xRMin += dilationHeight;
+                }
+                
+                const xRMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRCorner);
+                for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+                    const xCCorner = yC * strideWidth - padLeft;
+                    let xCMin = xCCorner;
+                    while (xCMin < 0) {
+                        xCMin += dilationWidth;
+                    }
+                    const xCMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xCCorner);
+                    let maxValue = Number.NEGATIVE_INFINITY;
+                    let maxPosition = -1;
+                    for (let xR = xRMin; xR < xRMax; xR += dilationHeight) {
+                        const wR = xR - xRCorner;
+                        for (let xC = xCMin; xC < xCMax; xC += dilationWidth) {
+                            const wC = xC - xCCorner;
+                            
+                            
+                            
+                            const pixel = xBuf.get(b, xR, xC, d);
+                            if (pixel > maxValue) {
+                                maxValue = pixel;
+                                if (flattenPositions) {
+                                    maxPosition = includeBatchInIndex ?
+                                        ((b * convInfo.inHeight + xR) * convInfo.inWidth + xC) *
+                                            convInfo.inChannels +
+                                            d :
+                                        (xR * convInfo.inWidth + xC) * convInfo.inChannels + d;
+                                }
+                                else {
+                                    maxPosition = wR * effectiveFilterWidth + wC;
+                                }
+                            }
+                        }
+                    }
+                    maxPositions.set(maxPosition, b, yR, yC, d);
+                }
+            }
+        }
+    }
+    return maxPositions;
+}
+function pool3d(xValues, xShape, dtype, strides, convInfo, poolType) {
+    const strideDepth = convInfo.strideDepth;
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const dilationDepth = convInfo.dilationDepth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterDepth = convInfo.effectiveFilterDepth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padFront = convInfo.padInfo.front;
+    const padTop = convInfo.padInfo.top;
+    const padLeft = convInfo.padInfo.left;
+    const initialValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY :
+        Number.POSITIVE_INFINITY);
+    const output = buffer(convInfo.outShape, dtype);
+    const outputVals = output.values;
+    const outputBatchStrides = convInfo.outShape[1] * convInfo.outShape[2] *
+        convInfo.outShape[3] * convInfo.outShape[4];
+    const outputDepthStrides = convInfo.outShape[2] * convInfo.outShape[3] * convInfo.outShape[4];
+    const outputRowStrides = convInfo.outShape[3] * convInfo.outShape[4];
+    const outputColStrides = convInfo.outShape[4];
+    for (let batch = 0; batch < convInfo.batchSize; ++batch) {
+        const outputBatchOffset = batch * outputBatchStrides;
+        const inputBatchOffset = batch * strides[0];
+        for (let channel = 0; channel < convInfo.inChannels; ++channel) {
+            for (let yDepth = 0; yDepth < convInfo.outDepth; ++yDepth) {
+                const xDepthCorner = yDepth * strideDepth - padFront;
+                let xDepthMin = xDepthCorner;
+                while (xDepthMin < 0) {
+                    xDepthMin += dilationDepth;
+                }
+                const xDepthMax = Math.min(convInfo.inDepth, effectiveFilterDepth + xDepthCorner);
+                const outputDepthOffset = outputBatchOffset + yDepth * outputDepthStrides;
+                for (let yRow = 0; yRow < convInfo.outHeight; ++yRow) {
+                    const xRowCorner = yRow * strideHeight - padTop;
+                    let xRowMin = xRowCorner;
+                    while (xRowMin < 0) {
+                        xRowMin += dilationHeight;
+                    }
+                    const xRowMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRowCorner);
+                    const outputRowOffset = outputDepthOffset + yRow * outputRowStrides;
+                    for (let yCol = 0; yCol < convInfo.outWidth; ++yCol) {
+                        const xColCorner = yCol * strideWidth - padLeft;
+                        let xColMin = xColCorner;
+                        while (xColMin < 0) {
+                            xColMin += dilationWidth;
+                        }
+                        const xColMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xColCorner);
+                        
+                        const outputColOffset = outputRowOffset + yCol * outputColStrides;
+                        let minMaxValue = initialValue;
+                        let avgValue = 0;
+                        let count = 0;
+                        for (let xDepth = xDepthMin; xDepth < xDepthMax; xDepth += dilationDepth) {
+                            const xDepthOffset = inputBatchOffset + xDepth * strides[1];
+                            for (let xRow = xRowMin; xRow < xRowMax; xRow += dilationHeight) {
+                                const xRowOffset = xDepthOffset + xRow * strides[2];
+                                for (let xCol = xColMin; xCol < xColMax; xCol += dilationWidth) {
+                                    const xColOffset = xRowOffset + xCol * strides[3];
+                                    const pixel = xValues[xColOffset + channel];
+                                    if ((poolType === 'max' && pixel > minMaxValue)) {
+                                        minMaxValue = pixel;
+                                    }
+                                    else if (poolType === 'avg') {
+                                        avgValue += pixel;
+                                        count++;
+                                    }
+                                    if (isNaN(minMaxValue)) {
+                                        break;
+                                    }
+                                }
+                                if (isNaN(minMaxValue)) {
+                                    break;
+                                }
+                            }
+                            if (isNaN(minMaxValue)) {
+                                break;
+                            }
+                        }
+                        const outputOffset = outputColOffset + channel;
+                        outputVals[outputOffset] = poolType === 'avg' ?
+                            avgValue / Math.max(count, 1) :
+                            minMaxValue;
+                    }
+                }
+            }
+        }
+    }
+    return output;
+}
+function maxPool3dPositions(xBuf, convInfo) {
+    const maxPositions = buffer(convInfo.outShape, 'int32');
+    const strideDepth = convInfo.strideDepth;
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const dilationDepth = convInfo.dilationDepth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterDepth = convInfo.effectiveFilterDepth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padFront = convInfo.padInfo.front;
+    const padTop = convInfo.padInfo.top;
+    const padLeft = convInfo.padInfo.left;
+    for (let batch = 0; batch < convInfo.batchSize; ++batch) {
+        for (let channel = 0; channel < convInfo.inChannels; ++channel) {
+            for (let yDepth = 0; yDepth < convInfo.outDepth; ++yDepth) {
+                const xDepthCorner = yDepth * strideDepth - padFront;
+                let xDepthMin = xDepthCorner;
+                while (xDepthMin < 0) {
+                    xDepthMin += dilationDepth;
+                }
+                const xDepthMax = Math.min(convInfo.inDepth, effectiveFilterDepth + xDepthCorner);
+                for (let yRow = 0; yRow < convInfo.outHeight; ++yRow) {
+                    const xRowCorner = yRow * strideHeight - padTop;
+                    let xRowMin = xRowCorner;
+                    while (xRowMin < 0) {
+                        xRowMin += dilationHeight;
+                    }
+                    const xRowMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRowCorner);
+                    for (let yCol = 0; yCol < convInfo.outWidth; ++yCol) {
+                        const xColCorner = yCol * strideWidth - padLeft;
+                        let xColMin = xColCorner;
+                        while (xColMin < 0) {
+                            xColMin += dilationWidth;
+                        }
+                        const xColMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xColCorner);
+                        
+                        let maxValue = Number.NEGATIVE_INFINITY;
+                        let maxPosition = -1;
+                        for (let xDepth = xDepthMin; xDepth < xDepthMax; xDepth += dilationDepth) {
+                            const wDepth = xDepth - xDepthCorner;
+                            for (let xRow = xRowMin; xRow < xRowMax; xRow += dilationHeight) {
+                                const wRow = xRow - xRowCorner;
+                                for (let xCol = xColMin; xCol < xColMax; xCol += dilationWidth) {
+                                    const wCol = xCol - xColCorner;
+                                    const pixel = xBuf.get(batch, xDepth, xRow, xCol, channel);
+                                    if (pixel >= maxValue) {
+                                        maxValue = pixel;
+                                        maxPosition =
+                                            wDepth * effectiveFilterHeight * effectiveFilterWidth +
+                                                wRow * effectiveFilterHeight + wCol;
+                                    }
+                                }
+                            }
+                        }
+                        maxPositions.set(maxPosition, batch, yDepth, yRow, yCol, channel);
+                    }
+                }
+            }
+        }
+    }
+    return maxPositions;
+}
+
+
+function avgPool(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    assertNotComplex(x, 'avgPool');
+    const { filterSize, strides, pad, dimRoundingMode } = attrs;
+    const dilations = 1;
+    assert$1(eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in avgPool: Either strides or dilations must be 1. ' +
+        `Got strides ${strides} and dilations '${dilations}'`);
+    const convInfo = computePool2DInfo(x.shape, filterSize, strides, dilations, pad, dimRoundingMode);
+    let res;
+    if (convInfo.filterWidth === 1 && convInfo.filterHeight === 1 &&
+        arraysEqual(convInfo.inShape, convInfo.outShape)) {
+        res = identity$1({ inputs: { x }, backend });
+    }
+    else {
+        const xValues = backend.data.get(x.dataId).values;
+        const strides = computeStrides(x.shape);
+        const buffer = pool(xValues, x.shape, x.dtype, strides, convInfo, 'avg');
+        res = backend.makeTensorInfo(convInfo.outShape, x.dtype, buffer.values);
+    }
+    return res;
+}
+const avgPoolConfig = {
+    kernelName: AvgPool,
+    backendName: 'cpu',
+    kernelFunc: avgPool
+};
+
+
+function avgPool3D(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { filterSize, strides, pad, dimRoundingMode, dataFormat } = attrs;
+    assertNotComplex(x, 'avgPool3d');
+    const convInfo = computePool3DInfo(x.shape, filterSize, strides, 1 , pad, dimRoundingMode, dataFormat);
+    const xValues = backend.data.get(x.dataId).values;
+    const outBuf = pool3d(xValues, x.shape, x.dtype, computeStrides(x.shape), convInfo, 'avg');
+    return backend.makeTensorInfo(outBuf.shape, 'float32', outBuf.values);
+}
+const avgPool3DConfig = {
+    kernelName: AvgPool3D,
+    backendName: 'cpu',
+    kernelFunc: avgPool3D
+};
+
+
+function avgPool3DGrad(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, input } = inputs;
+    const { filterSize, strides, pad, dimRoundingMode } = attrs;
+    assertNotComplex([dy, input], 'avgPool3DGrad');
+    const convInfo = computePool3DInfo(input.shape, filterSize, strides, 1 , pad, dimRoundingMode);
+    const strideDepth = convInfo.strideDepth;
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const filterDepth = convInfo.filterDepth;
+    const filterHeight = convInfo.filterHeight;
+    const filterWidth = convInfo.filterWidth;
+    const dilationDepth = convInfo.dilationDepth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterDepth = convInfo.effectiveFilterDepth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padFront = effectiveFilterDepth - 1 - convInfo.padInfo.front;
+    const padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
+    const padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
+    const dx = buffer(input.shape, 'float32');
+    const avgMultiplier = 1 / (filterDepth * filterHeight * filterWidth);
+    const dyBuf = backend.bufferSync(dy);
+    for (let batch = 0; batch < convInfo.batchSize; ++batch) {
+        for (let channel = 0; channel < convInfo.inChannels; ++channel) {
+            for (let dxDepth = 0; dxDepth < convInfo.inDepth; ++dxDepth) {
+                for (let dxRow = 0; dxRow < convInfo.inHeight; ++dxRow) {
+                    for (let dxCol = 0; dxCol < convInfo.inWidth; ++dxCol) {
+                        
+                        const dyDepthCorner = dxDepth - padFront;
+                        const dyRowCorner = dxRow - padTop;
+                        const dyColCorner = dxCol - padLeft;
+                        let dotProd = 0;
+                        for (let wDepth = 0; wDepth < effectiveFilterDepth; wDepth += dilationDepth) {
+                            const dyDepth = (dyDepthCorner + wDepth) / strideDepth;
+                            if (dyDepth < 0 || dyDepth >= convInfo.outDepth ||
+                                Math.floor(dyDepth) !== dyDepth) {
+                                continue;
+                            }
+                            for (let wRow = 0; wRow < effectiveFilterHeight; wRow += dilationHeight) {
+                                const dyRow = (dyRowCorner + wRow) / strideHeight;
+                                if (dyRow < 0 || dyRow >= convInfo.outHeight ||
+                                    Math.floor(dyRow) !== dyRow) {
+                                    continue;
+                                }
+                                for (let wCol = 0; wCol < effectiveFilterWidth; wCol += dilationWidth) {
+                                    const dyCol = (dyColCorner + wCol) / strideWidth;
+                                    if (dyCol < 0 || dyCol >= convInfo.outWidth ||
+                                        Math.floor(dyCol) !== dyCol) {
+                                        continue;
+                                    }
+                                    const pixel = dyBuf.get(batch, dyDepth, dyRow, dyCol, channel);
+                                    dotProd += pixel;
+                                }
+                            }
+                        }
+                        dx.set(dotProd * avgMultiplier, batch, dxDepth, dxRow, dxCol, channel);
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const avgPool3DGradConfig$1 = {
+    kernelName: AvgPool3DGrad,
+    backendName: 'cpu',
+    kernelFunc: avgPool3DGrad
+};
+
+
+function avgPoolGrad$1(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, input } = inputs;
+    const x = input;
+    assertNotComplex([dy, input], 'avgPoolGrad');
+    const { filterSize, strides, pad } = attrs;
+    const convInfo = computePool2DInfo(x.shape, filterSize, strides, 1 , pad);
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const filterHeight = convInfo.filterHeight;
+    const filterWidth = convInfo.filterWidth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
+    const padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
+    const dx = buffer(x.shape, 'float32');
+    const avgMultiplier = 1 / (filterHeight * filterWidth);
+    const dyData = backend.data.get(dy.dataId).values;
+    const dyBuf = buffer(dy.shape, 'float32', dyData);
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        for (let d = 0; d < convInfo.inChannels; ++d) {
+            for (let dxR = 0; dxR < convInfo.inHeight; ++dxR) {
+                for (let dxC = 0; dxC < convInfo.inWidth; ++dxC) {
+                    
+                    const dyRCorner = dxR - padTop;
+                    const dyCCorner = dxC - padLeft;
+                    let dotProd = 0;
+                    for (let wR = 0; wR < effectiveFilterHeight; wR += dilationHeight) {
+                        const dyR = (dyRCorner + wR) / strideHeight;
+                        if (dyR < 0 || dyR >= convInfo.outHeight ||
+                            Math.floor(dyR) !== dyR) {
+                            continue;
+                        }
+                        for (let wC = 0; wC < effectiveFilterWidth; wC += dilationWidth) {
+                            const dyC = (dyCCorner + wC) / strideWidth;
+                            if (dyC < 0 || dyC >= convInfo.outWidth ||
+                                Math.floor(dyC) !== dyC) {
+                                continue;
+                            }
+                            const pixel = dyBuf.get(b, dyR, dyC, d);
+                            dotProd += pixel;
+                        }
+                    }
+                    dx.set(dotProd * avgMultiplier, b, dxR, dxC, d);
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const avgPoolGradConfig$1 = {
+    kernelName: AvgPoolGrad,
+    backendName: 'cpu',
+    kernelFunc: avgPoolGrad$1
+};
+
+
+function batchNorm(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, scale, offset, mean, variance } = inputs;
+    assert$1(mean.shape.length === variance.shape.length, () => 'Batch normalization gradient requires mean and variance to have ' +
+        'equal ranks.');
+    assert$1(offset == null || mean.shape.length === offset.shape.length, () => 'Batch normalization gradient requires mean and offset to have ' +
+        'equal ranks.');
+    assert$1(scale == null || mean.shape.length === scale.shape.length, () => 'Batch normalization gradient requires mean and scale to have ' +
+        'equal ranks.');
+    assertNotComplex([x, mean, variance, scale, offset], 'batchNorm');
+    let { varianceEpsilon } = attrs;
+    if (varianceEpsilon == null) {
+        varianceEpsilon = 0.001;
+    }
+    const xVals = backend.data.get(x.dataId).values;
+    const mVals = backend.data.get(mean.dataId).values;
+    const varVals = backend.data.get(variance.dataId).values;
+    const sVals = scale ? backend.data.get(scale.dataId).values :
+        new Float32Array([1]);
+    const offVals = offset ?
+        backend.data.get(offset.dataId).values :
+        new Float32Array([0]);
+    const outVals = new Float32Array(xVals.length);
+    const offValsLength = offVals.length;
+    const sValsLength = sVals.length;
+    const varValsLength = varVals.length;
+    const mValsLength = mVals.length;
+    let offi = 0;
+    let mi = 0;
+    let si = 0;
+    let vi = 0;
+    for (let i = 0; i < xVals.length; ++i) {
+        outVals[i] = offVals[offi++] +
+            (xVals[i] - mVals[mi++]) * sVals[si++] /
+                Math.sqrt(varVals[vi++] + varianceEpsilon);
+        if (offi >= offValsLength) {
+            offi = 0;
+        }
+        if (mi >= mValsLength) {
+            mi = 0;
+        }
+        if (si >= sValsLength) {
+            si = 0;
+        }
+        if (vi >= varValsLength) {
+            vi = 0;
+        }
+    }
+    return backend.makeTensorInfo(x.shape, x.dtype, outVals);
+}
+const batchNormConfig = {
+    kernelName: FusedBatchNorm,
+    backendName: 'cpu',
+    kernelFunc: batchNorm,
+};
+
+
+function batchToSpaceND(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { blockShape, crops } = attrs;
+    assertNotComplex([x], 'batchToSpaceND');
+    const prod = blockShape.reduce((a, b) => a * b);
+    const reshaped = getReshaped(x.shape, blockShape, prod);
+    const permuted = getPermuted(reshaped.length, blockShape.length);
+    const reshapedPermuted = getReshapedPermuted(x.shape, blockShape, prod);
+    const sliceBeginCoords = getSliceBeginCoords(crops, blockShape.length);
+    const sliceSize = getSliceSize(reshapedPermuted, crops, blockShape.length);
+    const xReshaped = reshape({ inputs: { x }, backend, attrs: { shape: reshaped } });
+    const xTransposed = transpose$1({ inputs: { x: xReshaped }, backend, attrs: { perm: permuted } });
+    const xTransposedReshaped = reshape({ inputs: { x: xTransposed }, backend, attrs: { shape: reshapedPermuted } });
+    const result = slice$1({
+        inputs: { x: xTransposedReshaped },
+        backend,
+        attrs: { begin: sliceBeginCoords, size: sliceSize }
+    });
+    backend.disposeIntermediateTensorInfo(xReshaped);
+    backend.disposeIntermediateTensorInfo(xTransposed);
+    backend.disposeIntermediateTensorInfo(xTransposedReshaped);
+    return result;
+}
+const batchToSpaceNDConfig = {
+    kernelName: BatchToSpaceND,
+    backendName: 'cpu',
+    kernelFunc: batchToSpaceND
+};
+
+
+function bincount(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, weights } = inputs;
+    const { size } = attrs;
+    const xVals = backend.data.get(x.dataId).values;
+    const weightsVals = backend.data.get(weights.dataId).values;
+    const outVals = bincountImpl(xVals, weightsVals, weights.dtype, weights.shape, size);
+    return backend.makeTensorInfo([size], weights.dtype, outVals);
+}
+const bincountConfig = {
+    kernelName: Bincount,
+    backendName: 'cpu',
+    kernelFunc: bincount
+};
+
+
+function broadcastArgs(args) {
+    const { inputs, backend } = args;
+    const { s0, s1 } = inputs;
+    const s0Vals = backend.data.get(s0.dataId).values;
+    const s1Vals = backend.data.get(s1.dataId).values;
+    const broadcastShape = assertAndGetBroadcastShape(Array.from(s0Vals), Array.from(s1Vals));
+    return backend.makeTensorInfo([broadcastShape.length], 'int32', Int32Array.from(broadcastShape));
+}
+const broadcastArgsConfig = {
+    kernelName: BroadcastArgs,
+    backendName: 'cpu',
+    kernelFunc: broadcastArgs
+};
+
+
+const clipByValue = unaryKernelFunc$1(ClipByValue, (xi, attrs) => {
+    const clipAttrs = attrs;
+    if (xi > clipAttrs.clipValueMax) {
+        return clipAttrs.clipValueMax;
+    }
+    return xi < clipAttrs.clipValueMin ? clipAttrs.clipValueMin : xi;
+});
+const clipByValueConfig = {
+    kernelName: ClipByValue,
+    backendName: 'cpu',
+    kernelFunc: clipByValue,
+};
+
+
+const complexAbs = (args) => {
+    const { x } = args.inputs;
+    const cpuBackend = args.backend;
+    const resultValues = new Float32Array(sizeFromShape(x.shape));
+    const complexVals = cpuBackend.data.get(x.dataId);
+    const real = complexVals.complexTensorInfos.real;
+    const imag = complexVals.complexTensorInfos.imag;
+    const realVals = cpuBackend.data.get(real.dataId).values;
+    const imagVals = cpuBackend.data.get(imag.dataId).values;
+    for (let i = 0; i < realVals.length; i++) {
+        const real = realVals[i];
+        const imag = imagVals[i];
+        resultValues[i] = Math.hypot(real, imag);
+    }
+    return cpuBackend.makeOutput(resultValues, x.shape, 'float32');
+};
+const complexAbsConfig = {
+    kernelName: ComplexAbs,
+    backendName: 'cpu',
+    kernelFunc: complexAbs,
+};
+
+
+function imag(args) {
+    const { inputs, backend } = args;
+    const { input } = inputs;
+    const imag = backend.data.get(input.dataId).complexTensorInfos.imag;
+    const imagVal = backend.data.get(imag.dataId).values;
+    
+    
+    
+    return backend.makeTensorInfo(imag.shape, imag.dtype, imagVal);
+}
+const imagConfig = {
+    kernelName: Imag,
+    backendName: 'cpu',
+    kernelFunc: imag
+};
+
+
+function concat(args) {
+    const { inputs, backend, attrs } = args;
+    const { axis } = attrs;
+    const $axis = parseAxisParam(axis, inputs[0].shape)[0];
+    const shapes = inputs.map(t => t.shape);
+    assertParamsConsistent(shapes, $axis);
+    let outShape = computeOutShape$1(inputs.map(t => t.shape), $axis);
+    if (sizeFromShape(outShape) === 0) {
+        return backend.makeTensorInfo(outShape, inputs[0].dtype, []);
+    }
+    
+    const $inputs = inputs.filter(t => sizeFromShape(t.shape) > 0);
+    if ($inputs.length === 1) {
+        return identity$1({ inputs: { x: $inputs[0] }, backend });
+    }
+    if ($inputs[0].dtype === 'complex64') {
+        const reals = $inputs.map((t) => real$1({ inputs: { input: t }, backend }));
+        const imags = $inputs.map((t) => imag({ inputs: { input: t }, backend }));
+        const realConcated = concat({ inputs: reals, backend, attrs: { axis: $axis } });
+        const imagConcated = concat({ inputs: imags, backend, attrs: { axis: $axis } });
+        const result = complex$1({ inputs: { real: realConcated, imag: imagConcated }, backend });
+        reals.forEach(r => backend.disposeIntermediateTensorInfo(r));
+        imags.forEach(i => backend.disposeIntermediateTensorInfo(i));
+        backend.disposeIntermediateTensorInfo(realConcated);
+        backend.disposeIntermediateTensorInfo(imagConcated);
+        return result;
+    }
+    
+    
+    
+    
+    
+    
+    
+    const inputs2D = $inputs.map(t => {
+        const innerSize = sizeFromShape(t.shape.slice($axis));
+        const shape = [-1, innerSize];
+        return reshape({ inputs: { x: t }, backend, attrs: { shape } });
+    });
+    const inputsValShapes = inputs2D.map(t => {
+        return { vals: backend.data.get(t.dataId).values, shape: t.shape };
+    });
+    
+    outShape =
+        computeOutShape$1(inputs2D.map(t => t.shape), 1 );
+    const simplyConcat = inputs2D[0].shape[0] === 1;
+    const outVals = concatImpl$1(inputsValShapes, outShape, inputs[0].dtype, simplyConcat);
+    const finalOutShape = computeOutShape$1($inputs.map(t => t.shape), $axis);
+    const outInfo = backend.makeTensorInfo(finalOutShape, inputs[0].dtype, outVals);
+    inputs2D.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return outInfo;
+}
+const concatConfig = {
+    kernelName: Concat,
+    backendName: 'cpu',
+    kernelFunc: concat
+};
+
+
+function conv2D(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, filter } = inputs;
+    const { strides, pad, dataFormat, dilations, dimRoundingMode } = attrs;
+    assertNotComplex([x, filter], 'conv2d');
+    const $dataFormat = convertConv2DDataFormat(dataFormat);
+    const convInfo = computeConv2DInfo(x.shape, filter.shape, strides, dilations, pad, dimRoundingMode, false , $dataFormat);
+    const filterHeight = convInfo.filterHeight;
+    const filterWidth = convInfo.filterWidth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const padLeft = convInfo.padInfo.left;
+    const padTop = convInfo.padInfo.top;
+    const isChannelsLast = convInfo.dataFormat === 'channelsLast';
+    const y = new TensorBuffer(convInfo.outShape, x.dtype);
+    const xStrides = computeStrides(x.shape);
+    const filterStrides = computeStrides(filter.shape);
+    const xBatchStride = xStrides[0];
+    const xRowStride = isChannelsLast ? xStrides[1] : xStrides[2];
+    const xColStride = isChannelsLast ? xStrides[2] : 1;
+    const xChannelStride = isChannelsLast ? 1 : xStrides[1];
+    const yBatchStride = y.strides[0];
+    const yRowStride = isChannelsLast ? y.strides[1] : y.strides[2];
+    const yColStride = isChannelsLast ? y.strides[2] : 1;
+    const yChannelStride = isChannelsLast ? 1 : y.strides[1];
+    const xVals = backend.data.get(x.dataId).values;
+    const wVals = backend.data.get(filter.dataId).values;
+    const yVals = y.values;
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        const xOffset1 = b * xBatchStride;
+        const yOffset1 = b * yBatchStride;
+        for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+            const yOffset2 = yOffset1 + yR * yRowStride;
+            const xRCorner = yR * convInfo.strideHeight - padTop;
+            for (let wR = 0; wR < filterHeight; ++wR) {
+                const xR = xRCorner + wR * dilationHeight;
+                if (xR < 0 || xR >= convInfo.inHeight) {
+                    continue;
+                }
+                const wOffset1 = wR * filterStrides[0];
+                const xOffset2 = xOffset1 + xR * xRowStride;
+                for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+                    const yOffset3 = yOffset2 + yC * yColStride;
+                    const xCCorner = yC * convInfo.strideWidth - padLeft;
+                    for (let wC = 0; wC < filterWidth; ++wC) {
+                        const xC = xCCorner + wC * dilationWidth;
+                        if (xC < 0 || xC >= convInfo.inWidth) {
+                            continue;
+                        }
+                        const wOffset2 = wOffset1 + wC * filterStrides[1];
+                        const xOffset3 = xOffset2 + xC * xColStride;
+                        let wOffset3 = wOffset2;
+                        for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+                            const xVal = xVals[xOffset3 + d1 * xChannelStride];
+                            for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+                                yVals[yOffset3 + d2 * yChannelStride] +=
+                                    xVal * wVals[wOffset3 + d2];
+                            }
+                            wOffset3 += convInfo.outChannels;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(y.shape, y.dtype, yVals);
+}
+const conv2DConfig = {
+    kernelName: Conv2D,
+    backendName: 'cpu',
+    kernelFunc: conv2D
+};
+
+
+function conv2DBackpropFilter(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, dy } = inputs;
+    const { strides, pad, dataFormat, dimRoundingMode, filterShape } = attrs;
+    assertNotComplex([x, dy], 'conv2dBackpropFilter');
+    const $dataFormat = convertConv2DDataFormat(dataFormat);
+    const convInfo = computeConv2DInfo(x.shape, filterShape, strides, 1 , pad, dimRoundingMode, false , $dataFormat);
+    const { strideHeight, strideWidth, filterHeight, filterWidth } = convInfo;
+    const isChannelsLast = convInfo.dataFormat === 'channelsLast';
+    const dW = new TensorBuffer(convInfo.filterShape, 'float32');
+    const leftPad = convInfo.padInfo.left;
+    const topPad = convInfo.padInfo.top;
+    const xVals = backend.data.get(x.dataId).values;
+    const dyVals = backend.data.get(dy.dataId).values;
+    const xBuf = new TensorBuffer(x.shape, x.dtype, xVals);
+    const dyBuf = new TensorBuffer(dy.shape, dy.dtype, dyVals);
+    for (let wR = 0; wR < filterHeight; ++wR) {
+        const yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));
+        const yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);
+        for (let wC = 0; wC < filterWidth; ++wC) {
+            const yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));
+            const yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);
+            for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+                for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+                    let dotProd = 0;
+                    for (let b = 0; b < convInfo.batchSize; ++b) {
+                        for (let yR = yRMin; yR < yRMax; ++yR) {
+                            const xR = wR + yR * strideHeight - topPad;
+                            for (let yC = yCMin; yC < yCMax; ++yC) {
+                                const xC = wC + yC * strideWidth - leftPad;
+                                if (isChannelsLast) {
+                                    dotProd += xBuf.get(b, xR, xC, d1) *
+                                        dyBuf.get(b, yR, yC, d2);
+                                }
+                                else {
+                                    dotProd += xBuf.get(b, d1, xR, xC) *
+                                        dyBuf.get(b, d2, yR, yC);
+                                }
+                            }
+                        }
+                    }
+                    dW.set(dotProd, wR, wC, d1, d2);
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dW.shape, dW.dtype, dW.values);
+}
+const conv2DBackpropFilterConfig = {
+    kernelName: Conv2DBackpropFilter,
+    backendName: 'cpu',
+    kernelFunc: conv2DBackpropFilter
+};
+
+
+function conv2DBackpropInput(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, filter } = inputs;
+    const { inputShape, strides, pad, dataFormat, dimRoundingMode } = attrs;
+    assertNotComplex([dy, filter], 'conv2dBackpropInput');
+    const filterStrides = computeStrides(filter.shape);
+    const dyStrides = computeStrides(dy.shape);
+    let $dataFormat = convertConv2DDataFormat(dataFormat);
+    const convInfo = computeConv2DInfo(inputShape, filter.shape, strides, 1 , pad, dimRoundingMode, false, $dataFormat);
+    const dx = new TensorBuffer(convInfo.inShape, 'float32');
+    const dxValues = dx.values;
+    const dyValues = backend.data.get(dy.dataId).values;
+    const fltValues = backend.data.get(filter.dataId).values;
+    const [fltS0, fltS1, fltS2] = filterStrides;
+    const { batchSize, filterHeight, filterWidth, inChannels, inHeight, inWidth, outChannels, outHeight, outWidth, strideHeight, strideWidth } = convInfo;
+    $dataFormat = convInfo.dataFormat;
+    const topPad = filterHeight - 1 - convInfo.padInfo.top;
+    const leftPad = filterWidth - 1 - convInfo.padInfo.left;
+    const isChannelsLast = $dataFormat === 'channelsLast';
+    const xBatchStride = dx.strides[0];
+    const xRowStride = isChannelsLast ? dx.strides[1] : dx.strides[2];
+    const xColStride = isChannelsLast ? dx.strides[2] : 1;
+    const xChannelStride = isChannelsLast ? 1 : dx.strides[1];
+    const yBatchStride = dyStrides[0];
+    const yRowStride = isChannelsLast ? dyStrides[1] : dyStrides[2];
+    const yColStride = isChannelsLast ? dyStrides[2] : 1;
+    const yChannelStride = isChannelsLast ? 1 : dyStrides[1];
+    for (let b = 0; b < batchSize; ++b) {
+        for (let d1 = 0; d1 < inChannels; ++d1) {
+            for (let xR = 0; xR < inHeight; ++xR) {
+                const xRCorner = xR - topPad;
+                const xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));
+                const yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);
+                for (let xC = 0; xC < inWidth; ++xC) {
+                    const xCCorner = xC - leftPad;
+                    const xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));
+                    const yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);
+                    let dotProd = 0;
+                    for (let yR = xRMin; yR < yRMax; ++yR) {
+                        const wR = yR * strideHeight - xRCorner;
+                        for (let yC = xCMin; yC < yCMax; ++yC) {
+                            const wC = yC * strideWidth - xCCorner;
+                            const dyOffset = yBatchStride * b + yRowStride * yR + yColStride * yC;
+                            const fltOffset = fltS0 * (filterHeight - 1 - wR) +
+                                fltS1 * (filterWidth - 1 - wC) + fltS2 * d1;
+                            for (let d2 = 0; d2 < outChannels; ++d2) {
+                                const pixel = dyValues[dyOffset + yChannelStride * d2];
+                                const weight = fltValues[fltOffset + d2];
+                                dotProd += pixel * weight;
+                            }
+                        }
+                    }
+                    const dxOffset = xBatchStride * b + xRowStride * xR +
+                        xColStride * xC + xChannelStride * d1;
+                    dxValues[dxOffset] = dotProd;
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const conv2DBackpropInputConfig = {
+    kernelName: Conv2DBackpropInput,
+    backendName: 'cpu',
+    kernelFunc: conv2DBackpropInput
+};
+
+
+function conv3D(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, filter } = inputs;
+    const { strides, pad, dilations } = attrs;
+    assertNotComplex([x, filter], 'conv3d');
+    const convInfo = computeConv3DInfo(x.shape, filter.shape, strides, dilations, pad);
+    const { filterDepth, filterHeight, filterWidth, dilationDepth, dilationHeight, dilationWidth, padInfo } = convInfo;
+    const padFront = padInfo.front;
+    const padLeft = padInfo.left;
+    const padTop = padInfo.top;
+    const y = new TensorBuffer(convInfo.outShape, x.dtype);
+    const xVals = backend.data.get(x.dataId).values;
+    const wVals = backend.data.get(filter.dataId).values;
+    const yVals = y.values;
+    const xStrides = computeStrides(x.shape);
+    const filterStrides = computeStrides(filter.shape);
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        const xOffset1 = b * xStrides[0];
+        const yOffset1 = b * y.strides[0];
+        for (let yF = 0; yF < convInfo.outDepth; ++yF) {
+            const yOffset2 = yOffset1 + yF * y.strides[1];
+            const xFCorner = yF * convInfo.strideDepth - padFront;
+            for (let wF = 0; wF < filterDepth; ++wF) {
+                const xF = xFCorner + wF * dilationDepth;
+                if (xF < 0 || xF >= convInfo.inDepth) {
+                    continue;
+                }
+                const wOffset1 = wF * filterStrides[0];
+                const xOffset2 = xOffset1 + xF * xStrides[1];
+                for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+                    const yOffset3 = yOffset2 + yR * y.strides[2];
+                    const xRCorner = yR * convInfo.strideHeight - padTop;
+                    for (let wR = 0; wR < filterHeight; ++wR) {
+                        const xR = xRCorner + wR * dilationHeight;
+                        if (xR < 0 || xR >= convInfo.inHeight) {
+                            continue;
+                        }
+                        const wOffset2 = wOffset1 + wR * filterStrides[1];
+                        const xOffset3 = xOffset2 + xR * xStrides[2];
+                        for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+                            const yOffset4 = yOffset3 + yC * convInfo.outChannels;
+                            const xCCorner = yC * convInfo.strideWidth - padLeft;
+                            for (let wC = 0; wC < filterWidth; ++wC) {
+                                const xC = xCCorner + wC * dilationWidth;
+                                if (xC < 0 || xC >= convInfo.inWidth) {
+                                    continue;
+                                }
+                                const wOffset3 = wOffset2 + wC * filterStrides[2];
+                                const xOffset4 = xOffset3 + xC * convInfo.inChannels;
+                                let wOffset4 = wOffset3;
+                                for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+                                    const xVal = xVals[xOffset4 + d1];
+                                    for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+                                        yVals[yOffset4 + d2] += xVal * wVals[wOffset4 + d2];
+                                    }
+                                    wOffset4 += convInfo.outChannels;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(y.shape, y.dtype, y.values);
+}
+const conv3DConfig = {
+    kernelName: Conv3D,
+    backendName: 'cpu',
+    kernelFunc: conv3D
+};
+
+
+function conv3DBackpropFilterV2(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, dy } = inputs;
+    const { strides, pad, filterShape } = attrs;
+    assertNotComplex([x, dy], 'conv3dBackpropFilterV2');
+    const xStrides = computeStrides(x.shape);
+    const dyStrides = computeStrides(dy.shape);
+    const convInfo = computeConv3DInfo(x.shape, filterShape, strides, 1 , pad);
+    const strideDepth = convInfo.strideDepth;
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const filterDepth = convInfo.filterDepth;
+    const filterHeight = convInfo.filterHeight;
+    const filterWidth = convInfo.filterWidth;
+    const dw = new TensorBuffer(convInfo.filterShape, 'float32');
+    const dwValues = dw.values;
+    const [dwS0, dwS1, dwS2, dwS3] = dw.strides;
+    const dyValues = backend.data.get(dy.dataId).values;
+    const [dyS0, dyS1, dyS2, dyS3] = dyStrides;
+    const xValues = backend.data.get(x.dataId).values;
+    const [xS0, xS1, xS2, xS3] = xStrides;
+    const frontPad = convInfo.padInfo.front;
+    const leftPad = convInfo.padInfo.left;
+    const topPad = convInfo.padInfo.top;
+    for (let wF = 0; wF < filterDepth; ++wF) {
+        const yFMin = Math.max(0, Math.ceil((frontPad - wF) / strideDepth));
+        const yFMax = Math.min(convInfo.outDepth, (convInfo.inDepth + frontPad - wF) / strideDepth);
+        const wOffset1 = wF * dwS0;
+        for (let wR = 0; wR < filterHeight; ++wR) {
+            const yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));
+            const yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);
+            const wOffset2 = wR * dwS1 + wOffset1;
+            for (let wC = 0; wC < filterWidth; ++wC) {
+                const yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));
+                const yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);
+                const wOffset3 = wC * dwS2 + wOffset2;
+                for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+                    const wOffset4 = d1 * dwS3 + wOffset3;
+                    for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+                        let dotProd = 0;
+                        for (let b = 0; b < convInfo.batchSize; ++b) {
+                            const xOffset1 = b * xS0;
+                            const yOffset1 = b * dyS0;
+                            for (let yF = yFMin; yF < yFMax; ++yF) {
+                                const xF = wF + yF * strideDepth - frontPad;
+                                const xOffset2 = xF * xS1 + xOffset1;
+                                const yOffset2 = yF * dyS1 + yOffset1;
+                                for (let yR = yRMin; yR < yRMax; ++yR) {
+                                    const xR = wR + yR * strideHeight - topPad;
+                                    const xOffset3 = xR * xS2 + xOffset2;
+                                    const yOffset3 = yR * dyS2 + yOffset2;
+                                    for (let yC = yCMin; yC < yCMax; ++yC) {
+                                        const xC = wC + yC * strideWidth - leftPad;
+                                        const xOffset4 = xC * xS3 + xOffset3;
+                                        const yOffset4 = yC * dyS3 + yOffset3;
+                                        dotProd += xValues[xOffset4 + d1] * dyValues[yOffset4 + d2];
+                                    }
+                                }
+                            }
+                        }
+                        dwValues[wOffset4 + d2] = dotProd;
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dw.shape, dw.dtype, dw.values);
+}
+const conv3DBackpropFilterV2Config = {
+    kernelName: Conv3DBackpropFilterV2,
+    backendName: 'cpu',
+    kernelFunc: conv3DBackpropFilterV2
+};
+
+
+function conv3DBackpropInputV2(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, filter } = inputs;
+    const { pad, strides, inputShape } = attrs;
+    assertNotComplex([dy], 'conv3dBackpropInputV2');
+    const dyStrides = computeStrides(dy.shape);
+    const filterStrides = computeStrides(filter.shape);
+    const convInfo = computeConv3DInfo(inputShape, filter.shape, strides, 1 , pad);
+    const dx = new TensorBuffer(convInfo.inShape, 'float32');
+    const dxValues = dx.values;
+    const [dxS0, dxS1, dxS2, dxS3] = dx.strides;
+    const dyValues = backend.data.get(dy.dataId).values;
+    const [dyS0, dyS1, dyS2, dyS3] = dyStrides;
+    const fltValues = backend.data.get(filter.dataId).values;
+    const [fltS0, fltS1, fltS2, fltS3] = filterStrides;
+    const { batchSize, filterDepth, filterHeight, filterWidth, inChannels, inDepth, inHeight, inWidth, outChannels, outDepth, outHeight, outWidth, strideDepth, strideHeight, strideWidth } = convInfo;
+    const frontPad = filterDepth - 1 - convInfo.padInfo.front;
+    const topPad = filterHeight - 1 - convInfo.padInfo.top;
+    const leftPad = filterWidth - 1 - convInfo.padInfo.left;
+    for (let b = 0; b < batchSize; ++b) {
+        for (let d1 = 0; d1 < inChannels; ++d1) {
+            
+            for (let xF = 0; xF < inDepth; ++xF) {
+                const xFCorner = xF - frontPad;
+                const xFMin = Math.max(0, Math.ceil(xFCorner / strideDepth));
+                const yFMax = Math.min(outDepth, (filterDepth + xFCorner) / strideDepth);
+                
+                for (let xR = 0; xR < inHeight; ++xR) {
+                    const xRCorner = xR - topPad;
+                    const xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));
+                    const yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);
+                    
+                    for (let xC = 0; xC < inWidth; ++xC) {
+                        const xCCorner = xC - leftPad;
+                        const xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));
+                        const yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);
+                        let dotProd = 0;
+                        for (let yF = xFMin; yF < yFMax; ++yF) {
+                            const wF = yF * strideDepth - xFCorner;
+                            for (let yR = xRMin; yR < yRMax; ++yR) {
+                                const wR = yR * strideHeight - xRCorner;
+                                for (let yC = xCMin; yC < yCMax; ++yC) {
+                                    const wC = yC * strideWidth - xCCorner;
+                                    const dyOffset = dyS0 * b + dyS1 * yF + dyS2 * yR + dyS3 * yC;
+                                    const fltOffset = fltS0 * (filterDepth - 1 - wF) +
+                                        fltS1 * (filterHeight - 1 - wR) +
+                                        fltS2 * (filterWidth - 1 - wC) + fltS3 * d1;
+                                    for (let d2 = 0; d2 < outChannels; ++d2) {
+                                        const pixel = dyValues[dyOffset + d2];
+                                        const weight = fltValues[fltOffset + d2];
+                                        dotProd += pixel * weight;
+                                    }
+                                }
+                            }
+                        }
+                        dxValues[dxS0 * b + dxS1 * xF + dxS2 * xR + dxS3 * xC + d1] =
+                            dotProd;
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const conv3DBackpropInputV2Config = {
+    kernelName: Conv3DBackpropInputV2,
+    backendName: 'cpu',
+    kernelFunc: conv3DBackpropInputV2
+};
+
+
+const cos = unaryKernelFunc$1(Cos, (xi) => Math.cos(xi));
+const cosConfig = {
+    kernelName: Cos,
+    backendName: 'cpu',
+    kernelFunc: cos,
+};
+
+
+const cosh = unaryKernelFunc$1(Cosh, (xi) => Math.cosh(xi));
+const coshConfig = {
+    kernelName: Cosh,
+    backendName: 'cpu',
+    kernelFunc: cosh,
+};
+
+
+function cropAndResize(args) {
+    const { inputs, backend, attrs } = args;
+    const { image, boxes, boxInd } = inputs;
+    const { cropSize, method, extrapolationValue } = attrs;
+    const [batch, imageHeight, imageWidth, numChannels] = image.shape;
+    const numBoxes = boxes.shape[0];
+    const [cropHeight, cropWidth] = cropSize;
+    const output = buffer([numBoxes, cropHeight, cropWidth, numChannels], 'float32');
+    const boxVals = backend.data.get(boxes.dataId).values;
+    const boxIndVals = backend.data.get(boxInd.dataId).values;
+    const imageVals = backend.data.get(image.dataId).values;
+    const inStride = computeStrides(image.shape); 
+    const outStride = computeStrides(output.shape); 
+    
+    
+    
+    for (let b = 0; b < numBoxes; b++) {
+        const startInd = b * 4;
+        const y1 = boxVals[startInd];
+        const x1 = boxVals[startInd + 1];
+        const y2 = boxVals[startInd + 2];
+        const x2 = boxVals[startInd + 3];
+        const bInd = boxIndVals[b];
+        if (bInd >= batch) {
+            continue;
+        }
+        const heightScale = (cropHeight > 1) ? (y2 - y1) * (imageHeight - 1) / (cropHeight - 1) : 0;
+        const widthScale = (cropWidth > 1) ? (x2 - x1) * (imageWidth - 1) / (cropWidth - 1) : 0;
+        for (let y = 0; y < cropHeight; y++) {
+            const yInd = (cropHeight > 1) ?
+                y1 * (imageHeight - 1) + y * (heightScale) :
+                0.5 * (y1 + y2) * (imageHeight - 1);
+            if (yInd < 0 || yInd > imageHeight - 1) {
+                for (let x = 0; x < cropWidth; x++) {
+                    for (let c = 0; c < numChannels; c++) {
+                        const ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+                        output.values[ind] = extrapolationValue;
+                    }
+                }
+                continue;
+            }
+            if (method === 'bilinear') {
+                const topInd = Math.floor(yInd);
+                const bottomInd = Math.ceil(yInd);
+                const yLerp = yInd - topInd;
+                for (let x = 0; x < cropWidth; x++) {
+                    const xInd = (cropWidth > 1) ?
+                        x1 * (imageWidth - 1) + x * widthScale :
+                        0.5 * (x1 + x2) * (imageWidth - 1);
+                    if (xInd < 0 || xInd > imageWidth - 1) {
+                        for (let c = 0; c < numChannels; c++) {
+                            const ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+                            output.values[ind] = extrapolationValue;
+                        }
+                        continue;
+                    }
+                    const leftInd = Math.floor(xInd);
+                    const rightInd = Math.ceil(xInd);
+                    const xLerp = xInd - leftInd;
+                    for (let c = 0; c < numChannels; c++) {
+                        let ind = c + leftInd * inStride[2] + topInd * inStride[1] +
+                            bInd * inStride[0];
+                        const topLeft = imageVals[ind];
+                        ind = c + rightInd * inStride[2] + topInd * inStride[1] +
+                            bInd * inStride[0];
+                        const topRight = imageVals[ind];
+                        ind = c + leftInd * inStride[2] + bottomInd * inStride[1] +
+                            bInd * inStride[0];
+                        const bottomLeft = imageVals[ind];
+                        ind = c + rightInd * inStride[2] + bottomInd * inStride[1] +
+                            bInd * inStride[0];
+                        const bottomRight = imageVals[ind];
+                        const top = topLeft + (topRight - topLeft) * xLerp;
+                        const bottom = bottomLeft + (bottomRight - bottomLeft) * xLerp;
+                        ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+                        output.values[ind] = top + ((bottom - top) * yLerp);
+                    }
+                }
+            }
+            else { 
+                for (let x = 0; x < cropWidth; ++x) {
+                    const xInd = (cropWidth > 1) ?
+                        x1 * (imageWidth - 1) + x * widthScale :
+                        0.5 * (x1 + x2) * (imageWidth - 1);
+                    if (xInd < 0 || xInd > imageWidth - 1) {
+                        for (let c = 0; c < numChannels; c++) {
+                            const ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+                            output.values[ind] = extrapolationValue;
+                        }
+                        continue;
+                    }
+                    const closestX = Math.round(xInd);
+                    const closestY = Math.round(yInd);
+                    for (let c = 0; c < numChannels; c++) {
+                        const inInd = c + closestX * inStride[2] + closestY * inStride[1] +
+                            bInd * inStride[0];
+                        const outInd = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+                        output.values[outInd] = imageVals[inInd];
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(output.shape, output.dtype, output.values);
+}
+const cropAndResizeConfig = {
+    kernelName: CropAndResize,
+    backendName: 'cpu',
+    kernelFunc: cropAndResize
+};
+
+
+function cumprod(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, exclusive, reverse } = attrs;
+    assertNotComplex(x, 'cumprod');
+    const permutation = getAxesPermutation([axis], x.shape.length);
+    let $x = x;
+    if (permutation != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutation } });
+    }
+    const permutedAxis = getInnerMostAxes(1, x.shape.length)[0];
+    if (permutedAxis !== $x.shape.length - 1) {
+        throw new Error(`backend.cumprod in CPU expects an inner-most ` +
+            `axis=${$x.shape.length - 1} but got axis=${permutedAxis}`);
+    }
+    const resultDtype = upcastType($x.dtype, 'int32');
+    const vals = makeOnesTypedArray(sizeFromShape($x.shape), resultDtype);
+    const aVals = backend.data.get($x.dataId).values;
+    const finalDim = $x.shape[$x.shape.length - 1];
+    const indexAdjuster = reverse ?
+        (i, j) => i + finalDim - j - 1 :
+        (i, j) => i + j;
+    for (let i = 0; i < aVals.length; i += finalDim) {
+        for (let j = 0; j < finalDim; j++) {
+            const idx = indexAdjuster(i, j);
+            if (j === 0) {
+                vals[idx] = exclusive ? 1 : aVals[idx];
+            }
+            else {
+                const prevIdx = indexAdjuster(i, j - 1);
+                vals[idx] = exclusive ? aVals[prevIdx] * vals[prevIdx] :
+                    aVals[idx] * vals[prevIdx];
+            }
+        }
+    }
+    const result = backend.makeTensorInfo($x.shape, resultDtype, vals);
+    if (permutation != null) {
+        const reversePermutation = getUndoAxesPermutation(permutation);
+        const reverseTransposedResult = transpose$1({ inputs: { x: result }, backend, attrs: { perm: reversePermutation } });
+        backend.disposeIntermediateTensorInfo(result);
+        backend.disposeIntermediateTensorInfo($x);
+        return reverseTransposedResult;
+    }
+    return result;
+}
+const cumprodConfig = {
+    kernelName: Cumprod,
+    backendName: 'cpu',
+    kernelFunc: cumprod
+};
+
+
+function cumsum(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, exclusive, reverse } = attrs;
+    assertNotComplex(x, 'cumsum');
+    const permutation = getAxesPermutation([axis], x.shape.length);
+    let $x = x;
+    if (permutation != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutation } });
+    }
+    const permutedAxis = getInnerMostAxes(1, x.shape.length)[0];
+    if (permutedAxis !== $x.shape.length - 1) {
+        throw new Error(`backend.cumsum in CPU expects an inner-most ` +
+            `axis=${$x.shape.length - 1} but got axis=${permutedAxis}`);
+    }
+    const resultDtype = upcastType($x.dtype, 'int32');
+    const vals = makeZerosTypedArray(sizeFromShape($x.shape), resultDtype);
+    const aVals = backend.data.get($x.dataId).values;
+    const finalDim = $x.shape[$x.shape.length - 1];
+    const indexAdjuster = reverse ?
+        (i, j) => i + finalDim - j - 1 :
+        (i, j) => i + j;
+    for (let i = 0; i < aVals.length; i += finalDim) {
+        for (let j = 0; j < finalDim; j++) {
+            const idx = indexAdjuster(i, j);
+            if (j === 0) {
+                vals[idx] = exclusive ? 0 : aVals[idx];
+            }
+            else {
+                const prevIdx = indexAdjuster(i, j - 1);
+                vals[idx] = exclusive ? aVals[prevIdx] + vals[prevIdx] :
+                    aVals[idx] + vals[prevIdx];
+            }
+        }
+    }
+    const result = backend.makeTensorInfo($x.shape, resultDtype, vals);
+    if (permutation != null) {
+        const reversePermutation = getUndoAxesPermutation(permutation);
+        const reverseTransposedResult = transpose$1({ inputs: { x: result }, backend, attrs: { perm: reversePermutation } });
+        backend.disposeIntermediateTensorInfo(result);
+        backend.disposeIntermediateTensorInfo($x);
+        return reverseTransposedResult;
+    }
+    return result;
+}
+const cumsumConfig = {
+    kernelName: Cumsum,
+    backendName: 'cpu',
+    kernelFunc: cumsum
+};
+
+
+function denseBincount(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, weights } = inputs;
+    const { size, binaryOutput } = attrs;
+    if (x.shape.length === 1) {
+        const xVals = backend.data.get(x.dataId).values;
+        const weightsVals = backend.data.get(weights.dataId).values;
+        const outVals = bincountImpl(xVals, weightsVals, weights.dtype, weights.shape, size);
+        return backend.makeTensorInfo([size], weights.dtype, outVals);
+    }
+    else if (x.shape.length === 2) {
+        const xBuf = backend.bufferSync(x);
+        const weightsBuf = backend.bufferSync(weights);
+        const outBuf = bincountReduceImpl(xBuf, weightsBuf, size, binaryOutput);
+        return backend.makeTensorInfo(outBuf.shape, weights.dtype, outBuf.values);
+    }
+    throw new Error(`Error in denseBincount: input must be at most rank 2, but got rank` +
+        `${x.shape.length}.`);
+}
+const denseBincountConfig = {
+    kernelName: DenseBincount,
+    backendName: 'cpu',
+    kernelFunc: denseBincount
+};
+
+
+function depthToSpace(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { blockSize, dataFormat } = attrs;
+    assert$1(dataFormat === 'NHWC', () => `Only NHWC dataFormat supported on CPU for depthToSpace. Got ${dataFormat}`);
+    const batchSize = x.shape[0];
+    const inputHeight = x.shape[1];
+    const inputWidth = x.shape[2];
+    const inputDepth = x.shape[3];
+    const outputHeight = inputHeight * blockSize;
+    const outputWidth = inputWidth * blockSize;
+    const outputDepth = inputDepth / (blockSize * blockSize);
+    const xValues = backend.data.get(x.dataId).values;
+    const result = new Float32Array(batchSize * outputHeight * outputWidth * outputDepth);
+    let outputIdx = 0;
+    for (let b = 0; b < batchSize; ++b) {
+        for (let h = 0; h < outputHeight; ++h) {
+            const inH = Math.floor(h / blockSize);
+            const offsetH = (h % blockSize);
+            for (let w = 0; w < outputWidth; ++w) {
+                const inW = Math.floor(w / blockSize);
+                const offsetW = (w % blockSize);
+                const offsetD = (offsetH * blockSize + offsetW) * outputDepth;
+                for (let d = 0; d < outputDepth; ++d) {
+                    const inD = d + offsetD;
+                    const inputIdx = inD + inputDepth * (inW + inputWidth * (inH + inputHeight * b));
+                    result[outputIdx++] = xValues[inputIdx];
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo([batchSize, outputHeight, outputWidth, outputDepth], x.dtype, result);
+}
+const depthToSpaceConfig = {
+    kernelName: DepthToSpace,
+    backendName: 'cpu',
+    kernelFunc: depthToSpace
+};
+
+
+function depthwiseConv2dNative(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, filter } = inputs;
+    const { strides, pad, dilations, dimRoundingMode } = attrs;
+    assertNotComplex([x, filter], 'depthwiseConv2DNative');
+    const xStrides = computeStrides(x.shape);
+    const filterStrides = computeStrides(filter.shape);
+    let $dilations = dilations;
+    if ($dilations == null) {
+        $dilations = [1, 1];
+    }
+    assert$1(eitherStridesOrDilationsAreOne(strides, $dilations), () => 'Error in depthwiseConv2d: Either strides or dilations must be ' +
+        `1. Got strides ${strides} and dilations '${$dilations}'`);
+    const convInfo = computeConv2DInfo(x.shape, filter.shape, strides, $dilations, pad, dimRoundingMode, true );
+    const { filterHeight, filterWidth, dilationHeight, dilationWidth, padInfo } = convInfo;
+    const padLeft = padInfo.left;
+    const padTop = padInfo.top;
+    const chMul = convInfo.outChannels / convInfo.inChannels;
+    const y = new TensorBuffer(convInfo.outShape, x.dtype);
+    const xVals = backend.data.get(x.dataId).values;
+    const wVals = backend.data.get(filter.dataId).values;
+    const yVals = y.values;
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        const xOffset1 = b * xStrides[0];
+        const yOffset1 = b * y.strides[0];
+        for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+            const yOffset2 = yOffset1 + yR * y.strides[1];
+            const xRCorner = yR * convInfo.strideHeight - padTop;
+            for (let wR = 0; wR < filterHeight; ++wR) {
+                const xR = xRCorner + wR * dilationHeight;
+                if (xR < 0 || xR >= convInfo.inHeight) {
+                    continue;
+                }
+                const wOffset1 = wR * filterStrides[0];
+                const xOffset2 = xOffset1 + xR * xStrides[1];
+                for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+                    const yOffset3 = yOffset2 + yC * y.strides[2];
+                    const xCCorner = yC * convInfo.strideWidth - padLeft;
+                    for (let wC = 0; wC < filterWidth; ++wC) {
+                        const xC = xCCorner + wC * dilationWidth;
+                        if (xC < 0 || xC >= convInfo.inWidth) {
+                            continue;
+                        }
+                        const wOffset2 = wOffset1 + wC * filterStrides[1];
+                        const xOffset3 = xOffset2 + xC * convInfo.inChannels;
+                        let yOffset4 = yOffset3;
+                        let wOffset3 = wOffset2;
+                        for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+                            const xVal = xVals[xOffset3 + d1];
+                            for (let q = 0; q < chMul; ++q) {
+                                yVals[yOffset4 + q] += xVal * wVals[wOffset3 + q];
+                            }
+                            yOffset4 += chMul;
+                            wOffset3 += chMul;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(y.shape, y.dtype, y.values);
+}
+const depthwiseConv2dNativeConfig = {
+    kernelName: DepthwiseConv2dNative,
+    backendName: 'cpu',
+    kernelFunc: depthwiseConv2dNative
+};
+
+
+function depthwiseConv2dNativeBackpropFilter(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, dy } = inputs;
+    const { strides, dilations, pad, dimRoundingMode, filterShape } = attrs;
+    assertNotComplex([x, dy], 'depthwiseConv2dNativeBackpropFilter');
+    const convInfo = computeConv2DInfo(x.shape, filterShape, strides, dilations, pad, dimRoundingMode, true );
+    const { strideHeight, strideWidth, filterHeight, filterWidth } = convInfo;
+    const dW = new TensorBuffer(convInfo.filterShape, 'float32');
+    const leftPad = convInfo.padInfo.left;
+    const topPad = convInfo.padInfo.top;
+    const chMul = convInfo.outChannels / convInfo.inChannels;
+    const xVals = backend.data.get(x.dataId).values;
+    const xBuf = new TensorBuffer(x.shape, x.dtype, xVals);
+    const dyVals = backend.data.get(dy.dataId).values;
+    const dyBuf = new TensorBuffer(dy.shape, dy.dtype, dyVals);
+    for (let wR = 0; wR < filterHeight; ++wR) {
+        const yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));
+        const yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);
+        for (let wC = 0; wC < filterWidth; ++wC) {
+            const yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));
+            const yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);
+            for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+                const d1 = Math.trunc(d2 / chMul);
+                const dm = d2 % chMul;
+                let dotProd = 0;
+                for (let b = 0; b < convInfo.batchSize; ++b) {
+                    for (let yR = yRMin; yR < yRMax; ++yR) {
+                        const xR = wR + yR * strideHeight - topPad;
+                        for (let yC = yCMin; yC < yCMax; ++yC) {
+                            const xC = wC + yC * strideWidth - leftPad;
+                            dotProd += xBuf.get(b, xR, xC, d1) *
+                                dyBuf.get(b, yR, yC, d2);
+                        }
+                    }
+                }
+                dW.set(dotProd, wR, wC, d1, dm);
+            }
+        }
+    }
+    return backend.makeTensorInfo(dW.shape, dW.dtype, dW.values);
+}
+const depthwiseConv2dNativeBackpropFilterConfig = {
+    kernelName: DepthwiseConv2dNativeBackpropFilter,
+    backendName: 'cpu',
+    kernelFunc: depthwiseConv2dNativeBackpropFilter
+};
+
+
+function depthwiseConv2dNativeBackpropInput(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, filter } = inputs;
+    const { strides, dilations, pad, dimRoundingMode, inputShape } = attrs;
+    assertNotComplex([dy, filter], 'depthwiseConv2DNativeBackpropInput');
+    const dyStrides = computeStrides(dy.shape);
+    const filterStrides = computeStrides(filter.shape);
+    const convInfo = computeConv2DInfo(inputShape, filter.shape, strides, dilations, pad, dimRoundingMode, true );
+    const dx = new TensorBuffer(convInfo.inShape, 'float32');
+    const dxValues = dx.values;
+    const [dxS0, dxS1, dxS2] = dx.strides;
+    const dyValues = backend.data.get(dy.dataId).values;
+    const [dyS0, dyS1, dyS2] = dyStrides;
+    const fltValues = backend.data.get(filter.dataId).values;
+    const [fltS0, fltS1, fltS2] = filterStrides;
+    const { batchSize, filterHeight, filterWidth, inChannels, inHeight, inWidth, outChannels, outHeight, outWidth, strideHeight, strideWidth } = convInfo;
+    const topPad = filterHeight - 1 - convInfo.padInfo.top;
+    const leftPad = filterWidth - 1 - convInfo.padInfo.left;
+    const chMul = outChannels / inChannels;
+    for (let b = 0; b < batchSize; ++b) {
+        for (let d1 = 0; d1 < inChannels; ++d1) {
+            for (let xR = 0; xR < inHeight; ++xR) {
+                const xRCorner = xR - topPad;
+                const xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));
+                const yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);
+                for (let xC = 0; xC < inWidth; ++xC) {
+                    const xCCorner = xC - leftPad;
+                    const xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));
+                    const yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);
+                    let dotProd = 0;
+                    for (let yR = xRMin; yR < yRMax; ++yR) {
+                        const wR = yR * strideHeight - xRCorner;
+                        for (let yC = xCMin; yC < yCMax; ++yC) {
+                            const wC = yC * strideWidth - xCCorner;
+                            const dyOffset = dyS0 * b + dyS1 * yR + dyS2 * yC;
+                            const fltOffset = fltS0 * (filterHeight - 1 - wR) +
+                                fltS1 * (filterWidth - 1 - wC) + fltS2 * d1;
+                            for (let dm = 0; dm < chMul; ++dm) {
+                                const d2 = d1 * chMul + dm;
+                                const pixel = dyValues[dyOffset + d2];
+                                const weight = fltValues[fltOffset + dm];
+                                dotProd += pixel * weight;
+                            }
+                        }
+                    }
+                    dxValues[dxS0 * b + dxS1 * xR + dxS2 * xC + d1] = dotProd;
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const depthwiseConv2dNativeBackpropInputConfig = {
+    kernelName: DepthwiseConv2dNativeBackpropInput,
+    backendName: 'cpu',
+    kernelFunc: depthwiseConv2dNativeBackpropInput
+};
+
+
+function diag(args) {
+    const { inputs, backend } = args;
+    const { x } = inputs;
+    const xSize = sizeFromShape(x.shape);
+    const xVals = backend.data.get(x.dataId).values;
+    const outBuf = buffer([xSize, xSize], x.dtype);
+    const vals = outBuf.values;
+    for (let i = 0; i < xVals.length; i++) {
+        vals[i * xSize + i] = xVals[i];
+    }
+    const outShape = [...x.shape, ...x.shape];
+    return backend.makeTensorInfo(outShape, outBuf.dtype, outBuf.values);
+}
+const diagConfig = {
+    kernelName: Diag,
+    backendName: 'cpu',
+    kernelFunc: diag
+};
+
+
+const dilation2DConfig = {
+    kernelName: Dilation2D,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, backend, attrs }) => {
+        const { x, filter } = inputs;
+        const { strides, pad, dilations } = attrs;
+        const cpuBackend = backend;
+        const xVals = cpuBackend.data.get(x.dataId).values;
+        const xRank = x.shape.length;
+        const filterVals = cpuBackend.data.get(filter.dataId).values;
+        const filterRank = filter.shape.length;
+        const { batchSize, inHeight, inWidth, inChannels, outHeight, outWidth, padInfo, strideHeight, strideWidth, filterHeight, filterWidth, dilationHeight, dilationWidth, outShape } = computeDilation2DInfo(x.shape, filter.shape, strides, pad, 'NHWC' , dilations);
+        const outSize = sizeFromShape(outShape);
+        const outRank = outShape.length;
+        const outputVals = getArrayFromDType(x.dtype, outSize);
+        
+        
+        
+        
+        for (let b = 0; b < batchSize; ++b) {
+            for (let hOut = 0; hOut < outHeight; ++hOut) {
+                const hBeg = hOut * strideHeight - padInfo.top;
+                for (let wOut = 0; wOut < outWidth; ++wOut) {
+                    const wBeg = wOut * strideWidth - padInfo.left;
+                    for (let d = 0; d < inChannels; ++d) {
+                        let curVal = Number.MIN_SAFE_INTEGER;
+                        for (let h = 0; h < filterHeight; ++h) {
+                            const hIn = hBeg + h * dilationHeight;
+                            if (hIn >= 0 && hIn < inHeight) {
+                                for (let w = 0; w < filterWidth; ++w) {
+                                    const wIn = wBeg + w * dilationWidth;
+                                    if (wIn >= 0 && wIn < inWidth) {
+                                        const xIndex = locToIndex([b, hIn, wIn, d], xRank, computeStrides(x.shape));
+                                        const filterIndex = locToIndex([h, w, d], filterRank, computeStrides(filter.shape));
+                                        const val = xVals[xIndex] + filterVals[filterIndex];
+                                        if (val > curVal) {
+                                            curVal = val;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        const outputIndex = locToIndex([b, hOut, wOut, d], outRank, computeStrides(outShape));
+                        outputVals[outputIndex] = curVal;
+                    }
+                }
+            }
+        }
+        const dataId = cpuBackend.write(toTypedArray(outputVals, x.dtype), outShape, x.dtype);
+        return { dataId, shape: outShape, dtype: x.dtype };
+    }
+};
+
+
+const dilation2DBackpropFilterConfig = {
+    kernelName: Dilation2DBackpropFilter,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, backend, attrs }) => {
+        const { x, filter, dy } = inputs;
+        const { strides, pad, dilations } = attrs;
+        const cpuBackend = backend;
+        const $x = toNestedArray(x.shape, cpuBackend.data.get(x.dataId).values);
+        const $filter = toNestedArray(filter.shape, cpuBackend.data.get(filter.dataId).values);
+        const { batchSize, inHeight, inWidth, inChannels, outHeight, outWidth, padInfo, strideHeight, strideWidth, filterHeight, filterWidth, dilationHeight, dilationWidth, outShape } = computeDilation2DInfo(x.shape, filter.shape, strides, pad, 'NHWC' , dilations);
+        assert$1(dy.rank === outShape.length, () => `Error in ${Dilation2DBackpropFilter}, dy ` +
+            `must have the same rank as output ${outShape.length}, but got ` +
+            `${dy.rank}`);
+        const $dy = toNestedArray(outShape, cpuBackend.data.get(dy.dataId).values);
+        
+        
+        const gradients = makeZerosNestedTypedArray(filter.shape, filter.dtype);
+        
+        
+        
+        
+        
+        for (let b = 0; b < batchSize; ++b) {
+            for (let hOut = 0; hOut < outHeight; ++hOut) {
+                const hBeg = hOut * strideHeight - padInfo.top;
+                for (let wOut = 0; wOut < outWidth; ++wOut) {
+                    const wBeg = wOut * strideWidth - padInfo.left;
+                    for (let d = 0; d < inChannels; ++d) {
+                        let curVal = Number.MIN_SAFE_INTEGER;
+                        let hMax = 0;
+                        let wMax = 0;
+                        for (let h = 0; h < filterHeight; ++h) {
+                            const hIn = hBeg + h * dilationHeight;
+                            if (hIn >= 0 && hIn < inHeight) {
+                                for (let w = 0; w < filterWidth; ++w) {
+                                    const wIn = wBeg + w * dilationWidth;
+                                    if (wIn >= 0 && wIn < inWidth) {
+                                        const val = $x[b][hIn][wIn][d] + $filter[h][w][d];
+                                        if (val > curVal) {
+                                            curVal = val;
+                                            hMax = h;
+                                            wMax = w;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        gradients[hMax][wMax][d] += $dy[b][hOut][wOut][d];
+                    }
+                }
+            }
+        }
+        const dataId = cpuBackend.write(toTypedArray(gradients, x.dtype), filter.shape, filter.dtype);
+        return { dataId, shape: filter.shape, dtype: filter.dtype };
+    }
+};
+
+
+const dilation2DBackpropInputConfig = {
+    kernelName: Dilation2DBackpropInput,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, backend, attrs }) => {
+        const { x, filter, dy } = inputs;
+        const { strides, pad, dilations } = attrs;
+        const cpuBackend = backend;
+        const $x = toNestedArray(x.shape, cpuBackend.data.get(x.dataId).values);
+        const $filter = toNestedArray(filter.shape, cpuBackend.data.get(filter.dataId).values);
+        const { batchSize, inHeight, inWidth, inChannels, outHeight, outWidth, padInfo, strideHeight, strideWidth, filterHeight, filterWidth, dilationHeight, dilationWidth, outShape } = computeDilation2DInfo(x.shape, filter.shape, strides, pad, 'NHWC' , dilations);
+        assert$1(dy.rank === outShape.length, () => `Error in ${Dilation2DBackpropInput}, dy ` +
+            `must have the same rank as output ${outShape.length}, but got ` +
+            `${dy.rank}`);
+        const $dy = toNestedArray(outShape, cpuBackend.data.get(dy.dataId).values);
+        
+        
+        const gradients = makeZerosNestedTypedArray(x.shape, x.dtype);
+        
+        
+        
+        
+        
+        for (let b = 0; b < batchSize; ++b) {
+            for (let hOut = 0; hOut < outHeight; ++hOut) {
+                const hBeg = hOut * strideHeight - padInfo.top;
+                for (let wOut = 0; wOut < outWidth; ++wOut) {
+                    const wBeg = wOut * strideWidth - padInfo.left;
+                    for (let d = 0; d < inChannels; ++d) {
+                        let curVal = Number.MIN_SAFE_INTEGER;
+                        let hInMax = (hBeg < 0) ? 0 : hBeg;
+                        let wInMax = (wBeg < 0) ? 0 : wBeg;
+                        for (let h = 0; h < filterHeight; ++h) {
+                            const hIn = hBeg + h * dilationHeight;
+                            if (hIn >= 0 && hIn < inHeight) {
+                                for (let w = 0; w < filterWidth; ++w) {
+                                    const wIn = wBeg + w * dilationWidth;
+                                    if (wIn >= 0 && wIn < inWidth) {
+                                        const val = $x[b][hIn][wIn][d] + $filter[h][w][d];
+                                        if (val > curVal) {
+                                            curVal = val;
+                                            hInMax = hIn;
+                                            wInMax = wIn;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        gradients[b][hInMax][wInMax][d] += $dy[b][hOut][wOut][d];
+                    }
+                }
+            }
+        }
+        const dataId = cpuBackend.write(toTypedArray(gradients, x.dtype), x.shape, x.dtype);
+        return { dataId, shape: x.shape, dtype: x.dtype };
+    }
+};
+
+
+function draw(args) {
+    const { inputs, backend, attrs } = args;
+    const { image } = inputs;
+    const { canvas, options } = attrs;
+    const { contextOptions, imageOptions } = options || {};
+    const alpha = (imageOptions === null || imageOptions === void 0 ? void 0 : imageOptions.alpha) || 1;
+    const contextType = (contextOptions === null || contextOptions === void 0 ? void 0 : contextOptions.contextType) || '2d';
+    if (contextType !== '2d') {
+        throw new Error(`Context type ${contextOptions.contextType} is not supported by the CPU backend.`);
+    }
+    const ctx = canvas.getContext(contextType, (contextOptions === null || contextOptions === void 0 ? void 0 : contextOptions.contextAttributes) || {});
+    if (ctx == null) {
+        throw new Error(`Could not get the context with ${contextType} type.`);
+    }
+    const [height, width] = image.shape.slice(0, 2);
+    const depth = image.shape.length === 2 ? 1 : image.shape[2];
+    const data = backend.data.get(image.dataId).values;
+    const multiplier = image.dtype === 'float32' ? 255 : 1;
+    const bytes = new Uint8ClampedArray(width * height * 4);
+    for (let i = 0; i < height * width; ++i) {
+        const rgba = [0, 0, 0, 255 * alpha];
+        for (let d = 0; d < depth; d++) {
+            const value = data[i * depth + d];
+            if (image.dtype === 'float32') {
+                if (value < 0 || value > 1) {
+                    throw new Error(`Tensor values for a float32 Tensor must be in the ` +
+                        `range [0 - 1] but encountered ${value}.`);
+                }
+            }
+            else if (image.dtype === 'int32') {
+                if (value < 0 || value > 255) {
+                    throw new Error(`Tensor values for a int32 Tensor must be in the ` +
+                        `range [0 - 255] but encountered ${value}.`);
+                }
+            }
+            if (depth === 1) {
+                rgba[0] = value * multiplier;
+                rgba[1] = value * multiplier;
+                rgba[2] = value * multiplier;
+            }
+            else {
+                rgba[d] = value * multiplier;
+            }
+        }
+        const j = i * 4;
+        bytes[j + 0] = Math.round(rgba[0]);
+        bytes[j + 1] = Math.round(rgba[1]);
+        bytes[j + 2] = Math.round(rgba[2]);
+        bytes[j + 3] = Math.round(rgba[3]);
+    }
+    canvas.width = width;
+    canvas.height = height;
+    const imageData = new ImageData(bytes, width, height);
+    ctx.putImageData(imageData, 0, 0);
+    return image;
+}
+const drawConfig = {
+    kernelName: Draw,
+    backendName: 'cpu',
+    kernelFunc: draw
+};
+
+
+function sum(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, keepDims } = attrs;
+    assertNotComplex(x, 'sum');
+    let $x;
+    if (x.dtype === 'bool') {
+        $x = cast$2({ inputs: { x }, backend, attrs: { dtype: 'int32' } });
+    }
+    else {
+        $x = identity$1({ inputs: { x }, backend });
+    }
+    const xRank = $x.shape.length;
+    const axes = parseAxisParam(axis, $x.shape);
+    const permutation = getAxesPermutation(axes, xRank);
+    let reductionAxes = axes;
+    let permutedX = $x;
+    if (permutation != null) {
+        permutedX =
+            transpose$1({ inputs: { x: $x }, backend, attrs: { perm: permutation } });
+        reductionAxes = getInnerMostAxes(reductionAxes.length, xRank);
+    }
+    assertAxesAreInnerMostDims('sum', reductionAxes, permutedX.shape.length);
+    const [outShape, reduceShape] = computeOutAndReduceShapes(permutedX.shape, reductionAxes);
+    const resultDtype = upcastType(permutedX.dtype, 'int32');
+    let result = zeros(backend, outShape, resultDtype);
+    const reduceSize = sizeFromShape(reduceShape);
+    const vals = backend.data.get(result.dataId).values;
+    const aVals = backend.data.get(permutedX.dataId).values;
+    for (let i = 0; i < vals.length; ++i) {
+        const offset = i * reduceSize;
+        let sum = 0;
+        for (let j = 0; j < reduceSize; ++j) {
+            sum += aVals[offset + j];
+        }
+        vals[i] = sum;
+    }
+    if (keepDims) {
+        const newShape = expandShapeToKeepDim(result.shape, axes);
+        const oldResult = result;
+        result = reshape({ inputs: { x: result }, backend, attrs: { shape: newShape } });
+        backend.disposeIntermediateTensorInfo(oldResult);
+    }
+    backend.disposeIntermediateTensorInfo($x);
+    if (permutation != null) {
+        backend.disposeIntermediateTensorInfo(permutedX);
+    }
+    return result;
+}
+const sumConfig = {
+    kernelName: Sum,
+    backendName: 'cpu',
+    kernelFunc: sum
+};
+
+
+function einsum(args) {
+    const { inputs, backend, attrs } = args;
+    const { equation } = attrs;
+    const tensors = inputs;
+    const { allDims, summedDims, idDims } = decodeEinsumEquation(equation, tensors.length);
+    checkEinsumDimSizes(allDims.length, idDims, tensors);
+    const { path, steps } = getEinsumComputePath(summedDims, idDims);
+    const nSteps = steps.length;
+    let out = null;
+    let numDimsRemaining = allDims.length;
+    const tensorsToDispose = [];
+    for (let i = 0; i < nSteps; ++i) {
+        for (const idTerm of steps[i]) {
+            const { permutationIndices: perm, expandDims: dimsToExpand } = getEinsumPermutation(numDimsRemaining, idDims[idTerm]);
+            let x;
+            if (isIdentityPermutation(perm)) {
+                x = tensors[idTerm];
+            }
+            else {
+                x = transpose$1({ inputs: { x: tensors[idTerm] }, backend, attrs: { perm } });
+                tensorsToDispose.push(x);
+            }
+            const targetShape = x.shape.slice();
+            for (let k = 0; k < dimsToExpand.length; ++k) {
+                targetShape.splice(dimsToExpand[k], 0, 1);
+            }
+            if (!arraysEqual(x.shape, targetShape)) {
+                x = reshape({ inputs: { x }, backend, attrs: { shape: targetShape } });
+                tensorsToDispose.push(x);
+            }
+            if (out === null) {
+                out = x;
+            }
+            else {
+                
+                out = multiply$1({ inputs: { a: x, b: out }, backend });
+                tensorsToDispose.push(out);
+            }
+        }
+        if (i < nSteps - 1) {
+            if (path[i] >= 0) {
+                out = sum({
+                    inputs: { x: out },
+                    backend,
+                    attrs: {
+                        axis: path[i] - (allDims.length - numDimsRemaining),
+                        keepDims: false
+                    }
+                });
+                tensorsToDispose.push(out);
+            }
+            numDimsRemaining--;
+        }
+    }
+    
+    for (const tensorInfo of tensorsToDispose) {
+        if (tensorInfo === out) {
+            continue;
+        }
+        backend.disposeIntermediateTensorInfo(tensorInfo);
+    }
+    return out;
+}
+const einsumConfig = {
+    kernelName: Einsum,
+    backendName: 'cpu',
+    kernelFunc: einsum
+};
+
+
+function eluGrad(args) {
+    const { inputs, backend } = args;
+    const { dy, y } = inputs;
+    assertNotComplex([dy, y], 'eluGrad');
+    const resultValues = new Float32Array(sizeFromShape(y.shape));
+    const values = backend.data.get(y.dataId).values;
+    const dyValues = backend.data.get(dy.dataId).values;
+    for (let i = 0; i < values.length; ++i) {
+        const v = values[i];
+        if (v >= 0) {
+            resultValues[i] = dyValues[i];
+        }
+        else {
+            resultValues[i] = dyValues[i] * (v + 1);
+        }
+    }
+    return backend.makeTensorInfo(y.shape, 'float32', resultValues);
+}
+const eluGradConfig$1 = {
+    kernelName: EluGrad,
+    backendName: 'cpu',
+    kernelFunc: eluGrad
+};
+
+
+const p = ERF_P;
+const a1 = ERF_A1;
+const a2 = ERF_A2;
+const a3 = ERF_A3;
+const a4 = ERF_A4;
+const a5 = ERF_A5;
+const erf = unaryKernelFunc$1(Erf, (xi) => {
+    const sign = Math.sign(xi);
+    const v = Math.abs(xi);
+    const t = 1.0 / (1.0 + p * v);
+    return sign *
+        (1.0 -
+            (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t *
+                Math.exp(-v * v));
+});
+const erfConfig = {
+    kernelName: Erf,
+    backendName: 'cpu',
+    kernelFunc: erf,
+};
+
+
+function expandDims$1(args) {
+    const { inputs, backend, attrs } = args;
+    const { input } = inputs;
+    const { dim } = attrs;
+    const inputRank = input.shape.length;
+    const newShape = input.shape.slice();
+    let $dim = dim;
+    if (dim < 0) {
+        
+        assert$1(-(inputRank + 1) <= dim, () => `Axis must be in the interval [${-(inputRank + 1)}, ${inputRank}]`);
+        $dim = inputRank + dim + 1;
+    }
+    newShape.splice($dim, 0, 1);
+    return reshape({ inputs: { x: input }, backend, attrs: { shape: newShape } });
+}
+const expandDimsConfig = {
+    kernelName: ExpandDims,
+    backendName: 'cpu',
+    kernelFunc: expandDims$1
+};
+
+
+const realDivImpl = createSimpleBinaryKernelImpl((a, b) => a / b);
+const div = binaryKernelFunc$1(RealDiv, realDivImpl);
+const realDivConfig = {
+    kernelName: RealDiv,
+    backendName: 'cpu',
+    kernelFunc: div
+};
+
+
+
+function fftBatch(input, inverse, cpuBackend) {
+    const inputShape = input.shape;
+    const batch = inputShape[0];
+    const innerDim = inputShape[1];
+    const inputVals = cpuBackend.data.get(input.dataId);
+    const real2D = inputVals.complexTensorInfos.real;
+    const imag2D = inputVals.complexTensorInfos.imag;
+    
+    const resultShape = [batch, innerDim];
+    const resultSize = sizeFromShape(resultShape);
+    const resultReal = getTypedArrayFromDType('float32', resultSize);
+    const resultImag = getTypedArrayFromDType('float32', resultSize);
+    for (let b = 0; b < batch; b++) {
+        
+        const r = slice$1({
+            inputs: { x: real2D },
+            backend: cpuBackend,
+            attrs: { begin: [b, 0], size: [1, innerDim] }
+        });
+        const i = slice$1({
+            inputs: { x: imag2D },
+            backend: cpuBackend,
+            attrs: { begin: [b, 0], size: [1, innerDim] }
+        });
+        const input = complex$1({ inputs: { real: r, imag: i }, backend: cpuBackend });
+        
+        const { real, imag } = fftImpl(input, inverse, cpuBackend);
+        const res = mergeRealAndImagArrays(real, imag);
+        for (let d = 0; d < innerDim; d++) {
+            const c = getComplexWithIndex(res, d);
+            resultReal[b * innerDim + d] = c.real;
+            resultImag[b * innerDim + d] = c.imag;
+        }
+        cpuBackend.disposeIntermediateTensorInfo(r);
+        cpuBackend.disposeIntermediateTensorInfo(i);
+        cpuBackend.disposeIntermediateTensorInfo(input);
+    }
+    const $realInfo = cpuBackend.makeTensorInfo(resultShape, 'float32', resultReal);
+    const $imagInfo = cpuBackend.makeTensorInfo(resultShape, 'float32', resultImag);
+    const result = complex$1({ inputs: { real: $realInfo, imag: $imagInfo }, backend: cpuBackend });
+    cpuBackend.disposeIntermediateTensorInfo($realInfo);
+    cpuBackend.disposeIntermediateTensorInfo($imagInfo);
+    return result;
+}
+function fftImpl(input, inverse, cpuBackend) {
+    const inputSize = sizeFromShape(input.shape);
+    const inputVals = cpuBackend.data.get(input.dataId);
+    const realVals = cpuBackend.data.get(inputVals.complexTensorInfos.real.dataId).values;
+    const imagVals = cpuBackend.data.get(inputVals.complexTensorInfos.imag.dataId).values;
+    if (isExponentOf2(inputSize)) {
+        const result = fftRadix2(realVals, imagVals, inputSize, inverse, cpuBackend);
+        const resultShape = [input.shape[0], input.shape[1]];
+        if (inverse) {
+            const realInfo = cpuBackend.makeTensorInfo(resultShape, 'float32', result.real);
+            const imagInfo = cpuBackend.makeTensorInfo(resultShape, 'float32', result.imag);
+            const sizeInfo = cpuBackend.makeTensorInfo([], 'float32', createScalarValue(inputSize, 'float32'));
+            const sizeInfoCopy = identity$1({ inputs: { x: sizeInfo }, backend: cpuBackend });
+            const divRealInfo = realDivConfig.kernelFunc({ inputs: { a: realInfo, b: sizeInfo }, backend: cpuBackend });
+            const divImagInfo = realDivConfig.kernelFunc({ inputs: { a: imagInfo, b: sizeInfoCopy }, backend: cpuBackend });
+            const divRealVals = cpuBackend.data.get(divRealInfo.dataId).values;
+            const divImagVals = cpuBackend.data.get(divImagInfo.dataId).values;
+            cpuBackend.disposeIntermediateTensorInfo(realInfo);
+            cpuBackend.disposeIntermediateTensorInfo(imagInfo);
+            cpuBackend.disposeIntermediateTensorInfo(sizeInfo);
+            cpuBackend.disposeIntermediateTensorInfo(sizeInfoCopy);
+            cpuBackend.disposeIntermediateTensorInfo(divRealInfo);
+            cpuBackend.disposeIntermediateTensorInfo(divImagInfo);
+            return { real: divRealVals, imag: divImagVals };
+        }
+        return result;
+    }
+    else {
+        const data = mergeRealAndImagArrays(realVals, imagVals);
+        const rawOutput = fourierTransformByMatmul(data, inputSize, inverse);
+        return splitRealAndImagArrays(rawOutput);
+    }
+}
+function isExponentOf2(size) {
+    return (size & size - 1) === 0;
+}
+
+function fftRadix2(realVals, imagVals, size, inverse, cpuBackend) {
+    if (size === 1) {
+        return { real: realVals, imag: imagVals };
+    }
+    const data = mergeRealAndImagArrays(realVals, imagVals);
+    const half = size / 2;
+    const evenComplex = complexWithEvenIndex(data);
+    const evenRealVals = evenComplex.real;
+    const evenImagVals = evenComplex.imag;
+    const evenShape = [evenRealVals.length];
+    const evenRealInfo = cpuBackend.makeTensorInfo(evenShape, 'float32', evenRealVals);
+    const evenImagInfo = cpuBackend.makeTensorInfo(evenShape, 'float32', evenImagVals);
+    const evenTensorInfo = complex$1({ inputs: { real: evenRealInfo, imag: evenImagInfo }, backend: cpuBackend });
+    const oddComplex = complexWithOddIndex(data);
+    const oddRealVals = oddComplex.real;
+    const oddImagVals = oddComplex.imag;
+    const oddShape = [oddRealVals.length];
+    const oddRealInfo = cpuBackend.makeTensorInfo(oddShape, 'float32', oddRealVals);
+    const oddImagInfo = cpuBackend.makeTensorInfo(oddShape, 'float32', oddImagVals);
+    const oddTensorInfo = complex$1({ inputs: { real: oddRealInfo, imag: oddImagInfo }, backend: cpuBackend });
+    
+    const $evenComplex = fftRadix2(evenRealVals, evenImagVals, half, inverse, cpuBackend);
+    const $evenRealVals = $evenComplex.real;
+    const $evenImagVals = $evenComplex.imag;
+    const $evenShape = [$evenRealVals.length];
+    const $evenRealInfo = cpuBackend.makeTensorInfo($evenShape, 'float32', $evenRealVals);
+    const $evenImagInfo = cpuBackend.makeTensorInfo($evenShape, 'float32', $evenImagVals);
+    const $evenTensorInfo = complex$1({
+        inputs: { real: $evenRealInfo, imag: $evenImagInfo },
+        backend: cpuBackend
+    });
+    const $oddComplex = fftRadix2(oddRealVals, oddImagVals, half, inverse, cpuBackend);
+    const $oddRealVals = $oddComplex.real;
+    const $oddImagVals = $oddComplex.imag;
+    const $oddShape = [$oddRealVals.length];
+    const $oddRealInfo = cpuBackend.makeTensorInfo($oddShape, 'float32', $oddRealVals);
+    const $oddImagInfo = cpuBackend.makeTensorInfo($oddShape, 'float32', $oddImagVals);
+    const $oddTensorInfo = complex$1({ inputs: { real: $oddRealInfo, imag: $oddImagInfo }, backend: cpuBackend });
+    const e = exponents(size, inverse);
+    const eShape = [e.real.length];
+    const eRealInfo = cpuBackend.makeTensorInfo(eShape, 'float32', e.real);
+    const eImagInfo = cpuBackend.makeTensorInfo(eShape, 'float32', e.imag);
+    const complexInfo = complex$1({ inputs: { real: eRealInfo, imag: eImagInfo }, backend: cpuBackend });
+    const exponentInfo = multiply$1({ inputs: { a: complexInfo, b: $oddTensorInfo }, backend: cpuBackend });
+    const addPart = add({
+        inputs: { a: $evenTensorInfo, b: exponentInfo },
+        backend: cpuBackend
+    });
+    const subPart = sub$1({
+        inputs: { a: $evenTensorInfo, b: exponentInfo },
+        backend: cpuBackend
+    });
+    const addPartReal = real$1({ inputs: { input: addPart }, backend: cpuBackend });
+    const subPartReal = real$1({ inputs: { input: subPart }, backend: cpuBackend });
+    const addPartImag = imag({ inputs: { input: addPart }, backend: cpuBackend });
+    const subPartImag = imag({ inputs: { input: subPart }, backend: cpuBackend });
+    const $real = concat({
+        inputs: [addPartReal, subPartReal],
+        backend: cpuBackend,
+        attrs: { axis: 0 }
+    });
+    const $imag = concat({
+        inputs: [addPartImag, subPartImag],
+        backend: cpuBackend,
+        attrs: { axis: 0 }
+    });
+    const $realVals = cpuBackend.data.get($real.dataId).values;
+    const $imagVals = cpuBackend.data.get($imag.dataId).values;
+    cpuBackend.disposeIntermediateTensorInfo(evenRealInfo);
+    cpuBackend.disposeIntermediateTensorInfo(evenImagInfo);
+    cpuBackend.disposeIntermediateTensorInfo(evenTensorInfo);
+    cpuBackend.disposeIntermediateTensorInfo(oddRealInfo);
+    cpuBackend.disposeIntermediateTensorInfo(oddImagInfo);
+    cpuBackend.disposeIntermediateTensorInfo(oddTensorInfo);
+    cpuBackend.disposeIntermediateTensorInfo($evenRealInfo);
+    cpuBackend.disposeIntermediateTensorInfo($evenImagInfo);
+    cpuBackend.disposeIntermediateTensorInfo($evenTensorInfo);
+    cpuBackend.disposeIntermediateTensorInfo($oddRealInfo);
+    cpuBackend.disposeIntermediateTensorInfo($oddImagInfo);
+    cpuBackend.disposeIntermediateTensorInfo($oddTensorInfo);
+    cpuBackend.disposeIntermediateTensorInfo(eRealInfo);
+    cpuBackend.disposeIntermediateTensorInfo(eImagInfo);
+    cpuBackend.disposeIntermediateTensorInfo(complexInfo);
+    cpuBackend.disposeIntermediateTensorInfo(exponentInfo);
+    cpuBackend.disposeIntermediateTensorInfo(addPart);
+    cpuBackend.disposeIntermediateTensorInfo(subPart);
+    cpuBackend.disposeIntermediateTensorInfo(addPartReal);
+    cpuBackend.disposeIntermediateTensorInfo(addPartImag);
+    cpuBackend.disposeIntermediateTensorInfo(subPartReal);
+    cpuBackend.disposeIntermediateTensorInfo(subPartImag);
+    cpuBackend.disposeIntermediateTensorInfo($real);
+    cpuBackend.disposeIntermediateTensorInfo($imag);
+    return { real: $realVals, imag: $imagVals };
+}
+
+function fourierTransformByMatmul(data, size, inverse) {
+    const ret = new Float32Array(size * 2);
+    
+    for (let r = 0; r < size; r++) {
+        let real = 0.0;
+        let imag = 0.0;
+        for (let c = 0; c < size; c++) {
+            const e = exponent(r * c, size, inverse);
+            const term = getComplexWithIndex(data, c);
+            real += term.real * e.real - term.imag * e.imag;
+            imag += term.real * e.imag + term.imag * e.real;
+        }
+        if (inverse) {
+            real /= size;
+            imag /= size;
+        }
+        assignToTypedArray(ret, real, imag, r);
+    }
+    return ret;
+}
+
+
+function fft(args) {
+    const { inputs, backend } = args;
+    const { input } = inputs;
+    const inputSize = sizeFromShape(input.shape);
+    
+    const innerDimensionSize = input.shape[input.shape.length - 1];
+    const batch = inputSize / innerDimensionSize;
+    const input2D = reshape({
+        inputs: { x: input },
+        backend,
+        attrs: { shape: [batch, innerDimensionSize] }
+    });
+    const result = fftBatch(input2D, false, backend);
+    const resultReshaped = reshape({ inputs: { x: result }, backend, attrs: { shape: input.shape } });
+    backend.disposeIntermediateTensorInfo(input2D);
+    backend.disposeIntermediateTensorInfo(result);
+    return resultReshaped;
+}
+const fftConfig = {
+    kernelName: FFT,
+    backendName: 'cpu',
+    kernelFunc: fft
+};
+
+
+function fill(args) {
+    const { backend, attrs } = args;
+    const { shape, value, dtype } = attrs;
+    const $dtype = dtype || inferDtype(value);
+    const values = getArrayFromDType($dtype, sizeFromShape(shape));
+    fillValues(values, value, $dtype);
+    return backend.makeTensorInfo(shape, $dtype, values);
+}
+const fillConfig = {
+    kernelName: Fill,
+    backendName: 'cpu',
+    kernelFunc: fill
+};
+function fillValues(values, value, dtype) {
+    if (dtype === 'string') {
+        values.fill(value);
+    }
+    else {
+        values.fill(value);
+    }
+}
+
+
+const flipLeftRightConfig = {
+    kernelName: FlipLeftRight,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, attrs, backend }) => {
+        const { image } = inputs;
+        const cpuBackend = backend;
+        const output = getTypedArrayFromDType(image.dtype, sizeFromShape(image.shape));
+        const [batch, imageHeight, imageWidth, numChannels] = image.shape;
+        const imageVals = cpuBackend.data.get(image.dataId).values;
+        for (let batchIdx = 0; batchIdx < batch; batchIdx++) {
+            const batchOffset = batchIdx * imageWidth * imageHeight * numChannels;
+            for (let row = 0; row < imageHeight; row++) {
+                const rowOffset = row * (imageWidth * numChannels);
+                for (let col = 0; col < imageWidth; col++) {
+                    const colOffset = col * numChannels;
+                    for (let channel = 0; channel < numChannels; channel++) {
+                        const coordX = Math.round(imageWidth - col - 1);
+                        const outIdx = batchOffset + rowOffset + colOffset + channel;
+                        let outputValue = imageVals[outIdx];
+                        
+                        if (coordX >= 0 && coordX < imageWidth) {
+                            
+                            const rotatedColOffset = coordX * numChannels;
+                            const imageIdx = batchOffset + rowOffset + rotatedColOffset + channel;
+                            outputValue = imageVals[imageIdx];
+                        }
+                        output[outIdx] = outputValue;
+                    }
+                }
+            }
+        }
+        const dataId = cpuBackend.write(output, image.shape, image.dtype);
+        return { dataId, shape: image.shape, dtype: image.dtype };
+    }
+};
+
+
+function fusedConv2D(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, filter, bias, preluActivationWeights } = inputs;
+    const { strides, pad, dataFormat, dilations, dimRoundingMode, activation, leakyreluAlpha } = attrs;
+    let result = conv2D({
+        inputs: { x, filter },
+        backend,
+        attrs: { strides, pad, dataFormat, dilations, dimRoundingMode }
+    });
+    if (bias) {
+        const resultOld = result;
+        
+        
+        
+        
+        if (dataFormat === 'NCHW' && bias.shape.length === 1 &&
+            bias.shape[0] !== 1) {
+            const reshapedBias = reshape({ inputs: { x: bias }, backend, attrs: { shape: [bias.shape[0], 1, 1] } });
+            result =
+                add({ inputs: { a: result, b: reshapedBias }, backend });
+            backend.disposeIntermediateTensorInfo(reshapedBias);
+        }
+        else {
+            
+            
+            result = add({ inputs: { a: result, b: bias }, backend });
+        }
+        backend.disposeIntermediateTensorInfo(resultOld);
+    }
+    if (activation) {
+        const resultOld = result;
+        
+        
+        
+        
+        if (dataFormat === 'NCHW' && activation === 'prelu' &&
+            preluActivationWeights.shape.length === 1 &&
+            preluActivationWeights.shape[0] !== 1) {
+            const reshapedAlpha = reshape({
+                inputs: { x: preluActivationWeights },
+                backend,
+                attrs: { shape: [preluActivationWeights.shape[0], 1, 1] }
+            });
+            result = applyActivation(backend, result, activation, reshapedAlpha, leakyreluAlpha);
+            backend.disposeIntermediateTensorInfo(reshapedAlpha);
+        }
+        else {
+            result = applyActivation(backend, result, activation, preluActivationWeights, leakyreluAlpha);
+        }
+        backend.disposeIntermediateTensorInfo(resultOld);
+    }
+    return result;
+}
+const fusedConv2DConfig = {
+    kernelName: FusedConv2D,
+    backendName: 'cpu',
+    kernelFunc: fusedConv2D
+};
+
+
+function fusedDepthwiseConv2D(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, filter, bias, preluActivationWeights } = inputs;
+    const { strides, pad, dataFormat, dilations, dimRoundingMode, activation, leakyreluAlpha } = attrs;
+    let result = depthwiseConv2dNative({
+        inputs: { x, filter },
+        backend,
+        attrs: { strides, pad, dataFormat, dilations, dimRoundingMode }
+    });
+    if (bias) {
+        const oldResult = result;
+        result = add({ inputs: { a: result, b: bias }, backend });
+        backend.disposeIntermediateTensorInfo(oldResult);
+    }
+    if (activation) {
+        const oldResult = result;
+        result = applyActivation(backend, result, activation, preluActivationWeights, leakyreluAlpha);
+        backend.disposeIntermediateTensorInfo(oldResult);
+    }
+    return result;
+}
+const fusedDepthwiseConv2DConfig = {
+    kernelName: FusedDepthwiseConv2D,
+    backendName: 'cpu',
+    kernelFunc: fusedDepthwiseConv2D
+};
+
+
+function gatherNd(args) {
+    const { inputs, backend } = args;
+    const { params, indices } = inputs;
+    const paramsSize = sizeFromShape(params.shape);
+    const indicesShape = indices.shape;
+    const sliceRank = indicesShape[indicesShape.length - 1];
+    const [resultShape, numSlices, sliceSize, strides] = prepareAndValidate(params, indices);
+    if (numSlices === 0) {
+        return backend.makeTensorInfo(resultShape, params.dtype, []);
+    }
+    const indicesData = backend.data.get(indices.dataId).values;
+    const paramsBuf = backend.bufferSync(params);
+    const outBuf = gatherNdImpl(indicesData, paramsBuf, params.dtype, numSlices, sliceRank, sliceSize, strides, params.shape, paramsSize);
+    return backend.makeTensorInfo(resultShape, params.dtype, outBuf.values);
+}
+const gatherNdConfig = {
+    kernelName: GatherNd,
+    backendName: 'cpu',
+    kernelFunc: gatherNd
+};
+
+
+function gatherV2(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, indices } = inputs;
+    const { axis, batchDims } = attrs;
+    assertNotComplex([x, indices], 'gatherV2');
+    
+    const parsedAxis = parseAxisParam(axis, x.shape)[0];
+    const indicesVals = backend.data.get(indices.dataId).values;
+    const axisDim = x.shape[parsedAxis];
+    for (let i = 0; i < indicesVals.length; ++i) {
+        const index = indicesVals[i];
+        assert$1(index <= axisDim - 1 && index >= 0, () => `GatherV2: the index value ${index} is not in [0, ${axisDim - 1}]`);
+    }
+    let $batchDims = batchDims;
+    if (batchDims == null) {
+        $batchDims = 0;
+    }
+    const indicesSize = sizeFromShape(indices.shape);
+    const shapeInfo = collectGatherOpShapeInfo(x, indices, parsedAxis, $batchDims);
+    const flattenX = reshape({
+        inputs: { x },
+        backend,
+        attrs: {
+            shape: [
+                shapeInfo.batchSize, shapeInfo.outerSize, shapeInfo.dimSize,
+                shapeInfo.sliceSize
+            ]
+        }
+    });
+    const flattenIndex = reshape({
+        inputs: { x: indices },
+        backend,
+        attrs: { shape: [shapeInfo.batchSize, indicesSize / shapeInfo.batchSize] }
+    });
+    const flattenOutputShape = [
+        shapeInfo.batchSize, shapeInfo.outerSize, indicesSize / shapeInfo.batchSize,
+        shapeInfo.sliceSize
+    ];
+    const indicesBuf = backend.bufferSync(flattenIndex);
+    const xBuf = backend.bufferSync(flattenX);
+    const outBuf = gatherV2Impl(xBuf, indicesBuf, flattenOutputShape);
+    backend.disposeIntermediateTensorInfo(flattenX);
+    backend.disposeIntermediateTensorInfo(flattenIndex);
+    return backend.makeTensorInfo(shapeInfo.outputShape, outBuf.dtype, outBuf.values);
+}
+const gatherV2Config = {
+    kernelName: GatherV2,
+    backendName: 'cpu',
+    kernelFunc: gatherV2
+};
+
+
+function ifft(args) {
+    const { inputs, backend } = args;
+    const { input } = inputs;
+    const inputSize = sizeFromShape(input.shape);
+    
+    const innerDimensionSize = input.shape[input.shape.length - 1];
+    const batch = inputSize / innerDimensionSize;
+    const input2D = reshape({
+        inputs: { x: input },
+        backend,
+        attrs: { shape: [batch, innerDimensionSize] }
+    });
+    const result = fftBatch(input2D, true, backend);
+    const resultReshaped = reshape({ inputs: { x: result }, backend, attrs: { shape: input.shape } });
+    backend.disposeIntermediateTensorInfo(input2D);
+    backend.disposeIntermediateTensorInfo(result);
+    return resultReshaped;
+}
+const ifftConfig = {
+    kernelName: IFFT,
+    backendName: 'cpu',
+    kernelFunc: ifft
+};
+
+
+const isFinite$1 = unaryKernelFunc$1(IsFinite, (xi) => Number.isFinite(xi) ? 1 : 0, 'bool');
+const isFiniteConfig = {
+    kernelName: IsFinite,
+    backendName: 'cpu',
+    kernelFunc: isFinite$1,
+};
+
+
+const isInf = unaryKernelFunc$1(IsInf, (xi) => Math.abs(xi) === Infinity ? 1 : 0, 'bool');
+const isInfConfig = {
+    kernelName: IsInf,
+    backendName: 'cpu',
+    kernelFunc: isInf,
+};
+
+
+const isNaN$1 = unaryKernelFunc$1(IsNan, (xi) => Number.isNaN(xi) ? 1 : 0, 'bool');
+const isNaNConfig = {
+    kernelName: IsNan,
+    backendName: 'cpu',
+    kernelFunc: isNaN$1,
+};
+
+
+function linSpace(args) {
+    const { backend, attrs } = args;
+    const { start, stop, num } = attrs;
+    const outVals = linSpaceImpl(start, stop, num);
+    return backend.makeTensorInfo([outVals.length], 'float32', outVals);
+}
+const linSpaceConfig = {
+    kernelName: LinSpace,
+    backendName: 'cpu',
+    kernelFunc: linSpace
+};
+
+
+const log1p = unaryKernelFunc$1(Log1p, (xi) => Math.log1p(xi));
+const log1pConfig = {
+    kernelName: Log1p,
+    backendName: 'cpu',
+    kernelFunc: log1p,
+};
+
+
+const logicalAndImpl = createSimpleBinaryKernelImpl((a, b) => a && b);
+const logicalAnd = binaryKernelFunc$1(LogicalAnd, logicalAndImpl, null , 'bool');
+const logicalAndConfig = {
+    kernelName: LogicalAnd,
+    backendName: 'cpu',
+    kernelFunc: logicalAnd
+};
+
+
+const logicalNot = unaryKernelFunc$1(LogicalNot, (xi) => xi ? 0 : 1, 'bool');
+const logicalNotConfig = {
+    kernelName: LogicalNot,
+    backendName: 'cpu',
+    kernelFunc: logicalNot,
+};
+
+
+const logicalOrImpl = createSimpleBinaryKernelImpl((a, b) => a || b);
+const logicalOr = binaryKernelFunc$1(LogicalOr, logicalOrImpl, null , 'bool');
+const logicalOrConfig = {
+    kernelName: LogicalOr,
+    backendName: 'cpu',
+    kernelFunc: logicalOr
+};
+
+
+function lRN(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { depthRadius, bias, alpha, beta } = attrs;
+    assertNotComplex(x, 'LRN');
+    const channels = x.shape[3];
+    const maxD = channels - 1;
+    const xValues = backend.data.get(x.dataId).values;
+    const size = sizeFromShape(x.shape);
+    const result = new Float32Array(size);
+    function sumAcrossChannels(offset) {
+        const currentChannel = offset % channels;
+        let beginSumOffset = offset - currentChannel + Math.max(0, currentChannel - depthRadius);
+        const endSumOffset = offset - currentChannel + Math.min(currentChannel + depthRadius, maxD);
+        let sum = 0.0;
+        for (; beginSumOffset <= endSumOffset; beginSumOffset++) {
+            const z = xValues[beginSumOffset];
+            sum += z * z;
+        }
+        return sum;
+    }
+    for (let offset = 0; offset < size; offset++) {
+        const sum = sumAcrossChannels(offset);
+        const val = xValues[offset] * Math.pow(bias + alpha * sum, -beta);
+        result[offset] = val;
+    }
+    return backend.makeTensorInfo(x.shape, x.dtype, result);
+}
+
+const LRNConfig = {
+    kernelName: LRN,
+    backendName: 'cpu',
+    kernelFunc: lRN
+};
+
+
+function lRNGrad(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, y, dy } = inputs;
+    const { depthRadius, bias, alpha, beta } = attrs;
+    assertNotComplex(dy, 'LRNGrad');
+    const dySize = sizeFromShape(dy.shape);
+    const channels = dy.shape[3];
+    const dyValues = backend.data.get(dy.dataId).values;
+    const xValues = backend.data.get(x.dataId).values;
+    const yValues = backend.data.get(y.dataId).values;
+    const result = new Float32Array(dySize);
+    const size = dySize;
+    for (let offset = 0; offset < size; offset++) {
+        const currentChannel = offset % channels;
+        const depthBegin = (offset - currentChannel) + Math.max(0, currentChannel - depthRadius);
+        const depthEnd = (offset - currentChannel) +
+            Math.min(channels, currentChannel + depthRadius + 1);
+        let norm = 0;
+        for (let k = depthBegin; k < depthEnd; k++) {
+            norm += Math.pow(xValues[k], 2);
+        }
+        norm = alpha * norm + bias;
+        for (let k = depthBegin; k < depthEnd; k++) {
+            let dyi = -2 * alpha * beta * xValues[k] * yValues[offset] / norm;
+            if (offset === k) {
+                dyi += Math.pow(norm, -beta);
+            }
+            dyi *= dyValues[offset];
+            result[k] += dyi;
+        }
+    }
+    return backend.makeTensorInfo(dy.shape, x.dtype, result);
+}
+
+const LRNGradConfig = {
+    kernelName: LRNGrad,
+    backendName: 'cpu',
+    kernelFunc: lRNGrad
+};
+
+
+function max(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { reductionIndices, keepDims } = attrs;
+    const cpuBackend = backend;
+    let xShape = x.shape;
+    const xRank = xShape.length;
+    const origAxes = parseAxisParam(reductionIndices, xShape);
+    let axes = origAxes;
+    const permutedAxes = getAxesPermutation(axes, xRank);
+    let xVals = cpuBackend.data.get(x.dataId).values;
+    if (permutedAxes != null) {
+        const newShape = new Array(xRank);
+        for (let i = 0; i < newShape.length; i++) {
+            newShape[i] = xShape[permutedAxes[i]];
+        }
+        xVals = transposeImpl$1(xVals, xShape, x.dtype, permutedAxes, newShape);
+        axes = getInnerMostAxes(axes.length, xRank);
+        xShape = newShape;
+    }
+    assertNotComplex(x, 'max');
+    assertAxesAreInnerMostDims('max', axes, xRank);
+    const [maxOutShape, reduceShape] = computeOutAndReduceShapes(xShape, axes);
+    const reduceSize = sizeFromShape(reduceShape);
+    const result = maxImpl$1(xVals, reduceSize, maxOutShape, x.dtype);
+    const dataId = cpuBackend.write(result, maxOutShape, x.dtype);
+    let outShape = maxOutShape;
+    if (keepDims) {
+        
+        const newShape = expandShapeToKeepDim(maxOutShape, origAxes);
+        outShape = newShape;
+    }
+    return { dataId, shape: outShape, dtype: x.dtype };
+}
+const maxConfig = {
+    kernelName: Max,
+    backendName: 'cpu',
+    kernelFunc: max
+};
+
+
+function maxPool(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    assertNotComplex(x, 'maxPool');
+    const { filterSize, strides, pad, dimRoundingMode } = attrs;
+    const dilations = 1;
+    assert$1(eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in maxPool: Either strides or dilations must be 1. ' +
+        `Got strides ${strides} and dilations '${dilations}'`);
+    const convInfo = computePool2DInfo(x.shape, filterSize, strides, dilations, pad, dimRoundingMode);
+    let res;
+    if (convInfo.filterWidth === 1 && convInfo.filterHeight === 1 &&
+        arraysEqual(convInfo.inShape, convInfo.outShape)) {
+        res = identity$1({ inputs: { x }, backend });
+    }
+    else {
+        const xValues = backend.data.get(x.dataId).values;
+        const strides = computeStrides(x.shape);
+        const buffer = pool(xValues, x.shape, x.dtype, strides, convInfo, 'max');
+        res = backend.makeTensorInfo(convInfo.outShape, x.dtype, buffer.values);
+    }
+    return res;
+}
+const maxPoolConfig = {
+    kernelName: MaxPool,
+    backendName: 'cpu',
+    kernelFunc: maxPool
+};
+
+
+function maxPool3D(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { filterSize, strides, pad, dimRoundingMode, dataFormat } = attrs;
+    assertNotComplex(x, 'maxPool3d');
+    const convInfo = computePool3DInfo(x.shape, filterSize, strides, 1 , pad, dimRoundingMode, dataFormat);
+    const xValues = backend.data.get(x.dataId).values;
+    const outBuf = pool3d(xValues, x.shape, x.dtype, computeStrides(x.shape), convInfo, 'max');
+    return backend.makeTensorInfo(outBuf.shape, 'float32', outBuf.values);
+}
+const maxPool3DConfig = {
+    kernelName: MaxPool3D,
+    backendName: 'cpu',
+    kernelFunc: maxPool3D
+};
+
+
+function maxPool3DGrad(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, input } = inputs;
+    const { filterSize, strides, pad, dimRoundingMode } = attrs;
+    assertNotComplex([dy, input], 'maxPool3DGrad');
+    const convInfo = computePool3DInfo(input.shape, filterSize, strides, 1 , pad, dimRoundingMode);
+    const inputBuf = backend.bufferSync(input);
+    const maxPosBuf = maxPool3dPositions(inputBuf, convInfo);
+    const strideDepth = convInfo.strideDepth;
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const dilationDepth = convInfo.dilationDepth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterDepth = convInfo.effectiveFilterDepth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padFront = effectiveFilterDepth - 1 - convInfo.padInfo.front;
+    const padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
+    const padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
+    const dx = buffer(input.shape, 'float32');
+    const dyBuf = backend.bufferSync(dy);
+    for (let batch = 0; batch < convInfo.batchSize; ++batch) {
+        for (let channel = 0; channel < convInfo.inChannels; ++channel) {
+            for (let dxDepth = 0; dxDepth < convInfo.inDepth; ++dxDepth) {
+                for (let dxRow = 0; dxRow < convInfo.inHeight; ++dxRow) {
+                    for (let dxCol = 0; dxCol < convInfo.inWidth; ++dxCol) {
+                        
+                        const dyDepthCorner = dxDepth - padFront;
+                        const dyRowCorner = dxRow - padTop;
+                        const dyColCorner = dxCol - padLeft;
+                        let dotProd = 0;
+                        for (let wDepth = 0; wDepth < effectiveFilterDepth; wDepth += dilationDepth) {
+                            const dyDepth = (dyDepthCorner + wDepth) / strideDepth;
+                            if (dyDepth < 0 || dyDepth >= convInfo.outDepth ||
+                                Math.floor(dyDepth) !== dyDepth) {
+                                continue;
+                            }
+                            for (let wRow = 0; wRow < effectiveFilterHeight; wRow += dilationHeight) {
+                                const dyRow = (dyRowCorner + wRow) / strideHeight;
+                                if (dyRow < 0 || dyRow >= convInfo.outHeight ||
+                                    Math.floor(dyRow) !== dyRow) {
+                                    continue;
+                                }
+                                for (let wCol = 0; wCol < effectiveFilterWidth; wCol += dilationWidth) {
+                                    const dyCol = (dyColCorner + wCol) / strideWidth;
+                                    if (dyCol < 0 || dyCol >= convInfo.outWidth ||
+                                        Math.floor(dyCol) !== dyCol) {
+                                        continue;
+                                    }
+                                    const maxPos = effectiveFilterDepth * effectiveFilterHeight *
+                                        effectiveFilterWidth -
+                                        1 -
+                                        maxPosBuf.get(batch, dyDepth, dyRow, dyCol, channel);
+                                    const curPos = wDepth * effectiveFilterHeight * effectiveFilterWidth +
+                                        wRow * effectiveFilterWidth + wCol;
+                                    const mask = maxPos === curPos ? 1 : 0;
+                                    if (mask === 0) {
+                                        continue;
+                                    }
+                                    const pixel = dyBuf.get(batch, dyDepth, dyRow, dyCol, channel);
+                                    dotProd += pixel * mask;
+                                }
+                            }
+                        }
+                        dx.set(dotProd, batch, dxDepth, dxRow, dxCol, channel);
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const maxPool3DGradConfig$1 = {
+    kernelName: MaxPool3DGrad,
+    backendName: 'cpu',
+    kernelFunc: maxPool3DGrad
+};
+
+
+function maxPoolGrad$1(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, input, output } = inputs;
+    const x = input;
+    assertNotComplex([input, output], 'maxPoolGrad');
+    const { filterSize, strides, pad, dimRoundingMode } = attrs;
+    const convInfo = computePool2DInfo(x.shape, filterSize, strides, 1 , pad, dimRoundingMode);
+    const xValues = backend.data.get(x.dataId).values;
+    const maxPosBuf = buffer(convInfo.outShape, x.dtype, maxPoolPositions(xValues, x.shape, x.dtype, convInfo).values);
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
+    const padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
+    const dx = buffer(x.shape, 'float32');
+    const dyData = backend.data.get(dy.dataId).values;
+    const dyBuf = buffer(dy.shape, 'float32', dyData);
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        for (let d = 0; d < convInfo.inChannels; ++d) {
+            for (let dxR = 0; dxR < convInfo.inHeight; ++dxR) {
+                for (let dxC = 0; dxC < convInfo.inWidth; ++dxC) {
+                    
+                    const dyRCorner = dxR - padTop;
+                    const dyCCorner = dxC - padLeft;
+                    let dotProd = 0;
+                    for (let wR = 0; wR < effectiveFilterHeight; wR += dilationHeight) {
+                        const dyR = (dyRCorner + wR) / strideHeight;
+                        if (dyR < 0 || dyR >= convInfo.outHeight ||
+                            Math.floor(dyR) !== dyR) {
+                            continue;
+                        }
+                        for (let wC = 0; wC < effectiveFilterWidth; wC += dilationWidth) {
+                            const dyC = (dyCCorner + wC) / strideWidth;
+                            if (dyC < 0 || dyC >= convInfo.outWidth ||
+                                Math.floor(dyC) !== dyC) {
+                                continue;
+                            }
+                            const maxPos = effectiveFilterHeight * effectiveFilterWidth - 1 -
+                                maxPosBuf.get(b, dyR, dyC, d);
+                            const curPos = wR * effectiveFilterWidth + wC;
+                            const mask = maxPos === curPos ? 1 : 0;
+                            if (mask === 0) {
+                                continue;
+                            }
+                            const pixel = dyBuf.get(b, dyR, dyC, d);
+                            dotProd += pixel * mask;
+                        }
+                    }
+                    dx.set(dotProd, b, dxR, dxC, d);
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const maxPoolGradConfig$1 = {
+    kernelName: MaxPoolGrad,
+    backendName: 'cpu',
+    kernelFunc: maxPoolGrad$1
+};
+
+
+function maxPoolWithArgmaxImpl(xValues, xShape, dtype, includeBatchInIndex, convInfo) {
+    const strides = computeStrides(xShape);
+    const maxPools = pool(xValues, xShape, dtype, strides, convInfo, 'max');
+    const maxPositions = maxPoolPositions(xValues, xShape, dtype, convInfo, true, includeBatchInIndex);
+    return [maxPools.values, maxPositions.values];
+}
+
+
+const maxPoolWithArgmaxConfig = {
+    kernelName: MaxPoolWithArgmax,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, attrs, backend }) => {
+        const { x } = inputs;
+        const { filterSize, strides, pad, includeBatchInIndex } = attrs;
+        const cpuBackend = backend;
+        assertNotComplex(x, 'MaxPoolWithArgmax');
+        const values = cpuBackend.data.get(x.dataId).values;
+        const convInfo = computePool2DInfo(x.shape, filterSize, strides, [1, 1], pad);
+        const [pooled, indexes] = maxPoolWithArgmaxImpl(values, x.shape, x.dtype, includeBatchInIndex, convInfo);
+        const pooledDataId = cpuBackend.write(pooled, convInfo.outShape, x.dtype);
+        const indexesDataId = cpuBackend.write(indexes, convInfo.outShape, x.dtype);
+        return [
+            { dataId: pooledDataId, shape: convInfo.outShape, dtype: x.dtype },
+            { dataId: indexesDataId, shape: convInfo.outShape, dtype: 'int32' }
+        ];
+    }
+};
+
+
+function mean(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, keepDims } = attrs;
+    const axes = parseAxisParam(axis, x.shape);
+    const shapes = computeOutAndReduceShapes(x.shape, axes);
+    const reduceShape = shapes[1];
+    const reduceSize = sizeFromShape(reduceShape);
+    const toDispose = [];
+    const reduceSizeScalar = backend.makeTensorInfo([], 'float32', new Float32Array([reduceSize]));
+    toDispose.push(reduceSizeScalar);
+    const $x = cast$2({ inputs: { x }, backend, attrs: { dtype: 'float32' } });
+    toDispose.push($x);
+    const res = div({ inputs: { a: $x, b: reduceSizeScalar }, backend });
+    toDispose.push(res);
+    const result = sum({ inputs: { x: res }, backend, attrs: { axis, keepDims } });
+    toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return result;
+}
+const meanConfig = {
+    kernelName: Mean,
+    backendName: 'cpu',
+    kernelFunc: mean
+};
+
+
+function min(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, keepDims } = attrs;
+    assertNotComplex(x, 'min');
+    const origAxes = parseAxisParam(axis, x.shape);
+    let axes = origAxes;
+    const permutedAxes = getAxesPermutation(axes, x.shape.length);
+    let $x = x;
+    if (permutedAxes != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutedAxes } });
+        axes = getInnerMostAxes(axes.length, x.shape.length);
+    }
+    assertAxesAreInnerMostDims('min', axes, $x.shape.length);
+    const [outShape, reduceShape] = computeOutAndReduceShapes($x.shape, axes);
+    const reduceSize = sizeFromShape(reduceShape);
+    const vals = makeZerosTypedArray(sizeFromShape(outShape), $x.dtype);
+    const aVals = backend.data.get($x.dataId).values;
+    for (let i = 0; i < vals.length; ++i) {
+        const offset = i * reduceSize;
+        let min = aVals[offset];
+        for (let j = 0; j < reduceSize; ++j) {
+            const value = aVals[offset + j];
+            if (Number.isNaN(value) ||
+                value < min) { 
+                min = value;
+            }
+        }
+        vals[i] = min;
+    }
+    if (permutedAxes != null) {
+        backend.disposeIntermediateTensorInfo($x);
+    }
+    const result = backend.makeTensorInfo(outShape, $x.dtype, vals);
+    if (keepDims) {
+        const expandedShape = expandShapeToKeepDim(outShape, origAxes);
+        const reshapedResult = reshape({ inputs: { x: result }, backend, attrs: { shape: expandedShape } });
+        backend.disposeIntermediateTensorInfo(result);
+        return reshapedResult;
+    }
+    return result;
+}
+const minConfig = {
+    kernelName: Min,
+    backendName: 'cpu',
+    kernelFunc: min
+};
+
+
+function mirrorPad(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { paddings, mode } = attrs;
+    assertNotComplex(x, 'mirrorPad');
+    const outShape = paddings.map((p, i) => p[0]  + x.shape[i] + p[1] );
+    const start = paddings.map(p => p[0]);
+    const end = paddings.map((p, i) => p[0] + x.shape[i]);
+    const offset = mode === 'reflect' ? 0 : 1;
+    const xVals = backend.data.get(x.dataId).values;
+    const xRank = x.shape.length;
+    const xStrides = computeStrides(x.shape);
+    const resultSize = sizeFromShape(outShape);
+    const resultRank = outShape.length;
+    const resultStrides = computeStrides(outShape);
+    const resVals = getTypedArrayFromDType(x.dtype, resultSize);
+    for (let i = 0; i < resultSize; i++) {
+        let coords = indexToLoc(i, resultRank, resultStrides);
+        for (let i = 0; i < resultRank; i++) {
+            if (coords[i] < start[i]) {
+                coords[i] = start[i] * 2 - coords[i] - offset;
+            }
+            else if (coords[i] >= end[i]) {
+                coords[i] = (end[i] - 1) * 2 - coords[i] + offset;
+            }
+        }
+        coords = coords.map((c, i) => c - start[i]);
+        const inIndex = locToIndex(coords, xRank, xStrides);
+        resVals[i] = xVals[inIndex];
+    }
+    const outId = backend.write(resVals, outShape, x.dtype);
+    return { dataId: outId, shape: outShape, dtype: x.dtype };
+}
+const mirrorPadConfig = {
+    kernelName: MirrorPad,
+    backendName: 'cpu',
+    kernelFunc: mirrorPad
+};
+
+
+const modImpl = createSimpleBinaryKernelImpl(((aValue, bValue) => {
+    const rem = aValue % bValue;
+    if ((aValue < 0 && bValue < 0) || (aValue >= 0 && bValue >= 0)) {
+        return rem;
+    }
+    else {
+        return (rem + bValue) % bValue;
+    }
+}));
+const mod = binaryKernelFunc$1(Mod, modImpl);
+const modConfig = {
+    kernelName: Mod,
+    backendName: 'cpu',
+    kernelFunc: mod
+};
+
+
+function softmax(args) {
+    const { inputs, backend, attrs } = args;
+    const { logits } = inputs;
+    const { dim } = attrs;
+    const logitsRank = logits.shape.length;
+    let $dim = dim;
+    if ($dim === -1) {
+        $dim = logitsRank - 1;
+    }
+    if ($dim !== logitsRank - 1) {
+        throw Error('Softmax along a non-last dimension is not yet supported. ' +
+            `Logits was rank ${logitsRank} and dim was ${$dim}`);
+    }
+    const axes = parseAxisParam([$dim], logits.shape);
+    const maxLogit = max({
+        inputs: { x: logits },
+        backend,
+        attrs: { reductionIndices: axes, keepDims: false }
+    });
+    const expandedShape = expandShapeToKeepDim(maxLogit.shape, axes);
+    const maxLogitReshaped = reshape({ inputs: { x: maxLogit }, backend, attrs: { shape: expandedShape } });
+    const a = sub$1({ inputs: { a: logits, b: maxLogitReshaped }, backend });
+    const b = exp$1({ inputs: { x: a }, backend });
+    const sumExp = sum({ inputs: { x: b }, backend, attrs: { axis: axes, keepDims: false } });
+    const sumReshaped = reshape({ inputs: { x: sumExp }, backend, attrs: { shape: expandedShape } });
+    const result = div({ inputs: { a: b, b: sumReshaped }, backend });
+    backend.disposeIntermediateTensorInfo(maxLogit);
+    backend.disposeIntermediateTensorInfo(maxLogitReshaped);
+    backend.disposeIntermediateTensorInfo(a);
+    backend.disposeIntermediateTensorInfo(b);
+    backend.disposeIntermediateTensorInfo(sumExp);
+    backend.disposeIntermediateTensorInfo(sumReshaped);
+    return result;
+}
+const softmaxConfig = {
+    kernelName: Softmax$1,
+    backendName: 'cpu',
+    kernelFunc: softmax
+};
+
+
+function multinomial(args) {
+    const { inputs, backend, attrs } = args;
+    const { logits } = inputs;
+    const { numSamples, seed, normalized } = attrs;
+    assertNotComplex(logits, 'multinomial');
+    const probabilities = normalized ?
+        logits :
+        softmax({ inputs: { logits }, backend, attrs: { dim: -1 } });
+    const batchSize = probabilities.shape[0];
+    const numEvents = probabilities.shape[1];
+    const probVals = backend.data.get(probabilities.dataId).values;
+    const resShape = [batchSize, numSamples];
+    const resVals = makeZerosTypedArray(sizeFromShape(resShape), 'int32');
+    for (let b = 0; b < batchSize; ++b) {
+        const offset = b * numEvents;
+        
+        
+        const cdf = new Float32Array(numEvents - 1);
+        cdf[0] = probVals[offset];
+        for (let event = 1; event < cdf.length; ++event) {
+            cdf[event] = cdf[event - 1] + probVals[offset + event];
+        }
+        const random = seedrandom.alea(seed.toString());
+        const outOffset = b * numSamples;
+        for (let sampleId = 0; sampleId < numSamples; ++sampleId) {
+            const r = random();
+            
+            resVals[outOffset + sampleId] = cdf.length;
+            for (let event = 0; event < cdf.length; event++) {
+                if (r < cdf[event]) {
+                    resVals[outOffset + sampleId] = event;
+                    break;
+                }
+            }
+        }
+    }
+    if (!normalized) {
+        backend.disposeIntermediateTensorInfo(probabilities);
+    }
+    return backend.makeTensorInfo(resShape, 'int32', resVals);
+}
+const multinomialConfig = {
+    kernelName: Multinomial,
+    backendName: 'cpu',
+    kernelFunc: multinomial
+};
+
+
+const nonMaxSuppressionV3Impl = nonMaxSuppressionV3Impl$2;
+function nonMaxSuppressionV3(args) {
+    const { inputs, backend, attrs } = args;
+    const { boxes, scores } = inputs;
+    const { maxOutputSize, iouThreshold, scoreThreshold } = attrs;
+    assertNotComplex(boxes, 'NonMaxSuppression');
+    const boxesVals = backend.data.get(boxes.dataId).values;
+    const scoresVals = backend.data.get(scores.dataId).values;
+    const { selectedIndices } = nonMaxSuppressionV3Impl(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold);
+    return backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices));
+}
+const nonMaxSuppressionV3Config = {
+    kernelName: NonMaxSuppressionV3,
+    backendName: 'cpu',
+    kernelFunc: nonMaxSuppressionV3
+};
+
+
+const nonMaxSuppressionV4Impl = nonMaxSuppressionV4Impl$2;
+function nonMaxSuppressionV4(args) {
+    const { inputs, backend, attrs } = args;
+    const { boxes, scores } = inputs;
+    const { maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize } = attrs;
+    assertNotComplex(boxes, 'NonMaxSuppressionPadded');
+    const boxesVals = backend.data.get(boxes.dataId).values;
+    const scoresVals = backend.data.get(scores.dataId).values;
+    const { selectedIndices, validOutputs } = nonMaxSuppressionV4Impl(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize);
+    return [
+        backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices)),
+        backend.makeTensorInfo([], 'int32', new Int32Array([validOutputs]))
+    ];
+}
+const nonMaxSuppressionV4Config = {
+    kernelName: NonMaxSuppressionV4,
+    backendName: 'cpu',
+    kernelFunc: nonMaxSuppressionV4
+};
+
+
+const nonMaxSuppressionV5Impl = nonMaxSuppressionV5Impl$2;
+function nonMaxSuppressionV5(args) {
+    const { inputs, backend, attrs } = args;
+    const { boxes, scores } = inputs;
+    const { maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma } = attrs;
+    assertNotComplex(boxes, 'NonMaxSuppressionWithScore');
+    const boxesVals = backend.data.get(boxes.dataId).values;
+    const scoresVals = backend.data.get(scores.dataId).values;
+    const maxOutputSizeVal = maxOutputSize;
+    const iouThresholdVal = iouThreshold;
+    const scoreThresholdVal = scoreThreshold;
+    const softNmsSigmaVal = softNmsSigma;
+    const { selectedIndices, selectedScores } = nonMaxSuppressionV5Impl(boxesVals, scoresVals, maxOutputSizeVal, iouThresholdVal, scoreThresholdVal, softNmsSigmaVal);
+    return [
+        backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices)),
+        backend.makeTensorInfo([selectedScores.length], 'float32', new Float32Array(selectedScores))
+    ];
+}
+const nonMaxSuppressionV5Config = {
+    kernelName: NonMaxSuppressionV5,
+    backendName: 'cpu',
+    kernelFunc: nonMaxSuppressionV5
+};
+
+
+function oneHot(args) {
+    const { inputs, backend, attrs } = args;
+    const { indices } = inputs;
+    const { dtype, depth, onValue, offValue } = attrs;
+    assertNotComplex(indices, 'oneHot');
+    const indicesSize = sizeFromShape(indices.shape);
+    const res = new Float32Array(indicesSize * depth);
+    res.fill(offValue);
+    const indicesVal = backend.data.get(indices.dataId).values;
+    for (let event = 0; event < indicesSize; ++event) {
+        if (indicesVal[event] >= 0 && indicesVal[event] < depth) {
+            res[event * depth + indicesVal[event]] = onValue;
+        }
+    }
+    return backend.makeTensorInfo([...indices.shape, depth], dtype, res);
+}
+const oneHotConfig = {
+    kernelName: OneHot,
+    backendName: 'cpu',
+    kernelFunc: oneHot
+};
+
+
+function zerosLike(args) {
+    const { inputs, backend } = args;
+    const { x } = inputs;
+    if (x.dtype === 'string') {
+        throw new Error('zerosLike is not supported for string tensors');
+    }
+    else if (x.dtype === 'complex64') {
+        const realPart = real$1({ inputs: { input: x }, backend });
+        const r = zerosLike({ inputs: { x: realPart }, backend });
+        const imagPart = imag({ inputs: { input: x }, backend });
+        const i = zerosLike({ inputs: { x: imagPart }, backend });
+        const result = complex$1({ inputs: { real: r, imag: i }, backend });
+        backend.disposeIntermediateTensorInfo(realPart);
+        backend.disposeIntermediateTensorInfo(r);
+        backend.disposeIntermediateTensorInfo(imagPart);
+        backend.disposeIntermediateTensorInfo(i);
+        return result;
+    }
+    else {
+        return fill({ backend, attrs: { shape: x.shape, value: 0, dtype: x.dtype } });
+    }
+}
+const zerosLikeConfig = {
+    kernelName: ZerosLike,
+    backendName: 'cpu',
+    kernelFunc: zerosLike
+};
+
+
+function onesLike(args) {
+    const { inputs, backend } = args;
+    const { x } = inputs;
+    if (x.dtype === 'string') {
+        throw new Error('onesLike is not supported for string tensors');
+    }
+    else if (x.dtype === 'complex64') {
+        const realPart = real$1({ inputs: { input: x }, backend });
+        const r = onesLike({ inputs: { x: realPart }, backend });
+        const imagPart = imag({ inputs: { input: x }, backend });
+        const i = zerosLike({ inputs: { x: imagPart }, backend });
+        const result = complex$1({ inputs: { real: r, imag: i }, backend });
+        backend.disposeIntermediateTensorInfo(realPart);
+        backend.disposeIntermediateTensorInfo(r);
+        backend.disposeIntermediateTensorInfo(imagPart);
+        backend.disposeIntermediateTensorInfo(i);
+        return result;
+    }
+    else {
+        return fill({ backend, attrs: { shape: x.shape, value: 1, dtype: x.dtype } });
+    }
+}
+const onesLikeConfig = {
+    kernelName: OnesLike,
+    backendName: 'cpu',
+    kernelFunc: onesLike
+};
+
+
+function pack(args) {
+    const { inputs, backend, attrs } = args;
+    const { axis } = attrs;
+    if (inputs.length === 1) {
+        return expandDims$1({ inputs: { input: inputs[0] }, backend, attrs: { dim: axis } });
+    }
+    const shape = inputs[0].shape;
+    const dtype = inputs[0].dtype;
+    inputs.forEach(t => {
+        assertShapesMatch(shape, t.shape, 'All tensors passed to stack must have matching shapes');
+        assert$1(dtype === t.dtype, () => 'All tensors passed to stack must have matching dtypes');
+    });
+    const intermediateTensorInfos = [];
+    const expandedTensors = inputs.map(t => {
+        const expandedT = expandDims$1({ inputs: { input: t }, backend, attrs: { dim: axis } });
+        intermediateTensorInfos.push(expandedT);
+        return expandedT;
+    });
+    const result = concat({ inputs: expandedTensors, backend, attrs: { axis } });
+    intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return result;
+}
+const packConfig = {
+    kernelName: Pack,
+    backendName: 'cpu',
+    kernelFunc: pack
+};
+
+
+function padV2(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { paddings, constantValue } = attrs;
+    assertNotComplex(x, 'pad');
+    const outShape = paddings.map((p, i) => p[0]  + x.shape[i] + p[1] );
+    const start = paddings.map(p => p[0]);
+    const xVals = backend.data.get(x.dataId).values;
+    const xSize = sizeFromShape(x.shape);
+    const xRank = x.shape.length;
+    const xStrides = computeStrides(x.shape);
+    const resultSize = sizeFromShape(outShape);
+    const resultRank = outShape.length;
+    const resultStrides = computeStrides(outShape);
+    const resVals = getTypedArrayFromDType(x.dtype, resultSize);
+    if (constantValue !== 0) {
+        resVals.fill(constantValue);
+    }
+    for (let i = 0; i < xSize; i++) {
+        const coords = indexToLoc(i, xRank, xStrides);
+        const outCoords = coords.map((c, i) => c + start[i]);
+        const outIndex = locToIndex(outCoords, resultRank, resultStrides);
+        resVals[outIndex] = xVals[i];
+    }
+    const outId = backend.write(resVals, outShape, x.dtype);
+    return { dataId: outId, shape: outShape, dtype: x.dtype };
+}
+const padV2Config = {
+    kernelName: PadV2,
+    backendName: 'cpu',
+    kernelFunc: padV2
+};
+
+
+const powImpl = createSimpleBinaryKernelImpl((a, b) => Math.pow(a, b));
+const pow = binaryKernelFunc$1(Pow, powImpl);
+const powConfig = {
+    kernelName: Pow,
+    backendName: 'cpu',
+    kernelFunc: pow
+};
+
+
+function raggedGather(args) {
+    const { inputs, backend} = args;
+    const { paramsNestedSplits, paramsDenseValues, indices } = inputs;
+    const $paramsNestedSplits = paramsNestedSplits.map(t => backend.data.get(t.dataId).values);
+    const $paramsNestedSplitsShapes = paramsNestedSplits.map(t => t.shape);
+    const $paramsDenseValues = backend.data.get(paramsDenseValues.dataId).values;
+    const $indices = backend.data.get(indices.dataId).values;
+    const [outputNestedSplits, outputDenseValues, outputDenseValuesShape] = raggedGatherImpl($paramsNestedSplits, $paramsNestedSplitsShapes, $paramsDenseValues, paramsDenseValues.shape, paramsDenseValues.dtype, $indices, indices.shape);
+    const outputNestedSplitsTensors = outputNestedSplits.map((splits) => backend.makeTensorInfo([splits.length], 'int32', splits));
+    const outputDenseValuesTensor = backend.makeTensorInfo(outputDenseValuesShape, paramsDenseValues.dtype, outputDenseValues);
+    return outputNestedSplitsTensors.concat([outputDenseValuesTensor]);
+}
+const raggedGatherConfig = {
+    kernelName: RaggedGather,
+    backendName: 'cpu',
+    kernelFunc: raggedGather,
+};
+
+
+function raggedRange(args) {
+    const { inputs, backend } = args;
+    const { starts, limits, deltas } = inputs;
+    const $starts = backend.data.get(starts.dataId).values;
+    const $limits = backend.data.get(limits.dataId).values;
+    const $deltas = backend.data.get(deltas.dataId).values;
+    const [rtNestedSplitsData, rtDenseValuesData] = raggedRangeImpl($starts, starts.shape, starts.dtype, $limits, limits.shape, $deltas, deltas.shape);
+    const rtNestedSplits = backend.makeTensorInfo([rtNestedSplitsData.length], 'int32', rtNestedSplitsData);
+    const rtDenseValues = backend.makeTensorInfo([rtDenseValuesData.length], starts.dtype, rtDenseValuesData);
+    return [rtNestedSplits, rtDenseValues];
+}
+const raggedRangeConfig = {
+    kernelName: RaggedRange,
+    backendName: 'cpu',
+    kernelFunc: raggedRange,
+};
+
+
+function raggedTensorToTensor(args) {
+    const { inputs, backend, attrs } = args;
+    const { shape, values, defaultValue, rowPartitionTensors } = inputs;
+    const { rowPartitionTypes } = attrs;
+    const $shape = backend.data.get(shape.dataId).values;
+    const $values = backend.data.get(values.dataId).values;
+    const $defaultValue = backend.data.get(defaultValue.dataId).values;
+    const $rowPartitionValues = rowPartitionTensors.map(t => backend.data.get(t.dataId).values);
+    const rowPartitionValuesShapes = rowPartitionTensors.map(t => t.shape);
+    const [outputShape, output] = raggedTensorToTensorImpl($shape, shape.shape, $values, values.shape, values.dtype, $defaultValue, defaultValue.shape, $rowPartitionValues, rowPartitionValuesShapes, rowPartitionTypes);
+    return backend.makeTensorInfo(outputShape, values.dtype, output);
+}
+const raggedTensorToTensorConfig = {
+    kernelName: RaggedTensorToTensor,
+    backendName: 'cpu',
+    kernelFunc: raggedTensorToTensor,
+};
+
+
+function range$1(args) {
+    const { backend, attrs } = args;
+    const { start, stop, dtype, step } = attrs;
+    const values = rangeImpl(start, stop, step, dtype);
+    return backend.makeTensorInfo([values.length], dtype, values);
+}
+const rangeConfig = {
+    kernelName: Range,
+    backendName: 'cpu',
+    kernelFunc: range$1
+};
+
+
+const reciprocal = unaryKernelFunc$1(Reciprocal, (xi) => 1 / xi);
+const reciprocalConfig = {
+    kernelName: Reciprocal,
+    backendName: 'cpu',
+    kernelFunc: reciprocal,
+};
+
+
+function resizeBilinear(args) {
+    const { inputs, backend, attrs } = args;
+    const { images } = inputs;
+    const { alignCorners, halfPixelCenters, size } = attrs;
+    assertNotComplex(images, 'resizeBilinear');
+    const imagesStrides = computeStrides(images.shape);
+    const [newHeight, newWidth] = size;
+    const [batch, oldHeight, oldWidth, numChannels] = images.shape;
+    const xValues = backend.data.get(images.dataId).values;
+    const result = new Float32Array(sizeFromShape([batch, newHeight, newWidth, numChannels]));
+    const effectiveInputSize = [
+        (alignCorners && newHeight > 1) ? oldHeight - 1 : oldHeight,
+        (alignCorners && newWidth > 1) ? oldWidth - 1 : oldWidth
+    ];
+    const effectiveOutputSize = [
+        (alignCorners && newHeight > 1) ? newHeight - 1 : newHeight,
+        (alignCorners && newWidth > 1) ? newWidth - 1 : newWidth
+    ];
+    let outputIdx = 0;
+    const effectiveRowSizeRatio = effectiveInputSize[0] / effectiveOutputSize[0];
+    const effectiveColSizeRatio = effectiveInputSize[1] / effectiveOutputSize[1];
+    for (let b = 0; b < batch; b++) {
+        for (let r = 0; r < newHeight; r++) {
+            let sourceFracRow;
+            if (halfPixelCenters) {
+                sourceFracRow = effectiveRowSizeRatio * (r + 0.5) - 0.5;
+            }
+            else {
+                sourceFracRow = effectiveRowSizeRatio * r;
+            }
+            const sourceRowFloor = Math.max(0, Math.floor(sourceFracRow));
+            const rowFrac = sourceFracRow - sourceRowFloor;
+            const sourceRowCeil = Math.min(oldHeight - 1, Math.ceil(sourceFracRow));
+            const topRowOffset = b * imagesStrides[0] + sourceRowFloor * imagesStrides[1];
+            const botRowOffset = b * imagesStrides[0] + sourceRowCeil * imagesStrides[1];
+            for (let c = 0; c < newWidth; c++) {
+                let sourceFracCol;
+                if (halfPixelCenters) {
+                    sourceFracCol = effectiveColSizeRatio * (c + 0.5) - 0.5;
+                }
+                else {
+                    sourceFracCol = effectiveColSizeRatio * c;
+                }
+                const sourceColFloor = Math.max(0, Math.floor(sourceFracCol));
+                const colFrac = sourceFracCol - sourceColFloor;
+                const sourceColCeil = Math.min(oldWidth - 1, Math.ceil(sourceFracCol));
+                const topLeftOffest = topRowOffset + sourceColFloor * imagesStrides[2];
+                const botLeftOffset = botRowOffset + sourceColFloor * imagesStrides[2];
+                const topRightOffset = topRowOffset + sourceColCeil * imagesStrides[2];
+                const botRightOffest = botRowOffset + sourceColCeil * imagesStrides[2];
+                for (let d = 0; d < numChannels; d++) {
+                    
+                    
+                    const topLeft = xValues[topLeftOffest + d];
+                    const bottomLeft = xValues[botLeftOffset + d];
+                    const topRight = xValues[topRightOffset + d];
+                    const bottomRight = xValues[botRightOffest + d];
+                    const top = topLeft + (topRight - topLeft) * colFrac;
+                    const bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac;
+                    const newValue = top + (bottom - top) * rowFrac;
+                    result[outputIdx++] = newValue;
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo([batch, newHeight, newWidth, numChannels], 'float32', result);
+}
+const resizeBilinearConfig = {
+    kernelName: ResizeBilinear,
+    backendName: 'cpu',
+    kernelFunc: resizeBilinear
+};
+
+
+function resizeBilinearGrad(args) {
+    const { inputs, backend, attrs } = args;
+    const { images, dy } = inputs;
+    const { alignCorners } = attrs;
+    assertNotComplex([dy, images], 'resizeBilinearGrad');
+    const imagesStrides = computeStrides(images.shape);
+    const [batch, xHeight, xWidth, depth] = images.shape;
+    const [, yHeight, yWidth] = dy.shape;
+    const output = new Float32Array(batch * xHeight * xWidth * depth);
+    
+    
+    
+    
+    const effectiveXSize = [
+        (alignCorners && yHeight > 1) ? xHeight - 1 : xHeight,
+        (alignCorners && yWidth > 1) ? xWidth - 1 : xWidth
+    ];
+    const effectiveYSize = [
+        (alignCorners && yHeight > 1) ? yHeight - 1 : yHeight,
+        (alignCorners && yWidth > 1) ? yWidth - 1 : yWidth
+    ];
+    const heightScale = effectiveXSize[0] / effectiveYSize[0];
+    const widthScale = effectiveXSize[1] / effectiveYSize[1];
+    
+    
+    
+    const dyValues = backend.data.get(dy.dataId).values;
+    let offset = 0;
+    for (let b = 0; b < batch; b++) {
+        const bOffset = b * imagesStrides[0];
+        for (let r = 0; r < yHeight; r++) {
+            const dxR = r * heightScale;
+            const topDxRIndex = Math.floor(dxR);
+            const bottomDxRIndex = Math.min(Math.ceil(dxR), xHeight - 1);
+            const topDxROffset = bOffset + topDxRIndex * imagesStrides[1];
+            const bottomDxROffset = bOffset + bottomDxRIndex * imagesStrides[1];
+            const dxRLerp = dxR - topDxRIndex;
+            const inverseDxRLerp = 1.0 - dxRLerp;
+            for (let c = 0; c < yWidth; c++) {
+                const dxC = c * widthScale;
+                const leftDxCIndex = Math.floor(dxC);
+                const rightDxCIndex = Math.min(Math.ceil(dxC), xWidth - 1);
+                const dxCLerp = dxC - leftDxCIndex;
+                const inverseDxCLerp = 1.0 - dxCLerp;
+                const topLeftRCOffset = topDxROffset + leftDxCIndex * imagesStrides[2];
+                const topRightRCOffset = topDxROffset + rightDxCIndex * imagesStrides[2];
+                const bottomLeftRCOffset = bottomDxROffset + leftDxCIndex * imagesStrides[2];
+                const bottomRightRCOffset = bottomDxROffset + rightDxCIndex * imagesStrides[2];
+                const inverseDxRLerpTimesInverseDxCLerp = inverseDxRLerp * inverseDxCLerp;
+                const inverseDxRLerpTimesDxCLerp = inverseDxRLerp * dxCLerp;
+                const dxRLerpTimesInverseDxCLerp = dxRLerp * inverseDxCLerp;
+                const dxRLerpTimesDxCLerp = dxRLerp * dxCLerp;
+                for (let d = 0; d < depth; d++) {
+                    const dyVal = dyValues[offset++];
+                    output[topLeftRCOffset + d] +=
+                        dyVal * inverseDxRLerpTimesInverseDxCLerp;
+                    output[topRightRCOffset + d] += dyVal * inverseDxRLerpTimesDxCLerp;
+                    output[bottomLeftRCOffset + d] += dyVal * dxRLerpTimesInverseDxCLerp;
+                    output[bottomRightRCOffset + d] += dyVal * dxRLerpTimesDxCLerp;
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo([batch, xWidth, xHeight, depth], 'float32', output);
+}
+const resizeBilinearGradConfig$1 = {
+    kernelName: ResizeBilinearGrad,
+    backendName: 'cpu',
+    kernelFunc: resizeBilinearGrad
+};
+
+
+function resizeNearestNeighbor(args) {
+    const { inputs, backend, attrs } = args;
+    const { images } = inputs;
+    const { alignCorners, halfPixelCenters, size } = attrs;
+    assertNotComplex(images, 'resizeNearestNeighbor');
+    const imagesStrides = computeStrides(images.shape);
+    const [newHeight, newWidth] = size;
+    const [batch, oldHeight, oldWidth, numChannels] = images.shape;
+    const xValues = backend.data.get(images.dataId).values;
+    const output = new Float32Array(batch * newHeight * newWidth * numChannels);
+    const effectiveInputSize = [
+        (alignCorners && newHeight > 1) ? oldHeight - 1 : oldHeight,
+        (alignCorners && newWidth > 1) ? oldWidth - 1 : oldWidth
+    ];
+    const effectiveOutputSize = [
+        (alignCorners && newHeight > 1) ? newHeight - 1 : newHeight,
+        (alignCorners && newWidth > 1) ? newWidth - 1 : newWidth
+    ];
+    const effectiveRowSizeRatio = effectiveInputSize[0] / effectiveOutputSize[0];
+    const effectiveColSizeRatio = effectiveInputSize[1] / effectiveOutputSize[1];
+    let outputOffset = 0;
+    for (let b = 0; b < batch; b++) {
+        const batchOffset = b * imagesStrides[0];
+        for (let r = 0; r < newHeight; r++) {
+            const sourceFracRow = halfPixelCenters ?
+                effectiveRowSizeRatio * (r + 0.5) :
+                effectiveRowSizeRatio * r;
+            let sourceNearestRow = Math.min(oldHeight - 1, alignCorners ? Math.round(sourceFracRow) : Math.floor(sourceFracRow));
+            if (halfPixelCenters) {
+                sourceNearestRow = Math.max(0, sourceNearestRow);
+            }
+            const rowOffset = batchOffset + sourceNearestRow * imagesStrides[1];
+            for (let c = 0; c < newWidth; c++) {
+                const sourceFracCol = halfPixelCenters ?
+                    effectiveColSizeRatio * (c + 0.5) :
+                    effectiveColSizeRatio * c;
+                let sourceNearestCol = Math.min(oldWidth - 1, alignCorners ? Math.round(sourceFracCol) :
+                    Math.floor(sourceFracCol));
+                if (halfPixelCenters) {
+                    sourceNearestCol = Math.max(0, sourceNearestCol);
+                }
+                const colOffset = rowOffset + sourceNearestCol * imagesStrides[2];
+                for (let d = 0; d < numChannels; d++) {
+                    
+                    
+                    const newVal = xValues[colOffset + d];
+                    output[outputOffset++] = newVal;
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo([batch, newHeight, newWidth, numChannels], images.dtype, output);
+}
+const resizeNearestNeighborConfig = {
+    kernelName: ResizeNearestNeighbor,
+    backendName: 'cpu',
+    kernelFunc: resizeNearestNeighbor
+};
+
+
+function resizeNearestNeighborGrad(args) {
+    const { inputs, backend, attrs } = args;
+    const { images, dy } = inputs;
+    const { alignCorners } = attrs;
+    assertNotComplex([dy, images], 'resizeNearestNeighborGrad');
+    const imagesStrides = computeStrides(images.shape);
+    const dyStrides = computeStrides(dy.shape);
+    const [batch, xHeight, xWidth, depth] = images.shape;
+    const [, yHeight, yWidth] = dy.shape;
+    const output = new Float32Array(batch * xHeight * xWidth * depth);
+    const dyValues = backend.data.get(dy.dataId).values;
+    
+    
+    const effectiveXSize = [
+        (alignCorners && yHeight > 1) ? xHeight - 1 : xHeight,
+        (alignCorners && yWidth > 1) ? xWidth - 1 : xWidth
+    ];
+    const effectiveYSize = [
+        (alignCorners && yHeight > 1) ? yHeight - 1 : yHeight,
+        (alignCorners && yWidth > 1) ? yWidth - 1 : yWidth
+    ];
+    const heightScale = effectiveXSize[0] / effectiveYSize[0];
+    const widthScale = effectiveXSize[1] / effectiveYSize[1];
+    const invHeightScale = 1 / heightScale;
+    const invWidthScale = 1 / widthScale;
+    
+    
+    const winHeight = (Math.ceil(invHeightScale) * 2) + 2;
+    const winWidth = (Math.ceil(invWidthScale) * 2) + 2;
+    
+    for (let b = 0; b < batch; b++) {
+        const batchOffset = b * imagesStrides[0];
+        for (let r = 0; r < xHeight; r++) {
+            const rowOffset = batchOffset + r * imagesStrides[1];
+            
+            const startRLerp = Math.floor(r * invHeightScale);
+            const startDyR = Math.floor(startRLerp - (winHeight / 2));
+            for (let c = 0; c < xWidth; c++) {
+                const colOffset = rowOffset + c * imagesStrides[2];
+                
+                const startCLerp = Math.floor(c * invWidthScale);
+                const startDyC = Math.floor(startCLerp - (winWidth / 2));
+                for (let d = 0; d < depth; d++) {
+                    let accum = 0;
+                    
+                    for (let dyRIndex = 0; dyRIndex < winHeight; dyRIndex++) {
+                        const dyR = dyRIndex + startDyR;
+                        
+                        if (dyR < 0 || dyR >= yHeight) {
+                            continue;
+                        }
+                        const dyROffset = batchOffset + dyR * dyStrides[1];
+                        const sourceFracRow = dyR * heightScale;
+                        const sourceNearestRow = Math.min(xHeight - 1, alignCorners ? Math.round(sourceFracRow) :
+                            Math.floor(sourceFracRow));
+                        if (r !== sourceNearestRow) {
+                            continue;
+                        }
+                        for (let dyCIndex = 0; dyCIndex < winWidth; dyCIndex++) {
+                            const dyC = dyCIndex + startDyC;
+                            
+                            if (dyC < 0 || dyC >= yWidth) {
+                                continue;
+                            }
+                            const dyCOffset = dyROffset + dyC * dyStrides[2];
+                            const sourceFracCol = dyC * widthScale;
+                            const sourceNearestCol = Math.min(xWidth - 1, alignCorners ? Math.round(sourceFracCol) :
+                                Math.floor(sourceFracCol));
+                            if (c === sourceNearestCol) {
+                                accum += dyValues[dyCOffset + d];
+                            }
+                        }
+                    }
+                    output[colOffset + d] = accum;
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(images.shape, images.dtype, output);
+}
+const resizeNearestNeighborGradConfig$1 = {
+    kernelName: ResizeNearestNeighborGrad,
+    backendName: 'cpu',
+    kernelFunc: resizeNearestNeighborGrad
+};
+
+
+function reverse(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { dims } = attrs;
+    assertNotComplex(x, 'reverse');
+    const xRank = x.shape.length;
+    const $dims = parseAxisParam(dims, x.shape);
+    if (xRank === 0) {
+        return identity$1({ inputs: { x }, backend });
+    }
+    const outBuf = new TensorBuffer(x.shape, x.dtype);
+    const xBuf = backend.bufferSync(x);
+    for (let i = 0; i < outBuf.size; i++) {
+        const outLoc = outBuf.indexToLoc(i);
+        const inLoc = outLoc.slice();
+        $dims.forEach(d => inLoc[d] = x.shape[d] - 1 - inLoc[d]);
+        outBuf.set(xBuf.get(...inLoc), ...outLoc);
+    }
+    return backend.makeTensorInfo(outBuf.shape, outBuf.dtype, outBuf.values);
+}
+const reverseConfig = {
+    kernelName: Reverse,
+    backendName: 'cpu',
+    kernelFunc: reverse
+};
+
+
+const rotateWithOffsetConfig = {
+    kernelName: RotateWithOffset,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, attrs, backend }) => {
+        const { image } = inputs;
+        const { radians, fillValue, center } = attrs;
+        const cpuBackend = backend;
+        const output = getTypedArrayFromDType(image.dtype, sizeFromShape(image.shape));
+        const [batch, imageHeight, imageWidth, numChannels] = image.shape;
+        const [centerX, centerY] = getImageCenter(center, imageHeight, imageWidth);
+        const fullOpacityValue = 255;
+        const sinFactor = Math.sin(radians);
+        const cosFactor = Math.cos(radians);
+        const imageVals = cpuBackend.data.get(image.dataId).values;
+        for (let batchIdx = 0; batchIdx < batch; batchIdx++) {
+            const batchOffset = batchIdx * imageWidth * imageHeight * numChannels;
+            for (let row = 0; row < imageHeight; row++) {
+                const rowOffset = row * (imageWidth * numChannels);
+                for (let col = 0; col < imageWidth; col++) {
+                    const colOffset = col * numChannels;
+                    for (let channel = 0; channel < numChannels; channel++) {
+                        const coords = [batch, row, col, channel];
+                        const x = coords[2];
+                        const y = coords[1];
+                        
+                        let coordX = (x - centerX) * cosFactor - (y - centerY) * sinFactor;
+                        let coordY = (x - centerX) * sinFactor + (y - centerY) * cosFactor;
+                        coordX = Math.round(coordX + centerX);
+                        coordY = Math.round(coordY + centerY);
+                        let outputValue = fillValue;
+                        if (typeof fillValue !== 'number') {
+                            if (channel === 3) {
+                                outputValue = fullOpacityValue;
+                            }
+                            else {
+                                outputValue = fillValue[channel];
+                            }
+                        }
+                        
+                        if (coordX >= 0 && coordX < imageWidth && coordY >= 0 &&
+                            coordY < imageHeight) {
+                            
+                            const rotatedRowOffset = coordY * (imageWidth * numChannels);
+                            const rotatedColOffset = coordX * numChannels;
+                            const imageIdx = batchOffset + rotatedRowOffset + rotatedColOffset + channel;
+                            outputValue = imageVals[imageIdx];
+                        }
+                        const outIdx = batchOffset + rowOffset + colOffset + channel;
+                        output[outIdx] = outputValue;
+                    }
+                }
+            }
+        }
+        const dataId = cpuBackend.write(output, image.shape, image.dtype);
+        return { dataId, shape: image.shape, dtype: image.dtype };
+    }
+};
+
+
+const round = unaryKernelFunc$1(Round, (xi) => {
+    
+    const base = Math.floor(xi);
+    if (xi - base < 0.5) {
+        return Math.floor(xi);
+    }
+    else if (xi - base > 0.5) {
+        return Math.ceil(xi);
+    }
+    else {
+        if (base % 2.0 === 0.0) {
+            return base;
+        }
+        else {
+            return base + 1.0;
+        }
+    }
+});
+const roundConfig = {
+    kernelName: Round,
+    backendName: 'cpu',
+    kernelFunc: round,
+};
+
+
+function scatterNd(args) {
+    const { inputs, backend, attrs } = args;
+    const { indices, updates } = inputs;
+    const { shape } = attrs;
+    const { sliceRank, numUpdates, sliceSize, strides, outputSize } = calculateShapes(updates, indices, shape);
+    const sumDupeIndices = true;
+    const indicesBuf = backend.bufferSync(indices);
+    const updatesBuf = backend.bufferSync(updates);
+    const outBuf = scatterImpl(indicesBuf, updatesBuf, shape, outputSize, sliceSize, numUpdates, sliceRank, strides, 0 , sumDupeIndices);
+    return backend.makeTensorInfo(shape, outBuf.dtype, outBuf.values);
+}
+const scatterNdConfig = {
+    kernelName: ScatterNd,
+    backendName: 'cpu',
+    kernelFunc: scatterNd
+};
+
+
+function lowerBound(array, value) {
+    let left = 0;
+    let right = array.length;
+    let mid = 0;
+    while (left < right) {
+        mid = Math.floor((left + right) / 2);
+        if (array[mid] < value) {
+            left = mid + 1;
+        }
+        else {
+            right = mid;
+        }
+    }
+    return right;
+}
+function upperBound(array, value) {
+    let left = 0;
+    let right = array.length;
+    let mid = 0;
+    while (left < right) {
+        mid = Math.floor((left + right) / 2);
+        if (array[mid] <= value) {
+            left = mid + 1;
+        }
+        else {
+            right = mid;
+        }
+    }
+    return right;
+}
+function searchSortedImpl(sortedInputs, values, batchSize, numInputs, numValues, side) {
+    const output = getArrayFromDType('int32', batchSize * numValues);
+    for (let b = 0; b < batchSize; ++b) {
+        const sortedInputsSlice = sortedInputs.slice(b * numInputs, (b + 1) * numInputs);
+        const outputOffset = b * numValues;
+        for (let i = 0; i < numValues; ++i) {
+            output[outputOffset + i] = side === 'left' ?
+                lowerBound(sortedInputsSlice, values[i + outputOffset]) :
+                upperBound(sortedInputsSlice, values[i + outputOffset]);
+        }
+    }
+    return output;
+}
+
+
+function searchSorted(args) {
+    const { inputs, backend, attrs } = args;
+    const { sortedSequence, values } = inputs;
+    const { side } = attrs;
+    const $sortedSequence = backend.data.get(sortedSequence.dataId).values;
+    const $values = backend.data.get(values.dataId).values;
+    const output = searchSortedImpl($sortedSequence, $values, sortedSequence.shape[0], sortedSequence.shape[1], values.shape[1], side);
+    return backend.makeTensorInfo(values.shape, 'int32', output);
+}
+const searchSortedConfig = {
+    kernelName: SearchSorted,
+    backendName: 'cpu',
+    kernelFunc: searchSorted,
+};
+
+
+function select(args) {
+    const { inputs, backend } = args;
+    const { condition, t, e } = inputs;
+    assertNotComplex([condition, t, e], 'select');
+    const conditionRank = condition.shape.length;
+    const values = backend.data.get(condition.dataId).values;
+    const tValues = backend.data.get(t.dataId).values;
+    const eValues = backend.data.get(e.dataId).values;
+    const resultDtype = upcastType(t.dtype, e.dtype);
+    const newValues = makeZerosTypedArray(sizeFromShape(t.shape), resultDtype);
+    let index = 0;
+    const offset = conditionRank === 0 || conditionRank > 1 || t.shape.length === 1 ?
+        1 :
+        sizeFromShape(t.shape.slice(1));
+    for (let i = 0; i < values.length; i++) {
+        for (let j = 0; j < offset; j++) {
+            if (values[i] === 1) {
+                newValues[index++] = tValues[i];
+            }
+            else {
+                newValues[index++] = eValues[i];
+            }
+        }
+    }
+    return backend.makeTensorInfo(t.shape, resultDtype, newValues);
+}
+const selectConfig = {
+    kernelName: Select,
+    backendName: 'cpu',
+    kernelFunc: select
+};
+
+
+const scaleAlpha = SELU_SCALEALPHA;
+const scale = SELU_SCALE;
+const selu = unaryKernelFunc$1(Selu$1, (xi) => {
+    if (xi >= 0) {
+        return scale * xi;
+    }
+    else {
+        return scaleAlpha * (Math.exp(xi) - 1);
+    }
+});
+const seluConfig = {
+    kernelName: Selu$1,
+    backendName: 'cpu',
+    kernelFunc: selu,
+};
+
+
+const sign = unaryKernelFunc$1(Sign, (xi) => {
+    if (xi < 0) {
+        return -1;
+    }
+    else if (xi > 0) {
+        return 1;
+    }
+    else {
+        return 0;
+    }
+});
+const signConfig = {
+    kernelName: Sign,
+    backendName: 'cpu',
+    kernelFunc: sign,
+};
+
+
+const sin = unaryKernelFunc$1(Sin, (xi) => Math.sin(xi));
+const sinConfig = {
+    kernelName: Sin,
+    backendName: 'cpu',
+    kernelFunc: sin,
+};
+
+
+const sinh = unaryKernelFunc$1(Sinh, (xi) => Math.sinh(xi));
+const sinhConfig = {
+    kernelName: Sinh,
+    backendName: 'cpu',
+    kernelFunc: sinh,
+};
+
+
+
+
+
+
+const epsilon$1 = 1.1920928955078125e-7;
+const threshold = Math.log(epsilon$1) + 2.0;
+const softplus = unaryKernelFunc$1(Softplus$1, (xi) => {
+    
+    
+    const tooLarge = xi > -threshold;
+    
+    
+    const tooSmall = xi < threshold;
+    const expX = Math.exp(xi);
+    let result;
+    if (tooSmall) {
+        result = expX;
+    }
+    else if (tooLarge) {
+        result = xi;
+    }
+    else {
+        result = Math.log(1.0 + expX);
+    }
+    return result;
+});
+const softplusConfig = {
+    kernelName: Softplus$1,
+    backendName: 'cpu',
+    kernelFunc: softplus,
+};
+
+
+function spaceToBatchND(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { blockShape, paddings } = attrs;
+    assertNotComplex([x], 'spaceToBatchND');
+    const prod = sizeFromShape(blockShape);
+    const completePaddings = [[0, 0]];
+    completePaddings.push(...paddings);
+    for (let i = 1 + blockShape.length; i < x.shape.length; ++i) {
+        completePaddings.push([0, 0]);
+    }
+    const paddedX = padV2Config.kernelFunc({
+        inputs: { x },
+        backend,
+        attrs: { paddings: completePaddings, constantValue: 0 }
+    });
+    const reshapedPaddedShape = getReshaped(paddedX.shape, blockShape, prod, false);
+    const permutedReshapedPaddedPermutation = getPermuted(reshapedPaddedShape.length, blockShape.length, false);
+    const flattenShape = getReshapedPermuted(paddedX.shape, blockShape, prod, false);
+    const reshapeInputs = { x: paddedX };
+    const reshapeAttrs = { shape: reshapedPaddedShape };
+    const paddedXReshaped = reshape({ inputs: reshapeInputs, backend, attrs: reshapeAttrs });
+    const transposeInputs = { x: paddedXReshaped };
+    const transposeAttrs = { perm: permutedReshapedPaddedPermutation };
+    const paddedXT = transpose$1({ inputs: transposeInputs, backend, attrs: transposeAttrs });
+    const resultReshapeInputs = { x: paddedXT };
+    const resultReshapeAttrs = { shape: flattenShape };
+    const result = reshape({ inputs: resultReshapeInputs, backend, attrs: resultReshapeAttrs });
+    backend.disposeIntermediateTensorInfo(paddedX);
+    backend.disposeIntermediateTensorInfo(paddedXReshaped);
+    backend.disposeIntermediateTensorInfo(paddedXT);
+    return result;
+}
+const spaceToBatchNDConfig = {
+    kernelName: SpaceToBatchND,
+    backendName: 'cpu',
+    kernelFunc: spaceToBatchND
+};
+
+
+function sparseFillEmptyRows(args) {
+    const { inputs, backend } = args;
+    const { indices, values, denseShape, defaultValue } = inputs;
+    if (denseShape.shape.length !== 1) {
+        throw new Error(`Dense shape must be a vector, saw:
+        ${denseShape.shape}`);
+    }
+    if (indices.shape.length !== 2) {
+        throw new Error(`Indices must be a matrix, saw:
+        ${indices.shape}`);
+    }
+    if (values.shape.length !== 1) {
+        throw new Error(`Values must be a vector, saw:
+        ${values.shape}`);
+    }
+    if (defaultValue.shape.length !== 0) {
+        throw new Error(`Default value must be a scalar, saw:
+        ${defaultValue.shape}`);
+    }
+    const $indices = backend.data.get(indices.dataId).values;
+    const $values = backend.data.get(values.dataId).values;
+    const $denseShape = backend.data.get(denseShape.dataId).values;
+    const $defaultValue = backend.data.get(defaultValue.dataId).values[0];
+    const [outputIndices, outputIndicesShape, outputValues, emptyRowIndicator, reverseIndexMap] = sparseFillEmptyRowsImpl($indices, indices.shape, indices.dtype, $values, values.dtype, $denseShape, $defaultValue);
+    return [
+        backend.makeTensorInfo(outputIndicesShape, indices.dtype, outputIndices),
+        backend.makeTensorInfo([outputIndicesShape[0]], values.dtype, outputValues),
+        backend.makeTensorInfo([emptyRowIndicator.length], 'bool', new Uint8Array(emptyRowIndicator.map((value) => Number(value)))),
+        backend.makeTensorInfo([reverseIndexMap.length], indices.dtype, new Int32Array(reverseIndexMap)),
+    ];
+}
+const sparseFillEmptyRowsConfig = {
+    kernelName: SparseFillEmptyRows,
+    backendName: 'cpu',
+    kernelFunc: sparseFillEmptyRows,
+};
+
+
+function sparseReshape(args) {
+    const { inputs, backend } = args;
+    const { inputIndices, inputShape, newShape } = inputs;
+    if (inputIndices.shape.length !== 2) {
+        throw new Error(`Input indices should be a matrix but received shape
+        ${inputIndices.shape}`);
+    }
+    if (inputShape.shape.length !== 1) {
+        throw new Error(`Input shape should be a vector but received shape
+        ${inputShape.shape}`);
+    }
+    if (newShape.shape.length !== 1) {
+        throw new Error(`Target shape should be a vector but received shape ${newShape.shape}`);
+    }
+    const $inputShape = Array.from(backend.data.get(inputShape.dataId).values);
+    const $inputIndices = backend.data.get(inputIndices.dataId).values;
+    const targetShape = Array.from(backend.data.get(newShape.dataId).values);
+    const [newIndices, indicesShape, outputShape] = sparseReshapeImpl($inputIndices, inputIndices.shape, inputIndices.dtype, $inputShape, targetShape);
+    return [
+        backend.makeTensorInfo(indicesShape, inputIndices.dtype, newIndices),
+        backend.makeTensorInfo([outputShape.length], newShape.dtype, new Int32Array(outputShape)),
+    ];
+}
+const sparseReshapeConfig = {
+    kernelName: SparseReshape,
+    backendName: 'cpu',
+    kernelFunc: sparseReshape,
+};
+
+
+function sparseSegmentMean(args) {
+    const { inputs, backend } = args;
+    const { data, indices, segmentIds } = inputs;
+    if (data.shape.length < 1) {
+        throw new Error(`Data should be at least 1 dimensional but received scalar`);
+    }
+    if (indices.shape.length !== 1) {
+        throw new Error(`Indices should be a vector but received shape
+          ${indices.shape}`);
+    }
+    if (segmentIds.shape.length !== 1) {
+        throw new Error(`Segment ids should be a vector but received shape
+          ${segmentIds.shape}`);
+    }
+    if (indices.shape[0] !== segmentIds.shape[0]) {
+        throw new Error(`segmentIds and indices should have same size.`);
+    }
+    const $data = backend.data.get(data.dataId).values;
+    const $indices = backend.data.get(indices.dataId).values;
+    const $segmentIds = backend.data.get(segmentIds.dataId).values;
+    const [outputData, outputDataShape] = sparseSegmentReductionImpl($data, data.shape, data.dtype, $indices, $segmentIds, true);
+    return backend.makeTensorInfo(outputDataShape, data.dtype, outputData);
+}
+const sparseSegmentMeanConfig = {
+    kernelName: SparseSegmentMean,
+    backendName: 'cpu',
+    kernelFunc: sparseSegmentMean,
+};
+
+
+function sparseSegmentSum(args) {
+    const { inputs, backend } = args;
+    const { data, indices, segmentIds } = inputs;
+    if (data.shape.length < 1) {
+        throw new Error(`Data should be at least 1 dimensional but received scalar`);
+    }
+    if (indices.shape.length !== 1) {
+        throw new Error(`Indices should be a vector but received shape
+         ${indices.shape}`);
+    }
+    if (segmentIds.shape.length !== 1) {
+        throw new Error(`Segment ids should be a vector but received shape
+         ${segmentIds.shape}`);
+    }
+    if (indices.shape[0] !== segmentIds.shape[0]) {
+        throw new Error(`segmentIds and indices should have same size.`);
+    }
+    const $data = backend.data.get(data.dataId).values;
+    const $indices = backend.data.get(indices.dataId).values;
+    const $segmentIds = backend.data.get(segmentIds.dataId).values;
+    const [outputData, outputDataShape] = sparseSegmentReductionImpl($data, data.shape, data.dtype, $indices, $segmentIds);
+    return backend.makeTensorInfo(outputDataShape, data.dtype, outputData);
+}
+const sparseSegmentSumConfig = {
+    kernelName: SparseSegmentSum,
+    backendName: 'cpu',
+    kernelFunc: sparseSegmentSum,
+};
+
+
+function sparseToDense(args) {
+    const { inputs, backend, attrs } = args;
+    const { sparseIndices, sparseValues, defaultValue } = inputs;
+    const { outputShape } = attrs;
+    const { sliceRank, numUpdates, sliceSize, strides, outputSize } = calculateShapes(sparseValues, sparseIndices, outputShape);
+    const sumDupeIndices = false;
+    const indicesBuf = backend.bufferSync(sparseIndices);
+    let outBuf;
+    switch (sparseValues.dtype) {
+        case 'bool': {
+            const updatesBuf = backend.bufferSync(sparseValues);
+            const $defaultValue = Boolean(backend.data.get(defaultValue.dataId).values[0]);
+            outBuf = scatterImpl(indicesBuf, updatesBuf, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, $defaultValue, sumDupeIndices);
+            break;
+        }
+        case 'float32': {
+            const updatesBuf = backend.bufferSync(sparseValues);
+            const $defaultValue = backend.data.get(defaultValue.dataId).values[0];
+            outBuf = scatterImpl(indicesBuf, updatesBuf, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, $defaultValue, sumDupeIndices);
+            break;
+        }
+        case 'int32': {
+            const updatesBuf = backend.bufferSync(sparseValues);
+            const $defaultValue = backend.data.get(defaultValue.dataId).values[0];
+            outBuf = scatterImpl(indicesBuf, updatesBuf, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, $defaultValue, sumDupeIndices);
+            break;
+        }
+        case 'string': {
+            const updatesBuf = backend.bufferSync(sparseValues);
+            const $defaultValue = decodeString(backend.data.get(defaultValue.dataId).values[0]);
+            outBuf = scatterImpl(indicesBuf, updatesBuf, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, $defaultValue, sumDupeIndices);
+            break;
+        }
+        default:
+            throw new Error(`Unsupported type ${sparseValues.dtype}`);
+    }
+    return backend.makeTensorInfo(outputShape, outBuf.dtype, outBuf.values);
+}
+const sparseToDenseConfig = {
+    kernelName: SparseToDense,
+    backendName: 'cpu',
+    kernelFunc: sparseToDense
+};
+
+
+function splitV(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { numOrSizeSplits, axis } = attrs;
+    const $axis = parseAxisParam(axis, x.shape)[0];
+    const splitSizes = prepareSplitSize(x, numOrSizeSplits, $axis);
+    const begin = new Array(x.shape.length).fill(0);
+    const size = x.shape.slice();
+    return splitSizes.map(s => {
+        const sliceSize = [...size];
+        sliceSize[$axis] = s;
+        const sliceT = slice$1({ inputs: { x }, backend, attrs: { begin, size: sliceSize } });
+        begin[$axis] += s;
+        return sliceT;
+    });
+}
+const splitVConfig = {
+    kernelName: SplitV,
+    backendName: 'cpu',
+    kernelFunc: splitV
+};
+
+
+const squareConfig = {
+    kernelName: Square,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, backend }) => {
+        const { x } = inputs;
+        const cpuBackend = backend;
+        assertNotComplex(x, 'square');
+        const values = cpuBackend.data.get(x.dataId).values;
+        const newValues = new Float32Array(values.length);
+        for (let i = 0; i < values.length; ++i) {
+            const value = values[i];
+            newValues[i] = value * value;
+        }
+        const dataId = cpuBackend.write(newValues, x.shape, x.dtype);
+        return { dataId, shape: x.shape, dtype: x.dtype };
+    }
+};
+
+
+const step = unaryKernelFunc$1(Step, (xi, attrs) => {
+    const stepAttrs = attrs;
+    if (isNaN(xi)) {
+        return NaN;
+    }
+    else {
+        return xi > 0 ? 1 : stepAttrs.alpha;
+    }
+});
+const stepConfig = {
+    kernelName: Step,
+    backendName: 'cpu',
+    kernelFunc: step,
+};
+
+
+function stridedSlice(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { begin, end, strides, beginMask, endMask, ellipsisMask, newAxisMask, shrinkAxisMask } = attrs;
+    assertNotComplex(x, 'stridedSlice');
+    const { finalShapeSparse, finalShape, isIdentity, sliceDim0, isSimpleSlice, begin: $begin, end: $end, strides: $strides } = sliceInfo(x.shape, begin, end, strides, beginMask, endMask, ellipsisMask, newAxisMask, shrinkAxisMask);
+    let result;
+    
+    
+    if (isIdentity) {
+        
+        result = reshape({ inputs: { x }, backend, attrs: { shape: finalShape } });
+    }
+    else if (sliceDim0 || isSimpleSlice) {
+        
+        assert$1(x.shape.length >= 1, () => `Input must have rank at least 1, got: ${x.shape.length}`);
+        const size = computeOutShape$2($begin, $end, $strides);
+        
+        const sliced = slice$1({ inputs: { x }, backend, attrs: { begin: $begin, size } });
+        result =
+            reshape({ inputs: { x: sliced }, backend, attrs: { shape: finalShape } });
+        backend.disposeIntermediateTensorInfo(sliced);
+    }
+    else {
+        const xBuf = backend.bufferSync(x);
+        const outBuf = stridedSliceImpl(finalShapeSparse, xBuf, $strides, $begin);
+        result = backend.makeTensorInfo(finalShape, outBuf.dtype, outBuf.values);
+    }
+    return result;
+}
+const stridedSliceConfig = {
+    kernelName: StridedSlice,
+    backendName: 'cpu',
+    kernelFunc: stridedSlice
+};
+
+
+function stringNGrams(args) {
+    const { inputs, backend, attrs } = args;
+    const { separator, nGramWidths, leftPad, rightPad, padWidth, preserveShortSequences } = attrs;
+    const { data, dataSplits } = inputs;
+    const $data = backend.data.get(data.dataId).values;
+    const $dataSplits = backend.data.get(dataSplits.dataId).values;
+    const [nGrams, nGramsSplits] = stringNGramsImpl($data, $dataSplits, separator, nGramWidths, leftPad, rightPad, padWidth, preserveShortSequences);
+    return [
+        backend.makeTensorInfo([nGrams.length], 'string', nGrams),
+        backend.makeTensorInfo(dataSplits.shape, 'int32', nGramsSplits),
+    ];
+}
+const stringNGramsConfig = {
+    kernelName: StringNGrams,
+    backendName: 'cpu',
+    kernelFunc: stringNGrams,
+};
+
+
+function stringSplit(args) {
+    const { inputs, backend, attrs } = args;
+    const { skipEmpty } = attrs;
+    const { input, delimiter } = inputs;
+    if (input.dtype !== 'string') {
+        throw new Error('Input must be of datatype string');
+    }
+    if (input.shape.length !== 1) {
+        throw new Error(`Input must be a vector, got shape: ${input.shape}`);
+    }
+    if (delimiter.shape.length !== 0) {
+        throw new Error(`Delimiter must be a scalar, got shape: ${delimiter.shape}`);
+    }
+    const $input = backend.data.get(input.dataId).values;
+    const $delimiter = backend.data.get(delimiter.dataId).values[0];
+    const [indices, values, shape] = stringSplitImpl($input, $delimiter, skipEmpty);
+    const outputSize = values.length;
+    return [
+        backend.makeTensorInfo([outputSize, 2], 'int32', indices),
+        backend.makeTensorInfo([outputSize], 'string', values),
+        backend.makeTensorInfo([2], 'int32', new Int32Array(shape))
+    ];
+}
+const stringSplitConfig = {
+    kernelName: StringSplit,
+    backendName: 'cpu',
+    kernelFunc: stringSplit,
+};
+
+
+function stringToHashBucketFast(args) {
+    const { inputs, backend, attrs } = args;
+    const { numBuckets } = attrs;
+    const { input } = inputs;
+    if (input.dtype !== 'string') {
+        throw new Error('Input must be of datatype string');
+    }
+    if (numBuckets <= 0) {
+        throw new Error(`Number of buckets must be at least 1`);
+    }
+    const $input = backend.data.get(input.dataId).values;
+    const output = stringToHashBucketFastImpl($input, numBuckets);
+    return backend.makeTensorInfo(input.shape, 'int32', output);
+}
+const stringToHashBucketFastConfig = {
+    kernelName: StringToHashBucketFast,
+    backendName: 'cpu',
+    kernelFunc: stringToHashBucketFast,
+};
+
+
+const tan = unaryKernelFunc$1(Tan, (xi) => Math.tan(xi));
+const tanConfig = {
+    kernelName: Tan,
+    backendName: 'cpu',
+    kernelFunc: tan,
+};
+
+
+const tanh = unaryKernelFunc$1(Tanh$1, (xi) => Math.tanh(xi));
+const tanhConfig = {
+    kernelName: Tanh$1,
+    backendName: 'cpu',
+    kernelFunc: tanh,
+};
+
+
+function tensorScatterUpdate(args) {
+    const { inputs, backend } = args;
+    const { tensor, indices, updates } = inputs;
+    const { sliceRank, numUpdates, sliceSize, strides, outputSize } = calculateShapes(updates, indices, tensor.shape);
+    const sumDupeIndices = false;
+    const indicesBuf = backend.bufferSync(indices);
+    const updatesBuf = backend.bufferSync(updates);
+    const tensorBuf = backend.bufferSync(tensor);
+    const outBuf = scatterImpl(indicesBuf, updatesBuf, tensor.shape, outputSize, sliceSize, numUpdates, sliceRank, strides, tensorBuf, sumDupeIndices);
+    return backend.makeTensorInfo(tensor.shape, outBuf.dtype, outBuf.values);
+}
+const tensorScatterUpdateConfig = {
+    kernelName: TensorScatterUpdate,
+    backendName: 'cpu',
+    kernelFunc: tensorScatterUpdate
+};
+
+
+function tile$1(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { reps } = attrs;
+    assertNotComplex(x, 'tile');
+    const outBuf = tileImpl(backend.bufferSync(x), reps);
+    return backend.makeTensorInfo(outBuf.shape, outBuf.dtype, outBuf.values);
+}
+const tileConfig = {
+    kernelName: Tile,
+    backendName: 'cpu',
+    kernelFunc: tile$1
+};
+
+
+function topK(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { k, sorted } = attrs;
+    assertNotComplex(x, 'topk');
+    const xVals = backend.data.get(x.dataId).values;
+    const [allTopKVals, allTopKIndices] = topKImpl(xVals, x.shape, x.dtype, k, sorted);
+    return [
+        backend.makeTensorInfo(allTopKVals.shape, allTopKVals.dtype, allTopKVals.values),
+        backend.makeTensorInfo(allTopKIndices.shape, allTopKIndices.dtype, allTopKIndices.values)
+    ];
+}
+const topKConfig = {
+    kernelName: TopK,
+    backendName: 'cpu',
+    kernelFunc: topK
+};
+
+
+function transform(args) {
+    const { inputs, attrs, backend } = args;
+    const { image, transforms } = inputs;
+    const { interpolation, fillMode, fillValue, outputShape } = attrs;
+    const [batch, imageHeight, imageWidth, numChannels] = image.shape;
+    const [outHeight, outWidth] = outputShape != null ? outputShape : [imageHeight, imageWidth];
+    const outShape = [batch, outHeight, outWidth, numChannels];
+    const inStrides = computeStrides(image.shape);
+    const batchInStride = inStrides[0];
+    const rowInStride = inStrides[1];
+    const colInStride = inStrides[2];
+    const outStrides = computeStrides(outShape);
+    const batchOutStride = outStrides[0];
+    const rowOutStride = outStrides[1];
+    const colOutStride = outStrides[2];
+    const outVals = getTypedArrayFromDType(image.dtype, sizeFromShape(outShape));
+    outVals.fill(fillValue);
+    const imageVals = backend.data.get(image.dataId).values;
+    const transformVals = backend.data.get(transforms.dataId).values;
+    
+    
+    for (let b = 0; b < batch; ++b) {
+        const transform = transforms.shape[0] === 1 ?
+            transformVals :
+            transformVals.subarray(b * 8, b * 8 + 8);
+        for (let outY = 0; outY < outHeight; ++outY) {
+            for (let outX = 0; outX < outWidth; ++outX) {
+                for (let channel = 0; channel < numChannels; ++channel) {
+                    let val;
+                    const projection = transform[6] * outX + transform[7] * outY + 1;
+                    if (projection === 0) {
+                        
+                        
+                        continue;
+                    }
+                    const inX = (transform[0] * outX + transform[1] * outY + transform[2]) /
+                        projection;
+                    const inY = (transform[3] * outX + transform[4] * outY + transform[5]) /
+                        projection;
+                    const x = mapCoord(inX, imageWidth, fillMode);
+                    const y = mapCoord(inY, imageHeight, fillMode);
+                    switch (interpolation) {
+                        case 'nearest':
+                            val = nearestInterpolation(imageVals, imageHeight, imageWidth, batchInStride, rowInStride, colInStride, b, y, x, channel, fillValue);
+                            break;
+                        case 'bilinear':
+                            val = bilinearInterpolation(imageVals, imageHeight, imageWidth, batchInStride, rowInStride, colInStride, b, y, x, channel, fillValue);
+                            break;
+                        default:
+                            throw new Error(`Error in Transform: Expect 'nearest' or ` +
+                                `'bilinear', but got ${interpolation}`);
+                    }
+                    const ind = b * batchOutStride + outY * rowOutStride +
+                        outX * colOutStride + channel;
+                    outVals[ind] = val;
+                }
+            }
+        }
+        return backend.makeTensorInfo(outShape, image.dtype, outVals);
+    }
+    const dataId = backend.write(outVals, outShape, image.dtype);
+    return { dataId, shape: image.shape, dtype: image.dtype };
+}
+const transformConfig = {
+    kernelName: Transform,
+    backendName: 'cpu',
+    kernelFunc: transform
+};
+function mapCoord(outCoord, len, mode) {
+    switch (mode) {
+        case 'reflect':
+            return mapCoordReflect(outCoord, len);
+        case 'wrap':
+            return mapCoordWrap(outCoord, len);
+        case 'nearest':
+            return mapCoordNearest(outCoord, len);
+        case 'constant':
+        default:
+            return mapCoordConstant(outCoord);
+    }
+}
+function mapCoordReflect(outCoord, len) {
+    
+    let inCoord = outCoord;
+    if (inCoord < 0) {
+        if (len <= 1) {
+            inCoord = 0;
+        }
+        else {
+            const sz2 = 2 * len;
+            if (inCoord < sz2) {
+                inCoord = sz2 * Math.trunc(-inCoord / sz2) + inCoord;
+            }
+            inCoord = inCoord < -len ? inCoord + sz2 : -inCoord - 1;
+        }
+    }
+    else if (inCoord > len - 1) {
+        if (len <= 1) {
+            inCoord = 0;
+        }
+        else {
+            const sz2 = 2 * len;
+            inCoord -= sz2 * Math.trunc(inCoord / sz2);
+            if (inCoord >= len) {
+                inCoord = sz2 - inCoord - 1;
+            }
+        }
+    }
+    
+    
+    return clamp(0, inCoord, len - 1);
+}
+function mapCoordWrap(outCoord, len) {
+    
+    let inCoord = outCoord;
+    if (inCoord < 0) {
+        if (len <= 1) {
+            inCoord = 0;
+        }
+        else {
+            const sz = len - 1;
+            inCoord += len * (Math.trunc(-inCoord / sz) + 1);
+        }
+    }
+    else if (inCoord > len - 1) {
+        if (len <= 1) {
+            inCoord = 0;
+        }
+        else {
+            const sz = len - 1;
+            inCoord -= len * Math.trunc(inCoord / sz);
+        }
+    }
+    
+    
+    return clamp(0, inCoord, len - 1);
+}
+function mapCoordConstant(outCoord, len) {
+    return outCoord;
+}
+function mapCoordNearest(outCoord, len) {
+    return clamp(0, outCoord, len - 1);
+}
+function readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, y, x, channel, fillValue) {
+    const ind = batch * batchStride + y * rowStride + x * colStride + channel;
+    if (0 <= y && y < imageHeight && 0 <= x && x < imageWidth) {
+        return imageVals[ind];
+    }
+    else {
+        return fillValue;
+    }
+}
+function nearestInterpolation(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, y, x, channel, fillValue) {
+    const $y = Math.round(y);
+    const $x = Math.round(x);
+    return readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, $y, $x, channel, fillValue);
+}
+function bilinearInterpolation(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, y, x, channel, fillValue) {
+    const yFloor = Math.floor(y);
+    const xFloor = Math.floor(x);
+    const yCeil = yFloor + 1;
+    const xCeil = xFloor + 1;
+    
+    
+    const valueYFloor = (xCeil - x) *
+        readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, yFloor, xFloor, channel, fillValue) +
+        (x - xFloor) *
+            readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, yFloor, xCeil, channel, fillValue);
+    
+    
+    const valueYCeil = (xCeil - x) *
+        readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, yCeil, xFloor, channel, fillValue) +
+        (x - xFloor) *
+            readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, yCeil, xCeil, channel, fillValue);
+    
+    
+    return (yCeil - y) * valueYFloor + (y - yFloor) * valueYCeil;
+}
+
+
+function unique$1(args) {
+    const { inputs, attrs, backend } = args;
+    const { axis } = attrs;
+    const { x } = inputs;
+    assertNotComplex(x, 'unique');
+    const values = backend.data.get(x.dataId).values;
+    const { outputValues, outputShape, indices } = uniqueImpl(values, axis, x.shape, x.dtype);
+    return [
+        backend.makeTensorInfo(outputShape, x.dtype, outputValues),
+        backend.makeTensorInfo([indices.length], 'int32', indices),
+    ];
+}
+const uniqueConfig = {
+    kernelName: Unique,
+    backendName: 'cpu',
+    kernelFunc: unique$1,
+};
+
+
+function unpack(args) {
+    const { inputs, backend, attrs } = args;
+    const { value } = inputs;
+    let { axis } = attrs;
+    if (axis < 0) {
+        axis += value.shape.length;
+    }
+    const valueRank = value.shape.length;
+    const num = value.shape[axis];
+    const outShape = new Array(valueRank - 1);
+    let outIndex = 0;
+    for (let i = 0; i < valueRank; i++) {
+        if (i !== axis) {
+            outShape[outIndex++] = value.shape[i];
+        }
+    }
+    const begin = new Array(valueRank).fill(0);
+    const size = value.shape.slice();
+    size[axis] = 1;
+    const res = new Array(num);
+    for (let i = 0; i < res.length; i++) {
+        begin[axis] = i;
+        const tempRes = slice$1({ inputs: { x: value }, backend, attrs: { begin, size } });
+        res[i] = reshape({ inputs: { x: tempRes }, backend, attrs: { shape: outShape } });
+        backend.disposeIntermediateTensorInfo(tempRes);
+    }
+    return res;
+}
+const unpackConfig = {
+    kernelName: Unpack,
+    backendName: 'cpu',
+    kernelFunc: unpack
+};
+
+
+function unsortedSegmentSum(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, segmentIds } = inputs;
+    const { numSegments } = attrs;
+    assertNotComplex(x, 'unsortedSegmentSum');
+    const xRank = x.shape.length;
+    const segmentIdsRank = segmentIds.shape.length;
+    const res = [];
+    const intermediates = [];
+    
+    
+    const numIters = xRank - segmentIdsRank;
+    let $segmentIds = segmentIds;
+    for (let i = 0; i < numIters; ++i) {
+        const expanded = expandDims$1({ inputs: { input: $segmentIds }, backend, attrs: { dim: i + 1 } });
+        $segmentIds = expanded;
+        intermediates.push(expanded);
+    }
+    for (let i = 0; i < numSegments; ++i) {
+        const scalarValue = createScalarValue(i, 'int32');
+        const segmentId = backend.makeTensorInfo([], 'int32', scalarValue);
+        const mask = equal$1({ inputs: { a: segmentId, b: $segmentIds }, backend });
+        const maskCasted = cast$2({ inputs: { x: mask }, backend, attrs: { dtype: 'float32' } });
+        const mul = multiply$1({ inputs: { a: maskCasted, b: x }, backend });
+        const sumTensorInfo = sum({ inputs: { x: mul }, backend, attrs: { axis: 0, keepDims: false } });
+        res.push(sumTensorInfo);
+        intermediates.push(segmentId);
+        intermediates.push(mask);
+        intermediates.push(maskCasted);
+        intermediates.push(mul);
+        intermediates.push(sumTensorInfo);
+    }
+    const result = pack({ inputs: res, backend, attrs: { axis: 0 } });
+    intermediates.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return result;
+}
+const unsortedSegmentSumConfig = {
+    kernelName: UnsortedSegmentSum,
+    backendName: 'cpu',
     kernelFunc: unsortedSegmentSum
 };
 
 
 
+
+
+
 const kernelConfigs = [
     _fusedMatMulConfig,
-    absConfig,
+    absConfig$1,
     acosConfig,
     acoshConfig,
-    addConfig,
+    addConfig$1,
     addNConfig,
     allConfig,
     anyConfig,
@@ -29238,12 +35335,12 @@ const kernelConfigs = [
     batchNormConfig,
     batchToSpaceNDConfig,
     bincountConfig,
-    bitwiseAndConfig,
+    bitwiseAndConfig$1,
     broadcastArgsConfig,
-    castConfig,
-    ceilConfig,
+    castConfig$1,
+    ceilConfig$1,
     clipByValueConfig,
-    complexConfig,
+    complexConfig$1,
     complexAbsConfig,
     concatConfig,
     conv2DConfig,
@@ -29251,7 +35348,7 @@ const kernelConfigs = [
     conv2DBackpropInputConfig,
     conv3DConfig,
     conv3DBackpropFilterV2Config,
-    conv3DBackpropInputConfig,
+    conv3DBackpropInputV2Config,
     cosConfig,
     coshConfig,
     cropAndResizeConfig,
@@ -29264,37 +35361,39 @@ const kernelConfigs = [
     depthwiseConv2dNativeBackpropInputConfig,
     diagConfig,
     dilation2DConfig,
+    dilation2DBackpropFilterConfig,
+    dilation2DBackpropInputConfig,
+    drawConfig,
     einsumConfig,
     eluConfig,
     eluGradConfig$1,
-    equalConfig,
+    equalConfig$1,
     erfConfig,
-    expConfig,
+    expConfig$1,
     expandDimsConfig,
-    expm1Config,
+    expm1Config$1,
     fftConfig,
     fillConfig,
     flipLeftRightConfig,
-    floorConfig,
-    floorDivConfig,
-    fromPixelsConfig,
+    floorConfig$1,
+    floorDivConfig$1,
     fusedConv2DConfig,
     fusedDepthwiseConv2DConfig,
     gatherNdConfig,
     gatherV2Config,
-    greaterConfig,
-    greaterEqualConfig,
-    identityConfig,
+    greaterConfig$1,
+    greaterEqualConfig$1,
+    identityConfig$1,
     ifftConfig,
     imagConfig,
     isFiniteConfig,
     isInfConfig,
     isNaNConfig,
     leakyReluConfig,
-    lessConfig,
-    lessEqualConfig,
+    lessConfig$1,
+    lessEqualConfig$1,
     linSpaceConfig,
-    logConfig,
+    logConfig$1,
     log1pConfig,
     logicalAndConfig,
     logicalNotConfig,
@@ -29302,7 +35401,7 @@ const kernelConfigs = [
     LRNConfig,
     LRNGradConfig,
     maxConfig,
-    maximumConfig,
+    maximumConfig$1,
     maxPoolConfig,
     maxPool3DConfig,
     maxPool3DGradConfig$1,
@@ -29310,28 +35409,28 @@ const kernelConfigs = [
     maxPoolWithArgmaxConfig,
     meanConfig,
     minConfig,
-    minimumConfig,
+    minimumConfig$1,
     mirrorPadConfig,
     modConfig,
     multinomialConfig,
-    multiplyConfig,
-    negConfig,
+    multiplyConfig$1,
+    negConfig$1,
     nonMaxSuppressionV3Config,
     nonMaxSuppressionV4Config,
     nonMaxSuppressionV5Config,
-    notEqualConfig,
+    notEqualConfig$1,
     oneHotConfig,
     onesLikeConfig,
     packConfig,
     padV2Config,
     powConfig,
     preluConfig,
-    prodConfig,
+    prodConfig$1,
     raggedGatherConfig,
     raggedRangeConfig,
     raggedTensorToTensorConfig,
     rangeConfig,
-    realConfig,
+    realConfig$1,
     realDivConfig,
     reciprocalConfig,
     reluConfig,
@@ -29344,16 +35443,16 @@ const kernelConfigs = [
     reverseConfig,
     rotateWithOffsetConfig,
     roundConfig,
-    rsqrtConfig,
+    rsqrtConfig$1,
     scatterNdConfig,
     searchSortedConfig,
     selectConfig,
     seluConfig,
-    sigmoidConfig,
+    sigmoidConfig$1,
     signConfig,
     sinConfig,
     sinhConfig,
-    sliceConfig,
+    sliceConfig$1,
     softmaxConfig,
     softplusConfig,
     spaceToBatchNDConfig,
@@ -29363,16 +35462,16 @@ const kernelConfigs = [
     sparseSegmentSumConfig,
     sparseToDenseConfig,
     splitVConfig,
-    sqrtConfig,
+    sqrtConfig$1,
     squareConfig,
-    squaredDifferenceConfig,
-    staticRegexReplaceConfig,
+    squaredDifferenceConfig$1,
+    staticRegexReplaceConfig$1,
     stepConfig,
     stridedSliceConfig,
     stringNGramsConfig,
     stringSplitConfig,
     stringToHashBucketFastConfig,
-    subConfig,
+    subConfig$1,
     sumConfig,
     tanConfig,
     tanhConfig,
@@ -29380,7 +35479,7 @@ const kernelConfigs = [
     tileConfig,
     topKConfig,
     transformConfig,
-    transposeConfig,
+    transposeConfig$1,
     uniqueConfig,
     unpackConfig,
     unsortedSegmentSumConfig,
@@ -29396,7 +35495,7 @@ const absGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(dy, step$1(cast$2(x, 'float32'), -1)) };
+        return { x: () => mul(dy, step$2(cast$3(x, 'float32'), -1)) };
     }
 };
 
@@ -29408,9 +35507,9 @@ const acosGradConfig = {
         const [x] = saved;
         return {
             x: () => {
-                const a = square$2(cast$2(x, 'float32'));
-                const b = sqrt$1(sub$1(scalar(1), a));
-                return neg$1(div(dy, b));
+                const a = square$2(cast$3(x, 'float32'));
+                const b = sqrt$2(sub$2(scalar(1), a));
+                return neg$2(div$1(dy, b));
             }
         };
     }
@@ -29424,8 +35523,8 @@ const acoshGradConfig = {
         const [x] = saved;
         return {
             x: () => {
-                const a = sqrt$1(sub$1(square$2(cast$2(x, 'float32')), 1));
-                return div(dy, a);
+                const a = sqrt$2(sub$2(square$2(cast$3(x, 'float32')), 1));
+                return div$1(dy, a);
             }
         };
     }
@@ -29442,17 +35541,17 @@ const addGradConfig = {
             let res = dy;
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, a.shape);
+            return reshape$2(res, a.shape);
         };
         const derB = () => {
             let res = dy;
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, b.shape);
+            return reshape$2(res, b.shape);
         };
         return { a: derA, b: derB };
     }
@@ -29477,7 +35576,7 @@ const argMaxGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => zerosLike$1(x) };
+        return { x: () => zerosLike$2(x) };
     }
 };
 
@@ -29487,7 +35586,7 @@ const argMinGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => zerosLike$1(x) };
+        return { x: () => zerosLike$2(x) };
     }
 };
 
@@ -29497,7 +35596,7 @@ const asinGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, sqrt$1(sub$1(scalar(1), square$2(cast$2(x, 'float32'))))) };
+        return { x: () => div$1(dy, sqrt$2(sub$2(scalar(1), square$2(cast$3(x, 'float32'))))) };
     }
 };
 
@@ -29509,8 +35608,8 @@ const asinhGradConfig = {
         const [x] = saved;
         return {
             x: () => {
-                const a = sqrt$1(add(scalar(1), square$2(cast$2(x, 'float32'))));
-                return div(dy, a);
+                const a = sqrt$2(add$1(scalar(1), square$2(cast$3(x, 'float32'))));
+                return div$1(dy, a);
             }
         };
     }
@@ -29524,22 +35623,22 @@ const atan2GradConfig = {
         const [a, b] = saved;
         const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
         const derA = () => {
-            const d = add(square$2(a), square$2(b));
-            let res = mul(dy, div(b, d));
+            const d = add$1(square$2(a), square$2(b));
+            let res = mul(dy, div$1(b, d));
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, a.shape);
+            return reshape$2(res, a.shape);
         };
         const derB = () => {
-            const d = add(square$2(a), square$2(b));
-            let res = neg$1(mul(dy, div(a, d)));
+            const d = add$1(square$2(a), square$2(b));
+            let res = neg$2(mul(dy, div$1(a, d)));
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, b.shape);
+            return reshape$2(res, b.shape);
         };
         return { a: derA, b: derB };
     }
@@ -29551,7 +35650,7 @@ const atanGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, add(square$2(cast$2(x, 'float32')), 1)) };
+        return { x: () => div$1(dy, add$1(square$2(cast$3(x, 'float32')), 1)) };
     }
 };
 
@@ -29561,7 +35660,7 @@ const atanhGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, sub$1(scalar(1), square$2(cast$2(x, 'float32')))) };
+        return { x: () => div$1(dy, sub$2(scalar(1), square$2(cast$3(x, 'float32')))) };
     }
 };
 
@@ -29575,8 +35674,8 @@ function avgPool3dGrad_(dy, input, filterSize, strides, pad, dimRoundingMode) {
     let reshapedTo5D = false;
     if ($input.rank === 4) {
         reshapedTo5D = true;
-        dy5D = reshape$1($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2], $dy.shape[3]]);
-        input5D = reshape$1($input, [
+        dy5D = reshape$2($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2], $dy.shape[3]]);
+        input5D = reshape$2($input, [
             1, $input.shape[0], $input.shape[1], $input.shape[2], $input.shape[3]
         ]);
     }
@@ -29590,7 +35689,7 @@ function avgPool3dGrad_(dy, input, filterSize, strides, pad, dimRoundingMode) {
     
     const res = ENGINE.runKernel(AvgPool3DGrad, inputs, attrs);
     if (reshapedTo5D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
     }
     return res;
 }
@@ -29621,8 +35720,8 @@ function avgPoolGrad_(dy, input, filterSize, strides, pad) {
     if ($input.rank === 3) {
         reshapedTo4D = true;
         input4D =
-            reshape$1($input, [1, $input.shape[0], $input.shape[1], $input.shape[2]]);
-        dy4D = reshape$1($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2]]);
+            reshape$2($input, [1, $input.shape[0], $input.shape[1], $input.shape[2]]);
+        dy4D = reshape$2($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2]]);
     }
     assert$1(dy4D.rank === 4, () => `Error in avgPoolGrad: dy must be rank 4 but got rank ` +
         `${dy4D.rank}.`);
@@ -29633,7 +35732,7 @@ function avgPoolGrad_(dy, input, filterSize, strides, pad) {
     
     const res = ENGINE.runKernel(AvgPoolGrad, inputs, attrs);
     if (reshapedTo4D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3]]);
     }
     return res;
 }
@@ -29689,7 +35788,7 @@ const batchToSpaceNDGradConfig = {
     kernelName: BatchToSpaceND,
     gradFunc: (dy, saved, attrs) => {
         const { blockShape, crops } = attrs;
-        return { x: () => spaceToBatchND$1(dy, blockShape, crops) };
+        return { x: () => spaceToBatchND$2(dy, blockShape, crops) };
     }
 };
 
@@ -29715,7 +35814,7 @@ const broadcastToGradConfig = {
                 axes.push(i);
             }
         }
-        return { x: () => sum$1(dy, axes, true ) };
+        return { x: () => sum$2(dy, axes, true ) };
     }
 };
 
@@ -29732,7 +35831,7 @@ const ceilGradConfig = {
     kernelName: Ceil,
     gradFunc: (dy) => {
         
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -29744,7 +35843,7 @@ const clipByValueGradConfig = {
         const [x] = saved;
         const { clipValueMin, clipValueMax } = attrs;
         return {
-            x: () => where(logicalAnd$1(greaterEqual$1(x, clipValueMin), lessEqual$1(x, clipValueMax)), dy, zerosLike$1(dy)),
+            x: () => where(logicalAnd$2(greaterEqual$2(x, clipValueMin), lessEqual$2(x, clipValueMax)), dy, zerosLike$2(dy)),
         };
     }
 };
@@ -29780,8 +35879,8 @@ const conv2DGradConfig = {
         assert$1(tupleValuesAreOne(dilations), () => 'Error in gradient of conv2D: dilation rates greater than 1 ' +
             `are not yet supported in gradients. Got dilations '${dilations}'`);
         return {
-            x: () => conv2DBackpropInput$1(x4D.shape, dy, $filter, strides, pad, dataFormat),
-            filter: () => conv2DBackpropFilter$1(x4D, dy, $filter.shape, strides, pad, dataFormat)
+            x: () => conv2DBackpropInput$2(x4D.shape, dy, $filter, strides, pad, dataFormat),
+            filter: () => conv2DBackpropFilter$2(x4D, dy, $filter.shape, strides, pad, dataFormat)
         };
     }
 };
@@ -29795,7 +35894,7 @@ const conv2DBackpropInputGradConfig = {
         const { strides, pad, dataFormat, dimRoundingMode } = attrs;
         return {
             dy: () => conv2d$1(ddx, filter, strides, pad, dataFormat, 1 , dimRoundingMode),
-            filter: () => conv2DBackpropFilter$1(ddx, dy, filter.shape, strides, pad, dataFormat, dimRoundingMode)
+            filter: () => conv2DBackpropFilter$2(ddx, dy, filter.shape, strides, pad, dataFormat, dimRoundingMode)
         };
     }
 };
@@ -29805,11 +35904,11 @@ const conv2DBackpropInputGradConfig = {
 function conv3DBackpropFilter_(x, dy, filterShape, strides, pad) {
     let x5D = x;
     if (x.rank === 4) {
-        x5D = reshape$1(x, [1, x.shape[0], x.shape[1], x.shape[2], x.shape[3]]);
+        x5D = reshape$2(x, [1, x.shape[0], x.shape[1], x.shape[2], x.shape[3]]);
     }
     let dy5D = dy;
     if (dy5D.rank === 4) {
-        dy5D = reshape$1(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
+        dy5D = reshape$2(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
     }
     assert$1(x5D.rank === 5, () => `Error in conv3dDerFilter: input must be rank 5, but got shape ` +
         `${x5D.shape}.`);
@@ -29850,7 +35949,7 @@ const cosGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(neg$1(sin$1(cast$2(x, 'float32'))), dy) };
+        return { x: () => mul(neg$2(sin$2(cast$3(x, 'float32'))), dy) };
     }
 };
 
@@ -29860,7 +35959,7 @@ const coshGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(sinh$1(cast$2(x, 'float32')), dy) };
+        return { x: () => mul(sinh$2(cast$3(x, 'float32')), dy) };
     }
 };
 
@@ -29874,9 +35973,9 @@ const cumsumGradConfig = {
         return {
             x: () => {
                 const permutation = getAxesPermutation([axis], x.rank);
-                let out = cumsum$1(dy, axis, exclusive, !reverse);
+                let out = cumsum$2(dy, axis, exclusive, !reverse);
                 if (permutation != null) {
-                    out = transpose$1(out, permutation);
+                    out = transpose$2(out, permutation);
                 }
                 return out;
             }
@@ -29907,8 +36006,8 @@ const depthwiseConv2dNativeGradConfig = {
             `'${$dilations}'.`);
         checkPadOnDimRoundingMode('depthwiseConv2d', pad, dimRoundingMode);
         return {
-            x: () => depthwiseConv2dNativeBackpropInput$1(x.shape, dy, filter, strides, pad, $dilations, dimRoundingMode),
-            filter: () => depthwiseConv2dNativeBackpropFilter$1(x, dy, filter.shape, strides, pad, $dilations, dimRoundingMode),
+            x: () => depthwiseConv2dNativeBackpropInput$2(x.shape, dy, filter, strides, pad, $dilations, dimRoundingMode),
+            filter: () => depthwiseConv2dNativeBackpropFilter$2(x, dy, filter.shape, strides, pad, $dilations, dimRoundingMode),
         };
     }
 };
@@ -29945,7 +36044,7 @@ const erfGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        const a = mul(exp$1(neg$1(square$2(x))), 2 / Math.sqrt(Math.PI));
+        const a = mul(exp$2(neg$2(square$2(x))), 2 / Math.sqrt(Math.PI));
         return { x: () => mul(dy, a) };
     }
 };
@@ -29966,7 +36065,7 @@ const expandDimsGradConfig = {
     inputsToSave: ['input'],
     gradFunc: (dy, saved) => {
         const [input] = saved;
-        return { input: () => reshape$1(dy, input.shape) };
+        return { input: () => reshape$2(dy, input.shape) };
     }
 };
 
@@ -29976,7 +36075,7 @@ const expm1GradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(dy, exp$1(x)) };
+        return { x: () => mul(dy, exp$2(x)) };
     }
 };
 
@@ -29984,7 +36083,7 @@ const expm1GradConfig = {
 const floorGradConfig = {
     kernelName: Floor,
     gradFunc: (dy) => {
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -29996,21 +36095,21 @@ const floorDivGradConfig = {
         const [a, b] = saved;
         const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
         const derA = () => {
-            const res = div(dy, cast$2(b, 'float32'));
+            const res = div$1(dy, cast$3(b, 'float32'));
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                return reshape$1(sum$1(res, reduceAxes), a.shape);
+                return reshape$2(sum$2(res, reduceAxes), a.shape);
             }
             return res;
         };
         const derB = () => {
-            let res = mul(dy, cast$2(a, 'float32'));
+            let res = mul(dy, cast$3(a, 'float32'));
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = reshape$1(sum$1(res, reduceAxes), b.shape);
+                res = reshape$2(sum$2(res, reduceAxes), b.shape);
             }
             const tmp = square$2(b);
-            return neg$1(div(res, cast$2(tmp, 'float32')));
+            return neg$2(div$1(res, cast$3(tmp, 'float32')));
         };
         return { a: derA, b: derB };
     }
@@ -30032,46 +36131,46 @@ const fusedBatchNormGradConfig = {
             }
             tileShape.push(1);
         }
-        const xMinusMean = sub$1(x, mean);
+        const xMinusMean = sub$2(x, mean);
         const dyTimesScaleValue = mul(dy, scaleValue);
-        const oneOverSqrtVariance = rsqrt$1(add(variance, scalar(varianceEpsilon)));
+        const oneOverSqrtVariance = rsqrt$2(add$1(variance, scalar(varianceEpsilon)));
         const minusHalfRCube = mul(mul(mul(oneOverSqrtVariance, oneOverSqrtVariance), oneOverSqrtVariance), scalar(-0.5));
         const derX = () => {
             if (mean.rank === 1) {
-                return reshape$1(mul(mul(dy, tile$2(reshape$1(oneOverSqrtVariance, [1, 1, 1, mean.shape[0]]), tileShape)), scaleValue), x.shape);
+                return reshape$2(mul(mul(dy, tile$3(reshape$2(oneOverSqrtVariance, [1, 1, 1, mean.shape[0]]), tileShape)), scaleValue), x.shape);
             }
             else {
-                return reshape$1(mul(mul(dy, oneOverSqrtVariance), scaleValue), x.shape);
+                return reshape$2(mul(mul(dy, oneOverSqrtVariance), scaleValue), x.shape);
             }
         };
         const derMean = () => {
             let meanDer = mul(mul(oneOverSqrtVariance, scalar(-1)), dyTimesScaleValue);
             if (mean.rank === 1) {
-                meanDer = sum$1(meanDer, reductionAxes);
+                meanDer = sum$2(meanDer, reductionAxes);
             }
-            return reshape$1(meanDer, mean.shape);
+            return reshape$2(meanDer, mean.shape);
         };
         const derVariance = () => {
             let varianceDer = mul(mul(minusHalfRCube, xMinusMean), dyTimesScaleValue);
             if (mean.rank === 1) {
-                varianceDer = sum$1(varianceDer, reductionAxes);
+                varianceDer = sum$2(varianceDer, reductionAxes);
             }
-            return reshape$1(varianceDer, mean.shape);
+            return reshape$2(varianceDer, mean.shape);
         };
         const derScale = () => {
             const xMinusMean2TimesRsqrt = mul(xMinusMean, oneOverSqrtVariance);
             let scaleDer = mul(dy, xMinusMean2TimesRsqrt);
             if (mean.rank === 1) {
-                scaleDer = sum$1(scaleDer, reductionAxes);
+                scaleDer = sum$2(scaleDer, reductionAxes);
             }
-            return reshape$1(scaleDer, mean.shape);
+            return reshape$2(scaleDer, mean.shape);
         };
         const derOffset = () => {
             let offsetDer = dy;
             if (mean.rank === 1) {
-                offsetDer = sum$1(offsetDer, reductionAxes);
+                offsetDer = sum$2(offsetDer, reductionAxes);
             }
-            return reshape$1(offsetDer, mean.shape);
+            return reshape$2(offsetDer, mean.shape);
         };
         return {
             x: derX,
@@ -30103,13 +36202,13 @@ const gatherGradConfig = {
                 const innerAxesIndices = arrayRange(outerDims + 1, outerDims + 1 + innerDims);
                 const valuesShape = arrayConcat([outerShape, [indicesSize],
                     innerShape]);
-                const values = reshape$1(dy, valuesShape);
-                const reshapedIndices = reshape$1(indices, [indicesSize]);
+                const values = reshape$2(dy, valuesShape);
+                const reshapedIndices = reshape$2(indices, [indicesSize]);
                 const transposeDims = arrayConcat([[outerDims], outerAxesIndices, innerAxesIndices]);
-                const valuesTranspose = transpose$1(values, transposeDims);
-                let paramsGrad = unsortedSegmentSum$1(valuesTranspose, reshapedIndices, x.shape[parsedAxis]);
+                const valuesTranspose = transpose$2(values, transposeDims);
+                let paramsGrad = unsortedSegmentSum$2(valuesTranspose, reshapedIndices, x.shape[parsedAxis]);
                 const invertTransposeDims = getUndoAxesPermutation(transposeDims);
-                paramsGrad = transpose$1(paramsGrad, invertTransposeDims);
+                paramsGrad = transpose$2(paramsGrad, invertTransposeDims);
                 return paramsGrad;
             };
         };
@@ -30152,7 +36251,7 @@ const greaterEqualGradConfig = {
     inputsToSave: ['a', 'b'],
     gradFunc: (dy, saved) => {
         const [a, b] = saved;
-        return { a: () => zerosLike$1(a), b: () => zerosLike$1(b) };
+        return { a: () => zerosLike$2(a), b: () => zerosLike$2(b) };
     }
 };
 
@@ -30160,7 +36259,7 @@ const greaterEqualGradConfig = {
 const identityGradConfig = {
     kernelName: Identity$1,
     gradFunc: (dy) => {
-        return { x: () => cast$2(dy, 'float32') };
+        return { x: () => cast$3(dy, 'float32') };
     }
 };
 
@@ -30170,7 +36269,7 @@ const isFiniteGradConfig = {
     gradFunc: (dy) => {
         
         
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -30180,7 +36279,7 @@ const isInfGradConfig = {
     gradFunc: (dy) => {
         
         
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -30190,7 +36289,7 @@ const isNanGradConfig = {
     gradFunc: (dy) => {
         
         
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -30201,7 +36300,7 @@ const leakyReluGradConfig = {
     gradFunc: (dy, saved, attrs) => {
         const [x] = saved;
         const { alpha } = attrs;
-        const mask = greater$1(x, 0);
+        const mask = greater$2(x, 0);
         
         
         return { x: () => where(mask, dy, mul(dy, alpha)) };
@@ -30214,7 +36313,7 @@ const log1pGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, add(x, 1)) };
+        return { x: () => div$1(dy, add$1(x, 1)) };
     }
 };
 
@@ -30224,7 +36323,7 @@ const logGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, cast$2(x, 'float32')) };
+        return { x: () => div$1(dy, cast$3(x, 'float32')) };
     }
 };
 
@@ -30239,8 +36338,8 @@ const logSoftmaxGradConfig = {
         return {
             logits: () => {
                 const keepDims = true;
-                const softmax = exp$1(value);
-                return sub$1(dy, mul(sum$1(dy, axis, keepDims), softmax));
+                const softmax = exp$2(value);
+                return sub$2(dy, mul(sum$2(dy, axis, keepDims), softmax));
             }
         };
     }
@@ -30272,14 +36371,14 @@ const lrnGradConfig = {
 
 function gradForMinAndMax(dy, y, xOrig, origAxes) {
     if (y.rank < xOrig.rank) {
-        y = reshape$1(y, expandShapeToKeepDim(y.shape, origAxes));
+        y = reshape$2(y, expandShapeToKeepDim(y.shape, origAxes));
     }
     if (dy.rank < xOrig.rank) {
-        dy = reshape$1(dy, expandShapeToKeepDim(dy.shape, origAxes));
+        dy = reshape$2(dy, expandShapeToKeepDim(dy.shape, origAxes));
     }
     return {
         x: () => {
-            const dx = mul(dy, cast$2(equal$1(xOrig, y), dy.dtype));
+            const dx = mul(dy, cast$3(equal$2(xOrig, y), dy.dtype));
             return dx;
         }
     };
@@ -30311,8 +36410,8 @@ const maximumGradConfig = {
     inputsToSave: ['a', 'b'],
     gradFunc: (dy, saved) => {
         const [a, b] = saved;
-        const derA = () => mul(dy, cast$2(greaterEqual$1(a, b), 'float32'));
-        const derB = () => mul(dy, cast$2(less$1(a, b), 'float32'));
+        const derA = () => mul(dy, cast$3(greaterEqual$2(a, b), 'float32'));
+        const derB = () => mul(dy, cast$3(less$2(a, b), 'float32'));
         return { a: derA, b: derB };
     }
 };
@@ -30329,11 +36428,11 @@ function maxPool3dGrad_(dy, input, output, filterSize, strides, pad, dimRounding
     let reshapedTo5D = false;
     if ($input.rank === 4) {
         reshapedTo5D = true;
-        dy5D = reshape$1($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2], $dy.shape[3]]);
-        input5D = reshape$1($input, [
+        dy5D = reshape$2($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2], $dy.shape[3]]);
+        input5D = reshape$2($input, [
             1, $input.shape[0], $input.shape[1], $input.shape[2], $input.shape[3]
         ]);
-        output5D = reshape$1($output, [
+        output5D = reshape$2($output, [
             1, $output.shape[0], $output.shape[1], $output.shape[2], $output.shape[3]
         ]);
     }
@@ -30349,7 +36448,7 @@ function maxPool3dGrad_(dy, input, output, filterSize, strides, pad, dimRounding
     
     const res = ENGINE.runKernel(MaxPool3DGrad, inputs, attrs);
     if (reshapedTo5D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
     }
     return res;
 }
@@ -30419,8 +36518,8 @@ const meanGradConfig = {
             axes.forEach(axis => {
                 expandedDyShape[axis] = 1;
             });
-            const expandedDy = reshape$1(dy, expandedDyShape);
-            const res = div(mul(expandedDy, ones(x.shape, 'float32')), reduceSize);
+            const expandedDy = reshape$2(dy, expandedDyShape);
+            const res = div$1(mul(expandedDy, ones(x.shape, 'float32')), reduceSize);
             return res;
         };
         return { x: derX };
@@ -30452,8 +36551,8 @@ const minimumGradConfig = {
     inputsToSave: ['a', 'b'],
     gradFunc: (dy, saved) => {
         const [a, b] = saved;
-        const derA = () => mul(dy, cast$2(lessEqual$1(a, b), 'float32'));
-        const derB = () => mul(dy, cast$2(greater$1(a, b), 'float32'));
+        const derA = () => mul(dy, cast$3(lessEqual$2(a, b), 'float32'));
+        const derB = () => mul(dy, cast$3(greater$2(a, b), 'float32'));
         return { a: derA, b: derB };
     }
 };
@@ -30468,7 +36567,7 @@ const mirrorPadGradConfig = {
         const x = saved[0];
         const { paddings } = attrs;
         const begin = paddings.map(p => p[0]);
-        return { x: () => slice$1(dy, begin, x.shape) };
+        return { x: () => slice$2(dy, begin, x.shape) };
     }
 };
 
@@ -30482,15 +36581,15 @@ const modGradConfig = {
         const derA = () => {
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                return reshape$1(sum$1(dy, reduceAxes), a.shape);
+                return reshape$2(sum$2(dy, reduceAxes), a.shape);
             }
             return dy;
         };
         const derB = () => {
-            const res = mul(dy, neg$1(floor$1(div(a, b))));
+            const res = mul(dy, neg$2(floor$2(div$1(a, b))));
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                return reshape$1(sum$1(res, reduceAxes), b.shape);
+                return reshape$2(sum$2(res, reduceAxes), b.shape);
             }
             return res;
         };
@@ -30506,18 +36605,18 @@ const multiplyGradConfig = {
         const [a, b] = saved;
         const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
         const derA = () => {
-            const res = mul(dy, cast$2(b, 'float32'));
+            const res = mul(dy, cast$3(b, 'float32'));
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                return reshape$1(sum$1(res, reduceAxes), a.shape);
+                return reshape$2(sum$2(res, reduceAxes), a.shape);
             }
             return res;
         };
         const derB = () => {
-            const res = mul(dy, cast$2(a, 'float32'));
+            const res = mul(dy, cast$3(a, 'float32'));
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                return reshape$1(sum$1(res, reduceAxes), b.shape);
+                return reshape$2(sum$2(res, reduceAxes), b.shape);
             }
             return res;
         };
@@ -30529,7 +36628,7 @@ const multiplyGradConfig = {
 const negGradConfig = {
     kernelName: Neg,
     gradFunc: (dy) => {
-        return { x: () => neg$1(dy) };
+        return { x: () => neg$2(dy) };
     }
 };
 
@@ -30539,7 +36638,7 @@ const oneHotGradConfig = {
     inputsToSave: ['indices'],
     gradFunc: (dy, saved) => {
         const indices = saved[0];
-        return { indices: () => zeros(indices.shape, 'float32') };
+        return { indices: () => zeros$1(indices.shape, 'float32') };
     }
 };
 
@@ -30547,7 +36646,7 @@ const oneHotGradConfig = {
 const onesLikeGradConfig = {
     kernelName: OnesLike,
     gradFunc: (dy) => {
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -30572,7 +36671,7 @@ const padV2GradConfig = {
         const x = saved[0];
         const { paddings } = attrs;
         const begin = paddings.map(p => p[0]);
-        return { x: () => slice$1(dy, begin, x.shape) };
+        return { x: () => slice$2(dy, begin, x.shape) };
     }
 };
 
@@ -30587,23 +36686,23 @@ const powGradConfig = {
         const exp = b;
         const outShape = assertAndGetBroadcastShape(base.shape, exp.shape);
         const derBase = () => {
-            const expFloat = cast$2(exp, 'float32');
-            let res = mul(dy, mul(expFloat, pow$1(base, sub$1(expFloat, scalar(1)))));
+            const expFloat = cast$3(exp, 'float32');
+            let res = mul(dy, mul(expFloat, pow$2(base, sub$2(expFloat, scalar(1)))));
             const reduceAxes = getReductionAxes(base.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, base.shape);
+            return reshape$2(res, base.shape);
         };
         const derExp = () => {
-            const condition = greater$1(base, 0);
-            const logBase = where(condition, log$1(base), zerosLike$1(base));
+            const condition = greater$2(base, 0);
+            const logBase = where(condition, log$2(base), zerosLike$2(base));
             let res = mul(dy, mul(y, logBase));
             const reduceAxes = getReductionAxes(exp.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, exp.shape);
+            return reshape$2(res, exp.shape);
         };
         return { a: derBase, b: derExp };
     }
@@ -30615,16 +36714,16 @@ const preluGradConfig = {
     inputsToSave: ['x', 'alpha'],
     gradFunc: (dy, saved) => {
         const [x, alpha] = saved;
-        const mask = greater$1(x, 0);
+        const mask = greater$2(x, 0);
         return {
             x: () => where(mask, dy, mul(dy, alpha)),
             alpha: () => {
-                let res = where(mask, zerosLike$1(dy), mul(dy, x));
+                let res = where(mask, zerosLike$2(dy), mul(dy, x));
                 const reduceAxes = getReductionAxes(alpha.shape, dy.shape);
                 if (reduceAxes.length > 0) {
-                    res = sum$1(res, reduceAxes);
+                    res = sum$2(res, reduceAxes);
                 }
-                return reshape$1(res, alpha.shape);
+                return reshape$2(res, alpha.shape);
             }
         };
     }
@@ -30639,9 +36738,9 @@ function prodGradFn_(x, dy, axis) {
     const expandedYShape = x.shape.slice();
     expandedYShape[axis] = 1;
     
-    const expandedDy = reshape$1(dy, expandedYShape);
-    const xCumProd = cumprod$1(x, axis, true, false);
-    const xCumRevProd = cumprod$1(x, axis, true, true);
+    const expandedDy = reshape$2(dy, expandedYShape);
+    const xCumProd = cumprod$2(x, axis, true, false);
+    const xCumRevProd = cumprod$2(x, axis, true, true);
     const dx = mul(xCumProd, xCumRevProd);
     return mul(expandedDy, dx);
 }
@@ -30655,7 +36754,7 @@ function prodsGradFn_(x, dy, axis) {
     const xPermutation = getAxesPermutation(axis, xRank);
     let permutedX = x;
     if (xPermutation != null) {
-        permutedX = transpose$1(x, xPermutation);
+        permutedX = transpose$2(x, xPermutation);
     }
     
     
@@ -30670,7 +36769,7 @@ function prodsGradFn_(x, dy, axis) {
     prodGrad = prodGrad.reshape(permutedX.shape);
     if (xPermutation != null) {
         const undoPermutation = getUndoAxesPermutation(xPermutation);
-        prodGrad = transpose$1(prodGrad, undoPermutation);
+        prodGrad = transpose$2(prodGrad, undoPermutation);
     }
     return prodGrad;
 }
@@ -30716,21 +36815,21 @@ const divGradConfig = {
         const [a, b] = saved;
         const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
         const derA = () => {
-            const res = div(dy, cast$2(b, 'float32'));
+            const res = div$1(dy, cast$3(b, 'float32'));
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                return reshape$1(sum$1(res, reduceAxes), a.shape);
+                return reshape$2(sum$2(res, reduceAxes), a.shape);
             }
             return res;
         };
         const derB = () => {
-            let res = mul(dy, cast$2(a, 'float32'));
+            let res = mul(dy, cast$3(a, 'float32'));
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = reshape$1(sum$1(res, reduceAxes), b.shape);
+                res = reshape$2(sum$2(res, reduceAxes), b.shape);
             }
             const tmp = square$2(b);
-            return neg$1(div(res, cast$2(tmp, 'float32')));
+            return neg$2(div$1(res, cast$3(tmp, 'float32')));
         };
         return { a: derA, b: derB };
     }
@@ -30742,7 +36841,7 @@ const reciprocalGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, neg$1(square$2(x))) };
+        return { x: () => div$1(dy, neg$2(square$2(x))) };
     }
 };
 
@@ -30752,8 +36851,8 @@ const relu6GradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        const mask = mul(lessEqual$1(x, 6), step$1(x));
-        return { x: () => mul(dy, cast$2(mask, 'float32')) };
+        const mask = mul(lessEqual$2(x, 6), step$2(x));
+        return { x: () => mul(dy, cast$3(mask, 'float32')) };
     }
 };
 
@@ -30763,7 +36862,7 @@ const reluGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(dy, cast$2(step$1(x), 'float32')) };
+        return { x: () => mul(dy, cast$3(step$2(x), 'float32')) };
     }
 };
 
@@ -30773,7 +36872,7 @@ const reshapeGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => reshape$1(dy, x.shape) };
+        return { x: () => reshape$2(dy, x.shape) };
     }
 };
 
@@ -30811,7 +36910,7 @@ const reverseGradConfig = {
     gradFunc: (dy, saved, attrs) => {
         const { dims } = attrs;
         const axes = parseAxisParam(dims, dy.shape);
-        return { x: () => reverse$1(dy, axes) };
+        return { x: () => reverse$2(dy, axes) };
     }
 };
 
@@ -30821,7 +36920,7 @@ const roundGradConfig = {
     gradFunc: (dy) => {
         
         
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -30831,7 +36930,7 @@ const rsqrtGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => neg$1(div(dy, mul(pow$1(x, 1.5), 2))) };
+        return { x: () => neg$2(div$1(dy, mul(pow$2(x, 1.5), 2))) };
     }
 };
 
@@ -30844,9 +36943,9 @@ const selectGradConfig = {
         return {
             
             
-            condition: () => cast$2(zerosLike$1(condition), 'float32'),
-            t: () => mul(dy, cast$2(condition, dy.dtype)),
-            e: () => mul(dy, cast$2(logicalNot$1(condition), dy.dtype))
+            condition: () => cast$3(zerosLike$2(condition), 'float32'),
+            t: () => mul(dy, cast$3(condition, dy.dtype)),
+            e: () => mul(dy, cast$3(logicalNot$2(condition), dy.dtype))
         };
     }
 };
@@ -30859,11 +36958,11 @@ const seluGradConfig = {
         const [x] = saved;
         return {
             x: () => {
-                const mask = greater$1(x, scalar(0));
+                const mask = greater$2(x, scalar(0));
                 const scaleAlpha = scalar(SELU_SCALEALPHA);
                 const scale = scalar(SELU_SCALE);
                 const greaterThanZeroDer = mul(dy, scale);
-                const lessEqualZeroDer = mul(mul(dy, scaleAlpha), exp$1(cast$2(x, 'float32')));
+                const lessEqualZeroDer = mul(mul(dy, scaleAlpha), exp$2(cast$3(x, 'float32')));
                 return where(mask, greaterThanZeroDer, lessEqualZeroDer);
             }
         };
@@ -30876,7 +36975,7 @@ const sigmoidGradConfig = {
     outputsToSave: [true],
     gradFunc: (dy, saved) => {
         const [y] = saved;
-        return { x: () => mul(dy, mul(y, sub$1(scalar(1), y))) };
+        return { x: () => mul(dy, mul(y, sub$2(scalar(1), y))) };
     }
 };
 
@@ -30884,7 +36983,7 @@ const sigmoidGradConfig = {
 const signGradConfig = {
     kernelName: Sign,
     gradFunc: (dy) => {
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -30894,7 +36993,7 @@ const sinGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(cos$1(cast$2(x, 'float32')), dy) };
+        return { x: () => mul(cos$2(cast$3(x, 'float32')), dy) };
     }
 };
 
@@ -30904,7 +37003,7 @@ const sinhGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(cosh$1(cast$2(x, 'float32')), dy) };
+        return { x: () => mul(cosh$2(cast$3(x, 'float32')), dy) };
     }
 };
 
@@ -30940,7 +37039,7 @@ const softmaxGradConfig = {
         const keepDims = true;
         const dyTimesY = mul(dy, y);
         return {
-            logits: () => sub$1(dyTimesY, mul(sum$1(dyTimesY, [dim], keepDims), y))
+            logits: () => sub$2(dyTimesY, mul(sum$2(dyTimesY, [dim], keepDims), y))
         };
     }
 };
@@ -30951,7 +37050,7 @@ const softplusGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(dy, sigmoid$1(x)) };
+        return { x: () => mul(dy, sigmoid$2(x)) };
     }
 };
 
@@ -30960,7 +37059,7 @@ const spaceToBatchNDGradConfig = {
     kernelName: SpaceToBatchND,
     gradFunc: (dy, saved, attrs) => {
         const { blockShape, paddings } = attrs;
-        return { x: () => batchToSpaceND$1(dy, blockShape, paddings) };
+        return { x: () => batchToSpaceND$2(dy, blockShape, paddings) };
     }
 };
 
@@ -30969,7 +37068,7 @@ const splitVGradConfig = {
     kernelName: SplitV,
     gradFunc: (dy, saved, attrs) => {
         const { axis } = attrs;
-        return { x: () => concat$1(dy, axis) };
+        return { x: () => concat$2(dy, axis) };
     }
 };
 
@@ -30979,7 +37078,7 @@ const sqrtGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, mul(sqrt$1(cast$2(x, 'float32')), 2)) };
+        return { x: () => div$1(dy, mul(sqrt$2(cast$3(x, 'float32')), 2)) };
     }
 };
 
@@ -30989,7 +37088,7 @@ const squareGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(dy, mul(cast$2(x, 'float32'), 2)) };
+        return { x: () => mul(dy, mul(cast$3(x, 'float32'), 2)) };
     }
 };
 
@@ -31000,8 +37099,8 @@ const squaredDifferenceGradConfig = {
     gradFunc: (dy, saved) => {
         const [a, b] = saved;
         const two = scalar(2);
-        const derA = () => mul(dy, mul(two, sub$1(a, b)));
-        const derB = () => mul(dy, mul(two, sub$1(b, a)));
+        const derA = () => mul(dy, mul(two, sub$2(a, b)));
+        const derB = () => mul(dy, mul(two, sub$2(b, a)));
         return { a: derA, b: derB };
     }
 };
@@ -31012,7 +37111,7 @@ const stepGradConfig = {
     gradFunc: (dy) => {
         
         
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -31027,17 +37126,17 @@ const subGradConfig = {
             let res = dy;
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, a.shape);
+            return reshape$2(res, a.shape);
         };
         const derB = () => {
             let res = dy;
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(neg$1(res), b.shape);
+            return reshape$2(neg$2(res), b.shape);
         };
         return { a: derA, b: derB };
     }
@@ -31055,7 +37154,7 @@ const sumGradConfig = {
         axes.forEach(axis => {
             expandedDyShape[axis] = 1;
         });
-        const expandedDy = reshape$1(dy, expandedDyShape);
+        const expandedDy = reshape$2(dy, expandedDyShape);
         const derX = mul(expandedDy, ones(x.shape, 'float32'));
         return { x: () => derX };
     }
@@ -31067,7 +37166,7 @@ const tanGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, square$2(cos$1(x))) };
+        return { x: () => div$1(dy, square$2(cos$2(x))) };
     }
 };
 
@@ -31077,7 +37176,7 @@ const tanhGradConfig = {
     outputsToSave: [true],
     gradFunc: (dy, saved) => {
         const [y] = saved;
-        return { x: () => mul(sub$1(scalar(1), square$2(y)), dy) };
+        return { x: () => mul(sub$2(scalar(1), square$2(y)), dy) };
     }
 };
 
@@ -31089,18 +37188,18 @@ const tileGradConfig = {
         const [x] = saved;
         const { reps } = attrs;
         const derX = () => {
-            let xGrad = zerosLike$1(x);
+            let xGrad = zerosLike$2(x);
             
             
             if (x.rank === 1) {
                 for (let i = 0; i < reps[0]; ++i) {
-                    xGrad = add(xGrad, slice$1(dy, [i * x.shape[0]], [x.shape[0]]));
+                    xGrad = add$1(xGrad, slice$2(dy, [i * x.shape[0]], [x.shape[0]]));
                 }
             }
             else if (x.rank === 2) {
                 for (let i = 0; i < reps[0]; ++i) {
                     for (let j = 0; j < reps[1]; ++j) {
-                        xGrad = add(xGrad, slice$1(dy, [i * x.shape[0], j * x.shape[1]], [
+                        xGrad = add$1(xGrad, slice$2(dy, [i * x.shape[0], j * x.shape[1]], [
                             x.shape[0], x.shape[1]
                         ]));
                     }
@@ -31111,7 +37210,7 @@ const tileGradConfig = {
                     for (let j = 0; j < reps[1]; ++j) {
                         for (let k = 0; k < reps[2]; ++k) {
                             xGrad =
-                                add(xGrad, slice$1(dy, [i * x.shape[0], j * x.shape[1], k * x.shape[2]], [x.shape[0], x.shape[1], x.shape[2]]));
+                                add$1(xGrad, slice$2(dy, [i * x.shape[0], j * x.shape[1], k * x.shape[2]], [x.shape[0], x.shape[1], x.shape[2]]));
                         }
                     }
                 }
@@ -31122,7 +37221,7 @@ const tileGradConfig = {
                         for (let k = 0; k < reps[2]; ++k) {
                             for (let l = 0; l < reps[3]; ++l) {
                                 xGrad =
-                                    add(xGrad, slice$1(dy, [
+                                    add$1(xGrad, slice$2(dy, [
                                         i * x.shape[0], j * x.shape[1], k * x.shape[2],
                                         l * x.shape[3]
                                     ], [x.shape[0], x.shape[1], x.shape[2], x.shape[3]]));
@@ -31148,7 +37247,7 @@ const transposeGradConfig = {
         const transposeAttrs = attrs;
         const { perm } = transposeAttrs;
         const undoPerm = getUndoAxesPermutation(perm);
-        return { x: () => transpose$1(dy, undoPerm) };
+        return { x: () => transpose$2(dy, undoPerm) };
     }
 };
 
@@ -31178,15 +37277,15 @@ function gatherDropNegatives(x, indices) {
     
     
     
-    const zeroClippedIndices = maximum$1(indices, zerosLike$1(indices));
+    const zeroClippedIndices = maximum$2(indices, zerosLike$2(indices));
     const gathered = gather$1(x, zeroClippedIndices);
-    let isPositive = greaterEqual$1(indices, scalar(0, 'int32'));
+    let isPositive = greaterEqual$2(indices, scalar(0, 'int32'));
     const numIters = gathered.rank - isPositive.rank;
     for (let i = 0; i < numIters; ++i) {
-        isPositive = expandDims$2(isPositive, i + 1);
+        isPositive = expandDims$3(isPositive, i + 1);
     }
-    isPositive = logicalAnd$1(isPositive, ones(gathered.shape, 'bool'));
-    const zeroSlice = zerosLike$1(gathered);
+    isPositive = logicalAnd$2(isPositive, ones(gathered.shape, 'bool'));
+    const zeroSlice = zerosLike$2(gathered);
     return where(isPositive, gathered, zeroSlice);
 }
 
@@ -31194,7 +37293,7 @@ function gatherDropNegatives(x, indices) {
 const zerosLikeGradConfig = {
     kernelName: ZerosLike,
     gradFunc: (dy) => {
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -31842,7 +37941,7 @@ function imageDataFormat() {
 
 
 function cast(x, dtype) {
-    return cast$2(x, dtype);
+    return cast$3(x, dtype);
 }
 
 function expandDims(x, axis = -1) {
@@ -31851,7 +37950,7 @@ function expandDims(x, axis = -1) {
         axis = outShape.length + axis + 1;
     }
     outShape.splice(axis, 0, 1);
-    return reshape$1(x, outShape);
+    return reshape$2(x, outShape);
 }
 
 function repeat(x, n) {
@@ -31867,7 +37966,7 @@ function repeat(x, n) {
 
 function flatten(x) {
     const newShape = [arrayProd(x.shape)];
-    return reshape$1(x, newShape);
+    return reshape$2(x, newShape);
 }
 
 function batchFlatten(x) {
@@ -31875,7 +37974,7 @@ function batchFlatten(x) {
         throw new ValueError(`batchFlatten requires a minimum rank of 2. Got rank: ${x.rank}.`);
     }
     const newShape = [x.shape[0], arrayProd(x.shape, 1)];
-    return reshape$1(x, newShape);
+    return reshape$2(x, newShape);
 }
 
 function sliceAlongFirstAxis(array, start, size) {
@@ -31890,11 +37989,11 @@ function sliceAlongFirstAxis(array, start, size) {
             case 4:
                 return slice4d(array, [start, 0, 0, 0], [size, array.shape[1], array.shape[2], array.shape[3]]);
             case 5:
-                return slice$1(array, [start, 0, 0, 0, 0], [
+                return slice$2(array, [start, 0, 0, 0, 0], [
                     size, array.shape[1], array.shape[2], array.shape[3], array.shape[4]
                 ]);
             case 6:
-                return slice$1(array, [start, 0, 0, 0, 0, 0], [
+                return slice$2(array, [start, 0, 0, 0, 0, 0], [
                     size, array.shape[1], array.shape[2], array.shape[3], array.shape[4],
                     array.shape[5]
                 ]);
@@ -31913,7 +38012,7 @@ function tile(x, n) {
         throw new ValueError(`The length of input n (${n.length}) does not match ` +
             `the number of dimensions in input x (${x.rank})`);
     }
-    return tile$2(x, n);
+    return tile$3(x, n);
 }
 
 
@@ -31956,7 +38055,7 @@ function dot(a, b, activation, bias) {
         
         const aFirstDims = a.shape.slice(); 
         const aLastDim = aFirstDims.pop();
-        a = reshape$1(a, [-1, aLastDim]);
+        a = reshape$2(a, [-1, aLastDim]);
         
         
         const bShape = b.shape.slice();
@@ -31974,12 +38073,12 @@ function dot(a, b, activation, bias) {
             }
             return i;
         });
-        b = reshape$1(transpose$1(b, perm), [ySecondLastDim, -1]);
+        b = reshape$2(transpose$2(b, perm), [ySecondLastDim, -1]);
         
         const outputShape = [...aFirstDims, ...yOtherDims];
         const transposeA = false;
         const transposeB = false;
-        return reshape$1(matMul({
+        return reshape$2(matMul({
             a,
             b,
             transposeA,
@@ -31997,7 +38096,7 @@ function gather(reference, indices, axis) {
             indices = tensor1d(indices, 'int32');
         }
         else {
-            indices = cast$2(indices, 'int32');
+            indices = cast$3(indices, 'int32');
         }
         return gather$1(reference, indices, axis);
     });
@@ -32016,54 +38115,54 @@ function reshapeBias(xRank, bias, dataFormat) {
     if (xRank === 5) {
         if (dataFormat === 'channelsFirst') {
             if (biasShape.length === 1) {
-                return reshape$1(bias, [1, biasShape[0], 1, 1, 1]);
+                return reshape$2(bias, [1, biasShape[0], 1, 1, 1]);
             }
             else {
-                return reshape$1(bias, [1, biasShape[3], biasShape[0], biasShape[1], biasShape[2]]);
+                return reshape$2(bias, [1, biasShape[3], biasShape[0], biasShape[1], biasShape[2]]);
             }
         }
         else if (dataFormat === 'channelsLast') {
             if (biasShape.length === 1) {
-                return reshape$1(bias, [1, 1, 1, 1, biasShape[0]]);
+                return reshape$2(bias, [1, 1, 1, 1, biasShape[0]]);
             }
             else {
-                return reshape$1(bias, [1].concat(biasShape));
+                return reshape$2(bias, [1].concat(biasShape));
             }
         }
     }
     else if (xRank === 4) {
         if (dataFormat === 'channelsFirst') {
             if (biasShape.length === 1) {
-                return reshape$1(bias, [1, biasShape[0], 1, 1]);
+                return reshape$2(bias, [1, biasShape[0], 1, 1]);
             }
             else {
-                return reshape$1(bias, [1, biasShape[2], biasShape[0], biasShape[1]]);
+                return reshape$2(bias, [1, biasShape[2], biasShape[0], biasShape[1]]);
             }
         }
         else if (dataFormat === 'channelsLast') {
             if (biasShape.length === 1) {
-                return reshape$1(bias, [1, 1, 1, biasShape[0]]);
+                return reshape$2(bias, [1, 1, 1, biasShape[0]]);
             }
             else {
-                return reshape$1(bias, [1].concat(biasShape));
+                return reshape$2(bias, [1].concat(biasShape));
             }
         }
     }
     else if (xRank === 3) {
         if (dataFormat === 'channelsFirst') {
             if (biasShape.length === 1) {
-                return reshape$1(bias, [1, biasShape[0], 1]);
+                return reshape$2(bias, [1, biasShape[0], 1]);
             }
             else {
-                return reshape$1(bias, [1, biasShape[1], biasShape[0]]);
+                return reshape$2(bias, [1, biasShape[1], biasShape[0]]);
             }
         }
         else if (dataFormat === 'channelsLast') {
             if (biasShape.length === 1) {
-                return reshape$1(bias, [1, 1, biasShape[0]]);
+                return reshape$2(bias, [1, 1, biasShape[0]]);
             }
             else {
-                return reshape$1(bias, [1].concat(biasShape));
+                return reshape$2(bias, [1].concat(biasShape));
             }
         }
     }
@@ -32080,7 +38179,7 @@ function biasAdd(x, bias, dataFormat) {
             dataFormat = imageDataFormat();
         }
         checkDataFormat(dataFormat);
-        return add(x, reshapeBias(x.rank, bias, dataFormat));
+        return add$1(x, reshapeBias(x.rank, bias, dataFormat));
     });
 }
 
@@ -32090,11 +38189,11 @@ function elu(x, alpha = 1) {
         throw new NotImplementedError(`Support for alpha values other than 1 (${alpha}) is not implemented ` +
             `yet.`);
     }
-    return elu$2(x);
+    return elu$3(x);
 }
 
 function softsign(x) {
-    return tidy(() => div(x, add(abs$1(x), 1)));
+    return tidy(() => div$1(x, add$1(abs$2(x), 1)));
 }
 
 function dropout$1(x, level, noiseShape, seed) {
@@ -32103,8 +38202,8 @@ function dropout$1(x, level, noiseShape, seed) {
 
 function hardSigmoid(x) {
     return tidy(() => {
-        const y = add(.5, mul(.2, x));
-        return clipByValue$1(y, 0, 1);
+        const y = add$1(.5, mul(.2, x));
+        return clipByValue$2(y, 0, 1);
     });
 }
 
@@ -32134,7 +38233,7 @@ class Initializer extends Serializable {
 }
 class Zeros extends Initializer {
     apply(shape, dtype) {
-        return zeros(shape, dtype);
+        return zeros$1(shape, dtype);
     }
 }
 
@@ -33638,7 +39737,7 @@ function assertFeedCompatibility(key, val) {
     }
     try {
         
-        return cast$2(val, key.dtype);
+        return cast$3(val, key.dtype);
     }
     catch (err) {
         
@@ -33960,7 +40059,7 @@ function getNodeOutputs(fetch) {
 
 
 function calcL2Norms(w, axis) {
-    return tidy(() => sqrt$1(sum$1(mul(w, w), axis, true)));
+    return tidy(() => sqrt$2(sum$2(mul(w, w), axis, true)));
 }
 
 class Constraint extends Serializable {
@@ -33980,8 +40079,8 @@ class MaxNorm extends Constraint {
     apply(w) {
         return tidy(() => {
             const norms = calcL2Norms(w, this.axis);
-            const desired = clipByValue$1(norms, 0, this.maxValue);
-            return mul(w, div(desired, add(epsilon(), norms)));
+            const desired = clipByValue$2(norms, 0, this.maxValue);
+            return mul(w, div$1(desired, add$1(epsilon(), norms)));
         });
     }
     getConfig() {
@@ -33998,7 +40097,7 @@ class UnitNorm extends Constraint {
         this.axis = args.axis != null ? args.axis : this.defaultAxis;
     }
     apply(w) {
-        return tidy(() => div(w, add(epsilon(), calcL2Norms(w, this.axis))));
+        return tidy(() => div$1(w, add$1(epsilon(), calcL2Norms(w, this.axis))));
     }
     getConfig() {
         return { axis: this.axis };
@@ -34009,7 +40108,7 @@ UnitNorm.className = 'UnitNorm';
 registerClass(UnitNorm);
 class NonNeg extends Constraint {
     apply(w) {
-        return relu$1(w);
+        return relu$2(w);
     }
 }
 
@@ -34032,8 +40131,8 @@ class MinMaxNorm extends Constraint {
     apply(w) {
         return tidy(() => {
             const norms = calcL2Norms(w, this.axis);
-            const desired = add(mul(this.rate, clipByValue$1(norms, this.minValue, this.maxValue)), mul(1.0 - this.rate, norms));
-            return mul(w, div(desired, add(epsilon(), norms)));
+            const desired = add$1(mul(this.rate, clipByValue$2(norms, this.minValue, this.maxValue)), mul(1.0 - this.rate, norms));
+            return mul(w, div$1(desired, add$1(epsilon(), norms)));
         });
     }
     getConfig() {
@@ -34280,7 +40379,7 @@ class BaseLogger extends BaseCallback {
                 else {
                     this.totals[key] = 0;
                 }
-                const total = tidy(() => add((this.totals[key]), mul(value, batchSize)));
+                const total = tidy(() => add$1((this.totals[key]), mul(value, batchSize)));
                 this.totals[key] = total;
                 if (oldTotalsToDispose != null) {
                     oldTotalsToDispose.dispose();
@@ -34299,7 +40398,7 @@ class BaseLogger extends BaseCallback {
                 }
                 else {
                     tidy(() => {
-                        const log = mul(div(1, this.seen), this.totals[key]);
+                        const log = mul(div$1(1, this.seen), this.totals[key]);
                         logs[key] = log;
                         this.totals[key].dispose();
                         keep(logs[key]);
@@ -34534,86 +40633,86 @@ function deserialize(config, customObjects = {}, fastWeightInit = false) {
 function l2Normalize(x, axis) {
     return tidy(() => {
         if (x.dtype !== 'float32') {
-            x = cast$2(x, 'float32');
+            x = cast$3(x, 'float32');
         }
-        const squareSum = sum$1(square(x), axis, true);
-        const epsilonTensor = fill$1(squareSum.shape, epsilon());
-        const norm = sqrt$1(maximum$1(squareSum, epsilonTensor));
-        return div(x, norm);
+        const squareSum = sum$2(square(x), axis, true);
+        const epsilonTensor = fill$2(squareSum.shape, epsilon());
+        const norm = sqrt$2(maximum$2(squareSum, epsilonTensor));
+        return div$1(x, norm);
     });
 }
 function meanSquaredError(yTrue, yPred) {
-    return tidy(() => mean(square(sub$1(yPred, yTrue)), -1));
+    return tidy(() => mean$1(square(sub$2(yPred, yTrue)), -1));
 }
 function meanAbsoluteError(yTrue, yPred) {
-    return tidy(() => mean(abs$1(sub$1(yPred, yTrue)), -1));
+    return tidy(() => mean$1(abs$2(sub$2(yPred, yTrue)), -1));
 }
 function meanAbsolutePercentageError(yTrue, yPred) {
     return tidy(() => {
-        const diff = sub$1(yTrue, yPred);
-        const clippedTrue = clipByValue$1(abs$1(yTrue), epsilon(), Number.MAX_VALUE);
-        const absResult = abs$1(div(diff, clippedTrue));
-        return mul(100, mean(absResult, -1));
+        const diff = sub$2(yTrue, yPred);
+        const clippedTrue = clipByValue$2(abs$2(yTrue), epsilon(), Number.MAX_VALUE);
+        const absResult = abs$2(div$1(diff, clippedTrue));
+        return mul(100, mean$1(absResult, -1));
     });
 }
 function meanSquaredLogarithmicError(yTrue, yPred) {
     return tidy(() => {
-        const clippedPred = clipByValue$1(yPred, epsilon(), Number.MAX_VALUE);
-        const firstLog = log$1(add(1, clippedPred));
-        const clippedTrue = clipByValue$1(yTrue, epsilon(), Number.MAX_VALUE);
-        const secondLog = log$1(add(1, clippedTrue));
-        return mean(square(sub$1(firstLog, secondLog)), -1);
+        const clippedPred = clipByValue$2(yPred, epsilon(), Number.MAX_VALUE);
+        const firstLog = log$2(add$1(1, clippedPred));
+        const clippedTrue = clipByValue$2(yTrue, epsilon(), Number.MAX_VALUE);
+        const secondLog = log$2(add$1(1, clippedTrue));
+        return mean$1(square(sub$2(firstLog, secondLog)), -1);
     });
 }
 function squaredHinge(yTrue, yPred) {
     return tidy(() => {
-        const maxResult = maximum$1(0, sub$1(1, mul(yTrue, yPred)));
-        return mean(square(maxResult), -1);
+        const maxResult = maximum$2(0, sub$2(1, mul(yTrue, yPred)));
+        return mean$1(square(maxResult), -1);
     });
 }
 function hinge(yTrue, yPred) {
     return tidy(() => {
-        const maxResult = maximum$1(0, sub$1(1, mul(yTrue, yPred)));
-        return mean(maxResult, -1);
+        const maxResult = maximum$2(0, sub$2(1, mul(yTrue, yPred)));
+        return mean$1(maxResult, -1);
     });
 }
 function categoricalHinge(yTrue, yPred) {
     return tidy(() => {
-        const pos = sum$1(mul(yTrue, yPred), -1);
-        const neg = max$1(mul(sub$1(1, yTrue), yPred), -1);
-        return maximum$1(0, add(1, sub$1(neg, pos)));
+        const pos = sum$2(mul(yTrue, yPred), -1);
+        const neg = max$2(mul(sub$2(1, yTrue), yPred), -1);
+        return maximum$2(0, add$1(1, sub$2(neg, pos)));
     });
 }
 
 function logcosh(yTrue, yPred) {
     return tidy(() => {
         const log2 = Math.log(2);
-        const predictionDiff = sub$1(yPred, yTrue);
-        const logcoshResult = sub$1(add(predictionDiff, softplus$1(mul(-2, predictionDiff))), log2);
-        return mean(logcoshResult, -1);
+        const predictionDiff = sub$2(yPred, yTrue);
+        const logcoshResult = sub$2(add$1(predictionDiff, softplus$2(mul(-2, predictionDiff))), log2);
+        return mean$1(logcoshResult, -1);
     });
 }
 function categoricalCrossentropy$1(target, output, fromLogits = false) {
     return tidy(() => {
         if (fromLogits) {
-            output = softmax$1(output);
+            output = softmax$2(output);
         }
         else {
             
-            const outputSum = sum$1(output, output.shape.length - 1, true);
-            output = div(output, outputSum);
+            const outputSum = sum$2(output, output.shape.length - 1, true);
+            output = div$1(output, outputSum);
         }
-        output = clipByValue$1(output, epsilon(), 1 - epsilon());
-        return neg$1(sum$1(mul(cast$2(target, 'float32'), log$1(output)), output.shape.length - 1));
+        output = clipByValue$2(output, epsilon(), 1 - epsilon());
+        return neg$2(sum$2(mul(cast$3(target, 'float32'), log$2(output)), output.shape.length - 1));
     });
 }
 
 function sparseCategoricalCrossentropy$1(target, output, fromLogits = false) {
     return tidy(() => {
-        const flatTarget = cast$2(floor$1(flatten(target)), 'int32');
-        output = clipByValue$1(output, epsilon(), 1 - epsilon());
+        const flatTarget = cast$3(floor$2(flatten(target)), 'int32');
+        output = clipByValue$2(output, epsilon(), 1 - epsilon());
         const outputShape = output.shape;
-        const oneHotTarget = reshape$1(oneHot$1(flatTarget, outputShape[outputShape.length - 1]), outputShape);
+        const oneHotTarget = reshape$2(oneHot$2(flatTarget, outputShape[outputShape.length - 1]), outputShape);
         return categoricalCrossentropy$1(oneHotTarget, output, fromLogits);
     });
 }
@@ -34630,30 +40729,30 @@ function sigmoidCrossEntropyWithLogits(labels, logits) {
         
         
         
-        const reluLogits = relu$1(logits);
-        const negAbsLogits = neg$1(abs$1(logits));
-        return add(sub$1(reluLogits, mul(logits, labels)), log1p$1(exp$1(negAbsLogits)));
+        const reluLogits = relu$2(logits);
+        const negAbsLogits = neg$2(abs$2(logits));
+        return add$1(sub$2(reluLogits, mul(logits, labels)), log1p$2(exp$2(negAbsLogits)));
     });
 }
 function binaryCrossentropy$1(yTrue, yPred) {
     return tidy(() => {
         let y;
-        y = clipByValue$1(yPred, epsilon(), 1 - epsilon());
-        y = log$1(div(y, sub$1(1, y)));
-        return mean(sigmoidCrossEntropyWithLogits(yTrue, y), -1);
+        y = clipByValue$2(yPred, epsilon(), 1 - epsilon());
+        y = log$2(div$1(y, sub$2(1, y)));
+        return mean$1(sigmoidCrossEntropyWithLogits(yTrue, y), -1);
     });
 }
 function kullbackLeiblerDivergence(yTrue, yPred) {
     return tidy(() => {
-        const clippedTrue = clipByValue$1(yTrue, epsilon(), 1);
-        const clippedPred = clipByValue$1(yPred, epsilon(), 1);
-        return sum$1(mul(yTrue, log$1(div(clippedTrue, clippedPred))), -1);
+        const clippedTrue = clipByValue$2(yTrue, epsilon(), 1);
+        const clippedPred = clipByValue$2(yPred, epsilon(), 1);
+        return sum$2(mul(yTrue, log$2(div$1(clippedTrue, clippedPred))), -1);
     });
 }
 function poisson(yTrue, yPred) {
     return tidy(() => {
-        const logPred = log$1(add(epsilon(), yPred));
-        return mean(sub$1(yPred, mul(yTrue, logPred)), -1);
+        const logPred = log$2(add$1(epsilon(), yPred));
+        return mean$1(sub$2(yPred, mul(yTrue, logPred)), -1);
     });
 }
 function cosineProximity(yTrue, yPred) {
@@ -34661,7 +40760,7 @@ function cosineProximity(yTrue, yPred) {
         const trueNormalized = l2Normalize(yTrue, -1);
         const predNormalized = l2Normalize(yPred, -1);
         const trueXPred = mul(trueNormalized, predNormalized);
-        return neg$1(sum$1(trueXPred, -1));
+        return neg$2(sum$2(trueXPred, -1));
     });
 }
 
@@ -34705,30 +40804,30 @@ function get$1(identifierOrFn) {
 
 function binaryAccuracy(yTrue, yPred) {
     return tidy(() => {
-        const threshold = mul(.5, onesLike$1(yPred));
-        const yPredThresholded = cast(greater$1(yPred, threshold), yTrue.dtype);
-        return mean(equal$1(yTrue, yPredThresholded), -1);
+        const threshold = mul(.5, onesLike$2(yPred));
+        const yPredThresholded = cast(greater$2(yPred, threshold), yTrue.dtype);
+        return mean$1(equal$2(yTrue, yPredThresholded), -1);
     });
 }
 function categoricalAccuracy(yTrue, yPred) {
-    return tidy(() => cast(equal$1(argMax$1(yTrue, -1), argMax$1(yPred, -1)), 'float32'));
+    return tidy(() => cast(equal$2(argMax$2(yTrue, -1), argMax$2(yPred, -1)), 'float32'));
 }
 function truePositives(yTrue, yPred) {
     return tidy(() => {
-        return cast$2(sum$1(logicalAnd$1(equal$1(yTrue, 1), equal$1(yPred, 1))), 'float32');
+        return cast$3(sum$2(logicalAnd$2(equal$2(yTrue, 1), equal$2(yPred, 1))), 'float32');
     });
 }
 function falsePositives(yTrue, yPred) {
     return tidy(() => {
-        return cast$2(sum$1(logicalAnd$1(equal$1(yTrue, 0), equal$1(yPred, 1))), 'float32');
+        return cast$3(sum$2(logicalAnd$2(equal$2(yTrue, 0), equal$2(yPred, 1))), 'float32');
     });
 }
 function precision(yTrue, yPred) {
     return tidy(() => {
         const tp = truePositives(yTrue, yPred);
         const fp = falsePositives(yTrue, yPred);
-        const denominator = add(tp, fp);
-        return cast$2(where(greater$1(denominator, 0), div(tp, denominator), 0), 'float32');
+        const denominator = add$1(tp, fp);
+        return cast$3(where(greater$2(denominator, 0), div$1(tp, denominator), 0), 'float32');
     });
 }
 function binaryCrossentropy(yTrue, yPred) {
@@ -34738,11 +40837,11 @@ function sparseCategoricalAccuracy(yTrue, yPred) {
     if (yTrue.rank === yPred.rank) {
         yTrue = squeeze(yTrue, [yTrue.rank - 1]);
     }
-    yPred = argMax$1(yPred, -1);
+    yPred = argMax$2(yPred, -1);
     if (yPred.dtype !== yTrue.dtype) {
-        yPred = cast$2(yPred, yTrue.dtype);
+        yPred = cast$3(yPred, yTrue.dtype);
     }
-    return cast$2(equal$1(yTrue, yPred), 'float32');
+    return cast$3(equal$2(yTrue, yPred), 'float32');
 }
 
 const mse = meanSquaredError;
@@ -36233,11 +42332,11 @@ async function standardizeWeights(y, sampleWeight, classWeight, sampleWeightMode
                 if (y.shape[1] > 1) {
                     
                     const axis = 1;
-                    return argMax$1(y, axis);
+                    return argMax$2(y, axis);
                 }
                 else if (y.shape[1] === 1) {
                     
-                    return reshape$1(y, [y.shape[0]]);
+                    return reshape$2(y, [y.shape[0]]);
                 }
                 else {
                     throw new Error(`Encountered unexpected last-dimension size (${y.shape[1]}) ` +
@@ -36564,7 +42663,7 @@ model, dataset, args) {
                     const batchOut = batchOuts[i];
                     const oldScalar = outs[i];
                     outs[i] =
-                        tidy(() => add(outs[i], mul(batchSize, batchOut)));
+                        tidy(() => add$1(outs[i], mul(batchSize, batchOut)));
                     if (batch > 0) {
                         dispose(oldScalar);
                     }
@@ -36589,7 +42688,7 @@ model, dataset, args) {
     }
     for (let i = 0; i < outs.length; ++i) {
         const oldScalar = outs[i];
-        outs[i] = div(outs[i], numExamples);
+        outs[i] = div$1(outs[i], numExamples);
         dispose(oldScalar);
     }
     return singletonOrArray(outs);
@@ -36624,7 +42723,7 @@ function sliceArraysByIndices(arrays, indices) {
         else {
             
             
-            return gather(arrays, indices.dtype === 'int32' ? indices : cast$2(indices, 'int32'));
+            return gather(arrays, indices.dtype === 'int32' ? indices : cast$3(indices, 'int32'));
         }
     });
 }
@@ -37338,7 +43437,7 @@ class LayersModel extends Container {
                 });
                 batchOuts.forEach((batchOut, i) => outsBatches[i].push(batchOut));
             }
-            return singletonOrArray(outsBatches.map(batches => concat$1(batches, 0)));
+            return singletonOrArray(outsBatches.map(batches => concat$2(batches, 0)));
         });
     }
     
@@ -37447,11 +43546,11 @@ class LayersModel extends Container {
                     for (let i = 0; i < batchOuts.length; ++i) {
                         const batchOut = batchOuts[i];
                         outs[i] =
-                            add(outs[i], mul(batchEnd - batchStart, batchOut));
+                            add$1(outs[i], mul(batchEnd - batchStart, batchOut));
                     }
                 }
                 for (let i = 0; i < outs.length; ++i) {
-                    outs[i] = div(outs[i], numSamples);
+                    outs[i] = div$1(outs[i], numSamples);
                 }
             }
             return outs;
@@ -37501,14 +43600,14 @@ class LayersModel extends Container {
                         loss = computeWeightedLoss(loss, sampleWeights[i]);
                     }
                     
-                    const meanLoss = mean(loss);
+                    const meanLoss = mean$1(loss);
                     
                     lossValues.push(meanLoss);
                     if (i === 0) {
                         totalLoss = loss;
                     }
                     else {
-                        totalLoss = add(totalLoss, loss);
+                        totalLoss = add$1(totalLoss, loss);
                     }
                 }
                 
@@ -37523,16 +43622,16 @@ class LayersModel extends Container {
                         const metric = this.metricsTensors[i][0];
                         const outputIndex = this.metricsTensors[i][1];
                         weightedMetric =
-                            mean(metric(targets[outputIndex], outputs[outputIndex]));
+                            mean$1(metric(targets[outputIndex], outputs[outputIndex]));
                     }
                     keep(weightedMetric);
                     
                     metricsValues.push(weightedMetric);
                 }
-                totalLoss = mean(totalLoss);
+                totalLoss = mean$1(totalLoss);
                 
                 this.calculateLosses().forEach(regularizerLoss => {
-                    totalLoss = add(totalLoss, regularizerLoss);
+                    totalLoss = add$1(totalLoss, regularizerLoss);
                 });
                 return totalLoss;
             };
@@ -37561,12 +43660,12 @@ class LayersModel extends Container {
                     const lossFunction = this.lossFunctions[i];
                     
                     
-                    const loss = mean(lossFunction(targets[i], outputs[i]));
+                    const loss = mean$1(lossFunction(targets[i], outputs[i]));
                     if (i === 0) {
                         totalLoss = loss;
                     }
                     else {
-                        totalLoss = add(totalLoss, loss);
+                        totalLoss = add$1(totalLoss, loss);
                     }
                     valOutputs.push(totalLoss);
                 }
@@ -37575,7 +43674,7 @@ class LayersModel extends Container {
                     const metric = this.metricsTensors[i][0];
                     const outputIndex = this.metricsTensors[i][1];
                     
-                    const meanMetric = mean(metric(targets[outputIndex], outputs[outputIndex]));
+                    const meanMetric = mean$1(metric(targets[outputIndex], outputs[outputIndex]));
                     valOutputs.push(meanMetric);
                 }
                 return valOutputs;
@@ -38474,7 +44573,7 @@ registerClass(Elu);
 
 class Selu extends Activation$1 {
     apply(x) {
-        return selu$1(x);
+        return selu$2(x);
     }
 }
 
@@ -38483,7 +44582,7 @@ registerClass(Selu);
 
 class Relu extends Activation$1 {
     apply(x) {
-        return relu$1(x);
+        return relu$2(x);
     }
 }
 
@@ -38492,7 +44591,7 @@ registerClass(Relu);
 
 class Relu6 extends Activation$1 {
     apply(x) {
-        return tidy(() => minimum$1(6.0, relu$1(x)));
+        return tidy(() => minimum$2(6.0, relu$2(x)));
     }
 }
 
@@ -38510,7 +44609,7 @@ registerClass(Linear);
 
 class Sigmoid extends Activation$1 {
     apply(x) {
-        return sigmoid$1(x);
+        return sigmoid$2(x);
     }
 }
 
@@ -38528,7 +44627,7 @@ registerClass(HardSigmoid);
 
 class Softplus extends Activation$1 {
     apply(x) {
-        return softplus$1(x);
+        return softplus$2(x);
     }
 }
 
@@ -38546,7 +44645,7 @@ registerClass(Softsign);
 
 class Tanh extends Activation$1 {
     apply(x) {
-        return tanh$1(x);
+        return tanh$2(x);
     }
 }
 
@@ -38556,7 +44655,7 @@ registerClass(Tanh);
 class Softmax extends Activation$1 {
     
     apply(x, axis = (-1)) {
-        return softmax$1(x, axis);
+        return softmax$2(x, axis);
     }
 }
 
@@ -38580,7 +44679,7 @@ class Gelu extends Activation$1 {
             return tidy(() => {
                 const sqrtTwo = Math.sqrt(2);
                 
-                const cdf = mul(0.5, add(1, erf$1(div(x, sqrtTwo))));
+                const cdf = mul(0.5, add$1(1, erf$2(div$1(x, sqrtTwo))));
                 
                 return mul(x, cdf);
             });
@@ -38595,7 +44694,7 @@ class GeluNew extends Activation$1 {
     
     apply(x) {
         return tidy(() => {
-            return mul(0.5, mul(x, add(1, tanh$1(mul(sqrt$1(div(2, Math.PI)), add(x, mul(0.044715, pow$1(x, 3))))))));
+            return mul(0.5, mul(x, add$1(1, tanh$2(mul(sqrt$2(div$1(2, Math.PI)), add$1(x, mul(0.044715, pow$2(x, 3))))))));
         });
     }
 }
@@ -38606,7 +44705,7 @@ registerClass(GeluNew);
 class Mish extends Activation$1 {
     
     apply(x) {
-        return tidy(() => mul(x, tanh$1(softplus$1(x))));
+        return tidy(() => mul(x, tanh$2(softplus$2(x))));
     }
 }
 
@@ -38616,7 +44715,7 @@ registerClass(Mish);
 class Swish extends Activation$1 {
     
     apply(x, alpha = 1) {
-        return tidy(() => mul(sigmoid$1(mul(x, alpha)), x));
+        return tidy(() => mul(sigmoid$2(mul(x, alpha)), x));
     }
 }
 
@@ -38672,15 +44771,15 @@ class L1L2 extends Regularizer {
     
     apply(x) {
         return tidy(() => {
-            let regularization = zeros([1]);
+            let regularization = zeros$1([1]);
             if (this.hasL1) {
-                regularization = add(regularization, sum$1(mul(this.l1, abs$1(x))));
+                regularization = add$1(regularization, sum$2(mul(this.l1, abs$2(x))));
             }
             if (this.hasL2) {
                 regularization =
-                    add(regularization, sum$1(mul(this.l2, square(x))));
+                    add$1(regularization, sum$2(mul(this.l2, square(x))));
             }
-            return reshape$1(regularization, []);
+            return reshape$2(regularization, []);
         });
     }
     getConfig() {
@@ -38915,7 +45014,7 @@ class Flatten extends Layer {
                     permutation.push(i);
                 }
                 permutation.push(1);
-                input = transpose$1(input, permutation);
+                input = transpose$2(input, permutation);
             }
             return batchFlatten(input);
         });
@@ -39050,7 +45149,7 @@ class Reshape extends Layer {
             const input = getExactlyOneTensor(inputs);
             const inputShape = input.shape;
             const outputShape = inputShape.slice(0, 1).concat(this.fixUnknownDimension(inputShape.slice(1), this.targetShape));
-            return reshape$1(input, outputShape);
+            return reshape$2(input, outputShape);
         });
     }
     getConfig() {
@@ -39095,7 +45194,7 @@ class Permute extends Layer {
         return outputShape;
     }
     call(inputs, kwargs) {
-        return transpose$1(getExactlyOneTensor(inputs), this.dimsIncludingBatch);
+        return transpose$2(getExactlyOneTensor(inputs), this.dimsIncludingBatch);
     }
     getConfig() {
         const config = {
@@ -39132,7 +45231,7 @@ class Masking extends Layer {
     computeMask(inputs, mask) {
         const input = getExactlyOneTensor(inputs);
         const axis = -1;
-        return any$1(notEqual$1(input, this.maskValue), axis);
+        return any$2(notEqual$2(input, this.maskValue), axis);
     }
     call(inputs, kwargs) {
         return tidy(() => {
@@ -39140,8 +45239,8 @@ class Masking extends Layer {
             const input = getExactlyOneTensor(inputs);
             const axis = -1;
             const keepDims = true;
-            const booleanMask = any$1(notEqual$1(input, this.maskValue), axis, keepDims);
-            const output = mul(input, cast$2(booleanMask, input.dtype));
+            const booleanMask = any$2(notEqual$2(input, this.maskValue), axis, keepDims);
+            const output = mul(input, cast$3(booleanMask, input.dtype));
             return output;
         });
     }
@@ -39160,4 +45259,4 @@ function dropout(args) {
     return new Dropout(args);
 }
 
-export { LayersModel, PlatformStub, dense, dropout, enableProdMode, env, fromMemory, glorotUniform, loadLayersModelFromIOHandler, sequential, stringToHashBucketFast$1 as stringToHashBucketFast, tensor1d, tensor2d, withSaveHandler };
+export { LayersModel, PlatformStub, dense, dropout, enableProdMode, env, fromMemory, glorotUniform, loadLayersModelFromIOHandler, sequential, stringToHashBucketFast$2 as stringToHashBucketFast, tensor1d, tensor2d, withSaveHandler };
diff --git a/libs/tensorflow.js b/libs/tensorflow.js
index 9f52759bdc..4e39fe5ce6 100644
--- a/libs/tensorflow.js
+++ b/libs/tensorflow.js
@@ -178,7 +178,7 @@ function swap(object, left, right) {
     object[left] = object[right];
     object[right] = temp;
 }
-function sum$2(arr) {
+function sum$3(arr) {
     let sum = 0;
     for (let i = 0; i < arr.length; i++) {
         sum += arr[i];
@@ -549,6 +549,24 @@ function toNestedArray(shape, a, isComplex = false) {
     }
     return createNestedArray(0, shape, a, isComplex);
 }
+function convertBackendValuesAndArrayBuffer(data, dtype) {
+    // If is type Uint8Array[], return it directly.
+    if (Array.isArray(data)) {
+        return data;
+    }
+    if (dtype === 'float32') {
+        return data instanceof Float32Array ? data : new Float32Array(data);
+    }
+    else if (dtype === 'int32') {
+        return data instanceof Int32Array ? data : new Int32Array(data);
+    }
+    else if (dtype === 'bool' || dtype === 'string') {
+        return Uint8Array.from(new Int32Array(data));
+    }
+    else {
+        throw new Error(`Unknown dtype ${dtype}`);
+    }
+}
 function makeOnesTypedArray(size, dtype) {
     const array = makeZerosTypedArray(size, dtype);
     for (let i = 0; i < array.length; i++) {
@@ -570,6 +588,26 @@ function makeZerosTypedArray(size, dtype) {
         throw new Error(`Unknown data type ${dtype}`);
     }
 }
+/**
+ * Make nested `TypedArray` filled with zeros.
+ * @param shape The shape information for the nested array.
+ * @param dtype dtype of the array element.
+ */
+function makeZerosNestedTypedArray(shape, dtype) {
+    const size = shape.reduce((prev, curr) => prev * curr, 1);
+    if (dtype == null || dtype === 'float32') {
+        return toNestedArray(shape, new Float32Array(size));
+    }
+    else if (dtype === 'int32') {
+        return toNestedArray(shape, new Int32Array(size));
+    }
+    else if (dtype === 'bool') {
+        return toNestedArray(shape, new Uint8Array(size));
+    }
+    else {
+        throw new Error(`Unknown data type ${dtype}`);
+    }
+}
 function assertNonNegativeIntegerDimensions(shape) {
     shape.forEach(dimSize => {
         assert$1(Number.isInteger(dimSize) && dimSize >= 0, () => `Tensor must have a shape comprised of positive integers but got ` +
@@ -928,6 +966,7 @@ const Diag = 'Diag';
 const Dilation2D = 'Dilation2D';
 const Dilation2DBackpropInput = 'Dilation2DBackpropInput';
 const Dilation2DBackpropFilter = 'Dilation2DBackpropFilter';
+const Draw = 'Draw';
 const RealDiv = 'RealDiv';
 const Einsum = 'Einsum';
 const Elu$1 = 'Elu';
@@ -1077,7 +1116,7 @@ function warn(...msg) {
         console.warn(...msg);
     }
 }
-function log$2(...msg) {
+function log$3(...msg) {
     if (!(env().getBool('IS_TEST') || env().getBool('PROD'))) {
         console.log(...msg);
     }
@@ -4751,7 +4790,7 @@ class Engine {
             // Pass the tidy function to avoid circular dep with `tape.ts`.
             f => this.tidy(f), 
             // Pass an add function to avoide a circular dep with `tape.ts`.
-            add$1);
+            add$2);
             const grads = xs.map(x => accumulatedGradientMap[x.id]);
             if (this.state.gradientDepth === 0) {
                 // This means that we are not computing higher-order gradients
@@ -4888,7 +4927,7 @@ const ENGINE = getOrMakeEngine();
  * This allows us to avoid a circular dependency between add.ts and engine.
  * It is exported to be available in tape tests.
  */
-function add$1(a, b) {
+function add$2(a, b) {
     // We duplicate Add here to avoid a circular dependency with add.ts.
     const inputs = { a, b };
     return ENGINE.runKernel(Add, inputs);
@@ -5270,7 +5309,7 @@ function cast_(x, dtype) {
     const attrs = { dtype };
     return ENGINE.runKernel(Cast, inputs, attrs);
 }
-const cast$2 = /* @__PURE__ */ op({ cast_ });
+const cast$3 = /* @__PURE__ */ op({ cast_ });
 
 /**
  * @license
@@ -5365,7 +5404,7 @@ function print(x, verbose = false) {
 getOrMakeEngine();
 const opHandler = {
     buffer,
-    cast: cast$2,
+    cast: cast$3,
     clone,
     print
 };
@@ -5597,7 +5636,7 @@ function add_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Add, inputs);
 }
-const add = /* @__PURE__ */ op({ add_ });
+const add$1 = /* @__PURE__ */ op({ add_ });
 
 /**
  * @license
@@ -5648,7 +5687,7 @@ function floorDiv_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(FloorDiv, inputs);
 }
-const floorDiv$1 = /* @__PURE__ */ op({ floorDiv_ });
+const floorDiv$2 = /* @__PURE__ */ op({ floorDiv_ });
 
 /**
  * @license
@@ -5695,14 +5734,14 @@ function div_(a, b) {
     let $b = convertToTensor(b, 'b', 'div');
     [$a, $b] = makeTypesMatch($a, $b);
     if ($a.dtype === 'int32' && $b.dtype === 'int32') {
-        return floorDiv$1($a, $b);
+        return floorDiv$2($a, $b);
     }
     const inputs = { a: $a, b: $b };
     const attrs = {};
     // tslint:disable-next-line: no-unnecessary-type-assertion
     return ENGINE.runKernel(RealDiv, inputs, attrs);
 }
-const div = /* @__PURE__ */ op({ div_ });
+const div$1 = /* @__PURE__ */ op({ div_ });
 
 /**
  * @license
@@ -5793,7 +5832,7 @@ function abs_(x) {
         return ENGINE.runKernel(Abs, inputs);
     }
 }
-const abs$1 = /* @__PURE__ */ op({ abs_ });
+const abs$2 = /* @__PURE__ */ op({ abs_ });
 
 /**
  * @license
@@ -5847,7 +5886,7 @@ function any_(x, axis = null, keepDims = false) {
     return ENGINE.runKernel(Any, inputs, attrs);
 }
 // tslint:disable-next-line:variable-name
-const any$1 = /* @__PURE__ */ op({ any_ });
+const any$2 = /* @__PURE__ */ op({ any_ });
 
 /**
  * @license
@@ -5895,7 +5934,7 @@ function argMax_(x, axis = 0) {
     const attrs = { axis };
     return ENGINE.runKernel(ArgMax, inputs, attrs);
 }
-const argMax$1 = /* @__PURE__ */ op({ argMax_ });
+const argMax$2 = /* @__PURE__ */ op({ argMax_ });
 
 /**
  * @license
@@ -6100,8 +6139,8 @@ function computeOutputShape2D(inShape, fieldSize, stride, zeroPad, roundingMode)
     }
     const inputRows = inShape[0];
     const inputCols = inShape[1];
-    const outputRows = round$1((inputRows - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
-    const outputCols = round$1((inputCols - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
+    const outputRows = round$2((inputRows - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
+    const outputCols = round$2((inputCols - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
     return [outputRows, outputCols];
 }
 function computeOutputShape4D(inShape, filterShape, outChannels, strides, zeroPad, roundingMode) {
@@ -6111,7 +6150,7 @@ function computeOutputShape4D(inShape, filterShape, outChannels, strides, zeroPa
     const outShape = [0, 0, 0, outChannels];
     for (let index = 0; index < 3; index++) {
         if (inShape[index] + 2 * zeroPad >= filterShape[index]) {
-            outShape[index] = round$1((inShape[index] - filterShape[index] + 2 * zeroPad) / strides[index] +
+            outShape[index] = round$2((inShape[index] - filterShape[index] + 2 * zeroPad) / strides[index] +
                 1, roundingMode);
         }
     }
@@ -6186,8 +6225,8 @@ function getPadAndOutInfo(pad, inHeight, inWidth, strideHeight, strideWidth, fil
             'VALID' :
             'EXPLICIT';
         padInfo = { top, bottom, left, right, type: padType };
-        outHeight = round$1((inHeight - filterHeight + top + bottom) / strideHeight + 1, roundingMode);
-        outWidth = round$1((inWidth - filterWidth + left + right) / strideWidth + 1, roundingMode);
+        outHeight = round$2((inHeight - filterHeight + top + bottom) / strideHeight + 1, roundingMode);
+        outWidth = round$2((inWidth - filterWidth + left + right) / strideWidth + 1, roundingMode);
     }
     else {
         throw Error(`Unknown padding parameter: ${pad}`);
@@ -6244,7 +6283,7 @@ function get3DPadAndOutInfo(pad, inDepth, inHeight, inWidth, strideDepth, stride
  * @param roundingMode A string from: 'ceil', 'round', 'floor'. If none is
  *     provided, it will default to truncate.
  */
-function round$1(value, roundingMode) {
+function round$2(value, roundingMode) {
     if (!roundingMode) {
         return Math.trunc(value);
     }
@@ -6376,7 +6415,7 @@ function reshape_(x, shape) {
     const attrs = { shape };
     return ENGINE.runKernel(Reshape$1, inputs, attrs);
 }
-const reshape$1 = /* @__PURE__ */ op({ reshape_ });
+const reshape$2 = /* @__PURE__ */ op({ reshape_ });
 
 /**
  * @license
@@ -6452,7 +6491,7 @@ function concat_(tensors, axis = 0) {
     const attr = { axis };
     return ENGINE.runKernel(Concat, inputs, attr);
 }
-const concat$1 = /* @__PURE__ */ op({ concat_ });
+const concat$2 = /* @__PURE__ */ op({ concat_ });
 
 /**
  * @license
@@ -6529,7 +6568,7 @@ function sigmoid_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Sigmoid$1, inputs);
 }
-const sigmoid$1 = /* @__PURE__ */ op({ sigmoid_ });
+const sigmoid$2 = /* @__PURE__ */ op({ sigmoid_ });
 
 /**
  * @license
@@ -6590,7 +6629,7 @@ function slice_(x, begin, size) {
     const attrs = { begin, size };
     return ENGINE.runKernel(Slice, inputs, attrs);
 }
-const slice$1 = /* @__PURE__ */ op({ slice_ });
+const slice$2 = /* @__PURE__ */ op({ slice_ });
 
 /**
  * @license
@@ -6625,7 +6664,7 @@ function tanh_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Tanh$1, inputs);
 }
-const tanh$1 = /* @__PURE__ */ op({ tanh_ });
+const tanh$2 = /* @__PURE__ */ op({ tanh_ });
 
 /**
  * @license
@@ -6702,7 +6741,7 @@ function batchToSpaceND_(x, blockShape, crops) {
     const attrs = { blockShape, crops };
     return ENGINE.runKernel(BatchToSpaceND, inputs, attrs);
 }
-const batchToSpaceND$1 = /* @__PURE__ */ op({ batchToSpaceND_ });
+const batchToSpaceND$2 = /* @__PURE__ */ op({ batchToSpaceND_ });
 
 /**
  * @license
@@ -6746,7 +6785,7 @@ function broadcastTo_(x, shape) {
         while (newShape.length < shape.length) {
             newShape.unshift(1);
         }
-        input = reshape$1(input, newShape);
+        input = reshape$2(input, newShape);
     }
     const inputShape = input.shape;
     const reps = Array.from(shape);
@@ -6799,7 +6838,7 @@ const broadcastTo = /* @__PURE__ */ op({ broadcastTo_ });
  *
  * @doc {heading: 'Tensors', subheading: 'Creation'}
  */
-function fill$1(shape, value, dtype) {
+function fill$2(shape, value, dtype) {
     assertNonNegativeIntegerDimensions(shape);
     dtype = dtype || inferDtype(value);
     const attrs = { shape, value, dtype };
@@ -6841,13 +6880,13 @@ function clipByValue_(x, clipValueMin, clipValueMax) {
     assert$1((clipValueMin <= clipValueMax), () => `Error in clip: min (${clipValueMin}) must be ` +
         `less than or equal to max (${clipValueMax}).`);
     if (clipValueMin === clipValueMax) {
-        return fill$1($x.shape, clipValueMin, $x.dtype);
+        return fill$2($x.shape, clipValueMin, $x.dtype);
     }
     const inputs = { x: $x };
     const attrs = { clipValueMin, clipValueMax };
     return ENGINE.runKernel(ClipByValue, inputs, attrs);
 }
-const clipByValue$1 = /* @__PURE__ */ op({ clipByValue_ });
+const clipByValue$2 = /* @__PURE__ */ op({ clipByValue_ });
 
 /**
  * @license
@@ -6893,7 +6932,7 @@ function complex_(real, imag) {
     const inputs = { real: $real, imag: $imag };
     return ENGINE.runKernel(Complex, inputs);
 }
-const complex$1 = /* @__PURE__ */ op({ complex_ });
+const complex$2 = /* @__PURE__ */ op({ complex_ });
 
 /**
  * @license
@@ -6950,7 +6989,7 @@ function conv2d_(x, filter, strides, pad, dataFormat = 'NHWC', dilations = [1, 1
     let reshapedTo4D = false;
     if ($x.rank === 3) {
         reshapedTo4D = true;
-        x4D = reshape$1($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
+        x4D = reshape$2($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
     }
     assert$1(x4D.rank === 4, () => `Error in conv2d: input must be rank 4, but got rank ${x4D.rank}.`);
     assert$1($filter.rank === 4, () => `Error in conv2d: filter must be rank 4, but got rank ` +
@@ -6968,7 +7007,7 @@ function conv2d_(x, filter, strides, pad, dataFormat = 'NHWC', dilations = [1, 1
     // tslint:disable-next-line: no-unnecessary-type-assertion
     const res = ENGINE.runKernel(Conv2D, inputs, attrs);
     if (reshapedTo4D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3]]);
     }
     return res;
 }
@@ -7022,7 +7061,7 @@ function conv2DBackpropInput_(xShape, dy, filter, strides, pad, dataFormat = 'NH
     let reshapedTo4D = false;
     if (dy.rank === 3) {
         reshapedTo4D = true;
-        dy4D = reshape$1(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
+        dy4D = reshape$2(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
         xShape4D = [1, xShape[0], xShape[1], xShape[2]];
     }
     assert$1(xShape4D.length === 4, () => `Error in conv2dDerInput: inShape must be length 4, but got length ` +
@@ -7043,11 +7082,11 @@ function conv2DBackpropInput_(xShape, dy, filter, strides, pad, dataFormat = 'NH
     // tslint:disable-next-line: no-unnecessary-type-assertion
     const res = ENGINE.runKernel(Conv2DBackpropInput, inputs, attrs);
     if (reshapedTo4D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3]]);
     }
     return res;
 }
-const conv2DBackpropInput$1 = /* @__PURE__ */ op({ conv2DBackpropInput_ });
+const conv2DBackpropInput$2 = /* @__PURE__ */ op({ conv2DBackpropInput_ });
 
 /**
  * @license
@@ -7091,7 +7130,7 @@ function conv3DBackpropInput_(xShape, dy, filter, strides, pad) {
     let reshapedTo5D = false;
     if (dy.rank === 4) {
         reshapedTo5D = true;
-        dy5D = reshape$1(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
+        dy5D = reshape$2(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
         xShape5D = [1, xShape[0], xShape[1], xShape[2], xShape[3]];
     }
     const inDepth = xShape5D[4];
@@ -7111,7 +7150,7 @@ function conv3DBackpropInput_(xShape, dy, filter, strides, pad) {
     // tslint:disable-next-line: no-unnecessary-type-assertion
     const res = ENGINE.runKernel(Conv3DBackpropInputV2, inputs, attrs);
     if (reshapedTo5D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
     }
     return res;
 }
@@ -7150,7 +7189,7 @@ function cos_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Cos, inputs);
 }
-const cos$1 = /* @__PURE__ */ op({ cos_ });
+const cos$2 = /* @__PURE__ */ op({ cos_ });
 
 /**
  * @license
@@ -7185,7 +7224,7 @@ function cosh_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Cosh, inputs);
 }
-const cosh$1 = /* @__PURE__ */ op({ cosh_ });
+const cosh$2 = /* @__PURE__ */ op({ cosh_ });
 
 /**
  * @license
@@ -7232,7 +7271,7 @@ function cumprod_(x, axis = 0, exclusive = false, reverse = false) {
     const attrs = { axis, exclusive, reverse };
     return ENGINE.runKernel(Cumprod, inputs, attrs);
 }
-const cumprod$1 = /* @__PURE__ */ op({ cumprod_ });
+const cumprod$2 = /* @__PURE__ */ op({ cumprod_ });
 
 /**
  * @license
@@ -7279,7 +7318,7 @@ function cumsum_(x, axis = 0, exclusive = false, reverse = false) {
     const attrs = { axis, exclusive, reverse };
     return ENGINE.runKernel(Cumsum, inputs, attrs);
 }
-const cumsum$1 = /* @__PURE__ */ op({ cumsum_ });
+const cumsum$2 = /* @__PURE__ */ op({ cumsum_ });
 
 /**
  * @license
@@ -7404,7 +7443,7 @@ function equal_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Equal, inputs);
 }
-const equal$1 = /* @__PURE__ */ op({ equal_ });
+const equal$2 = /* @__PURE__ */ op({ equal_ });
 
 /**
  * @license
@@ -7499,7 +7538,7 @@ function zerosLike_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(ZerosLike, inputs);
 }
-const zerosLike$1 = /* @__PURE__ */ op({ zerosLike_ });
+const zerosLike$2 = /* @__PURE__ */ op({ zerosLike_ });
 
 /**
  * @license
@@ -7534,7 +7573,7 @@ function elu_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Elu$1, inputs);
 }
-const elu$2 = /* @__PURE__ */ op({ elu_ });
+const elu$3 = /* @__PURE__ */ op({ elu_ });
 
 /**
  * @license
@@ -7569,12 +7608,12 @@ function erf_(x) {
     let $x = convertToTensor(x, 'x', 'erf');
     assert$1($x.dtype === 'int32' || $x.dtype === 'float32', () => 'Input dtype must be `int32` or `float32`.');
     if ($x.dtype === 'int32') {
-        $x = cast$2($x, 'float32');
+        $x = cast$3($x, 'float32');
     }
     const inputs = { x: $x };
     return ENGINE.runKernel(Erf, inputs);
 }
-const erf$1 = /* @__PURE__ */ op({ erf_ });
+const erf$2 = /* @__PURE__ */ op({ erf_ });
 
 /**
  * @license
@@ -7721,7 +7760,7 @@ function max_(x, axis = null, keepDims = false) {
     const attrs = { reductionIndices: axis, keepDims };
     return ENGINE.runKernel(Max, inputs, attrs);
 }
-const max$1 = /* @__PURE__ */ op({ max_ });
+const max$2 = /* @__PURE__ */ op({ max_ });
 
 /**
  * @license
@@ -7775,7 +7814,7 @@ function min_(x, axis = null, keepDims = false) {
     // tslint:disable-next-line: no-unnecessary-type-assertion
     return ENGINE.runKernel(Min, inputs, attrs);
 }
-const min$1 = /* @__PURE__ */ op({ min_ });
+const min$2 = /* @__PURE__ */ op({ min_ });
 
 /**
  * @license
@@ -7828,7 +7867,7 @@ function pow_(base, exp) {
     const inputs = { a: $base, b: $exp };
     return ENGINE.runKernel(Pow, inputs);
 }
-const pow$1 = /* @__PURE__ */ op({ pow_ });
+const pow$2 = /* @__PURE__ */ op({ pow_ });
 
 /**
  * @license
@@ -7975,7 +8014,7 @@ function sqrt_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Sqrt, inputs);
 }
-const sqrt$1 = /* @__PURE__ */ op({ sqrt_ });
+const sqrt$2 = /* @__PURE__ */ op({ sqrt_ });
 
 /**
  * @license
@@ -8061,13 +8100,13 @@ const square$2 = /* @__PURE__ */ op({ square_ });
 function sum_(x, axis = null, keepDims = false) {
     let $x = convertToTensor(x, 'x', 'sum');
     if ($x.dtype === 'bool') {
-        $x = cast$2($x, 'int32');
+        $x = cast$3($x, 'int32');
     }
     const inputs = { x: $x };
     const attrs = { axis, keepDims };
     return ENGINE.runKernel(Sum, inputs, attrs);
 }
-const sum$1 = /* @__PURE__ */ op({ sum_ });
+const sum$2 = /* @__PURE__ */ op({ sum_ });
 
 /**
  * @license
@@ -8131,48 +8170,48 @@ function norm_(x, ord = 'euclidean', axis = null, keepDims = false) {
         const axes = parseAxisParam(axis, x.shape);
         keepDimsShape = expandShapeToKeepDim(norm.shape, axes);
     }
-    return reshape$1(norm, keepDimsShape);
+    return reshape$2(norm, keepDimsShape);
 }
 function normImpl(x, p, axis = null) {
     if (x.rank === 0) {
-        return abs$1(x);
+        return abs$2(x);
     }
     // consider vector when no axis is specified
     if (x.rank !== 1 && axis === null) {
-        return normImpl(reshape$1(x, [-1]), p, axis);
+        return normImpl(reshape$2(x, [-1]), p, axis);
     }
     // vector
     if (x.rank === 1 || typeof axis === 'number' ||
         Array.isArray(axis) && axis.length === 1) {
         if (p === 1) {
-            return sum$1(abs$1(x), axis);
+            return sum$2(abs$2(x), axis);
         }
         if (p === Infinity) {
-            return max$1(abs$1(x), axis);
+            return max$2(abs$2(x), axis);
         }
         if (p === -Infinity) {
-            return min$1(abs$1(x), axis);
+            return min$2(abs$2(x), axis);
         }
         if (p === 'euclidean' || p === 2) {
             // norm(x, 2) = sum(abs(xi) ^ 2) ^ 1/2
-            return sqrt$1(sum$1(pow$1(abs$1(x), scalar(2, 'int32')), axis));
+            return sqrt$2(sum$2(pow$2(abs$2(x), scalar(2, 'int32')), axis));
         }
         throw new Error(`Error in norm: invalid ord value: ${p}`);
     }
     // matrix (assumption axis[0] < axis[1])
     if (Array.isArray(axis) && axis.length === 2) {
         if (p === 1) {
-            return max$1(sum$1(abs$1(x), axis[0]), axis[1] - 1);
+            return max$2(sum$2(abs$2(x), axis[0]), axis[1] - 1);
         }
         if (p === Infinity) {
-            return max$1(sum$1(abs$1(x), axis[1]), axis[0]);
+            return max$2(sum$2(abs$2(x), axis[1]), axis[0]);
         }
         if (p === -Infinity) {
-            return min$1(sum$1(abs$1(x), axis[1]), axis[0]);
+            return min$2(sum$2(abs$2(x), axis[1]), axis[0]);
         }
         if (p === 'fro' || p === 'euclidean') {
             // norm(x) = sqrt(sum(pow(x, 2)))
-            return sqrt$1(sum$1(square$2(x), axis));
+            return sqrt$2(sum$2(square$2(x), axis));
         }
         throw new Error(`Error in norm: invalid ord value: ${p}`);
     }
@@ -8213,7 +8252,7 @@ function exp_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Exp, inputs);
 }
-const exp$1 = /* @__PURE__ */ op({ exp_ });
+const exp$2 = /* @__PURE__ */ op({ exp_ });
 
 /**
  * @license
@@ -8254,7 +8293,7 @@ function expandDims_(x, axis = 0) {
     const attrs = { dim: axis };
     return ENGINE.runKernel(ExpandDims, inputs, attrs);
 }
-const expandDims$2 = /* @__PURE__ */ op({ expandDims_ });
+const expandDims$3 = /* @__PURE__ */ op({ expandDims_ });
 
 /**
  * @license
@@ -8305,7 +8344,7 @@ function tile_(x, reps) {
     const attrs = { reps };
     return ENGINE.runKernel(Tile, inputs, attrs);
 }
-const tile$2 = /* @__PURE__ */ op({ tile_ });
+const tile$3 = /* @__PURE__ */ op({ tile_ });
 
 /**
  * @license
@@ -8346,21 +8385,21 @@ function eye_(numRows, numColumns, batchShape, dtype = 'float32') {
     for (let i = 0; i < n; ++i) {
         buff.set(1, i, i);
     }
-    const out = reshape$1(buff.toTensor(), [numRows, numColumns]);
+    const out = reshape$2(buff.toTensor(), [numRows, numColumns]);
     if (batchShape == null) {
         return out;
     }
     else {
         if (batchShape.length === 1) {
-            return tile$2(expandDims$2(out, 0), [batchShape[0], 1, 1]);
+            return tile$3(expandDims$3(out, 0), [batchShape[0], 1, 1]);
         }
         else if (batchShape.length === 2) {
             // tslint:disable-next-line:no-unnecessary-type-assertion
-            return tile$2(expandDims$2(expandDims$2(out, 0), 0), [batchShape[0], batchShape[1], 1, 1]);
+            return tile$3(expandDims$3(expandDims$3(out, 0), 0), [batchShape[0], batchShape[1], 1, 1]);
         }
         else if (batchShape.length === 3) {
             // tslint:disable-next-line:no-unnecessary-type-assertion
-            return tile$2(expandDims$2(expandDims$2(expandDims$2(out, 0), 0), 0), [
+            return tile$3(expandDims$3(expandDims$3(expandDims$3(out, 0), 0), 0), [
                 batchShape[0], batchShape[1], batchShape[2], 1, 1
             ]);
         }
@@ -8406,7 +8445,7 @@ function floor_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Floor, inputs);
 }
-const floor$1 = /* @__PURE__ */ op({ floor_ });
+const floor$2 = /* @__PURE__ */ op({ floor_ });
 
 /**
  * @license
@@ -8498,7 +8537,7 @@ function greater_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Greater, inputs);
 }
-const greater$1 = /* @__PURE__ */ op({ greater_ });
+const greater$2 = /* @__PURE__ */ op({ greater_ });
 
 /**
  * @license
@@ -8539,7 +8578,7 @@ function greaterEqual_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(GreaterEqual, inputs);
 }
-const greaterEqual$1 = /* @__PURE__ */ op({ greaterEqual_ });
+const greaterEqual$2 = /* @__PURE__ */ op({ greaterEqual_ });
 
 /**
  * @license
@@ -8576,7 +8615,7 @@ function imag_(input) {
     const inputs = { input: $input };
     return ENGINE.runKernel(Imag, inputs);
 }
-const imag$1 = /* @__PURE__ */ op({ imag_ });
+const imag$2 = /* @__PURE__ */ op({ imag_ });
 
 /**
  * @license
@@ -8617,7 +8656,7 @@ function leakyRelu_(x, alpha = 0.2) {
     const attrs = { alpha };
     return ENGINE.runKernel(LeakyRelu, inputs, attrs);
 }
-const leakyRelu$1 = /* @__PURE__ */ op({ leakyRelu_ });
+const leakyRelu$2 = /* @__PURE__ */ op({ leakyRelu_ });
 
 /**
  * @license
@@ -8657,7 +8696,7 @@ function less_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Less, inputs);
 }
-const less$1 = /* @__PURE__ */ op({ less_ });
+const less$2 = /* @__PURE__ */ op({ less_ });
 
 /**
  * @license
@@ -8698,7 +8737,7 @@ function lessEqual_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(LessEqual, inputs);
 }
-const lessEqual$1 = /* @__PURE__ */ op({ lessEqual_ });
+const lessEqual$2 = /* @__PURE__ */ op({ lessEqual_ });
 
 /**
  * @license
@@ -8733,7 +8772,7 @@ function log_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Log, inputs);
 }
-const log$1 = /* @__PURE__ */ op({ log_ });
+const log$2 = /* @__PURE__ */ op({ log_ });
 
 /**
  * @license
@@ -8769,7 +8808,7 @@ function log1p_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Log1p, inputs);
 }
-const log1p$1 = /* @__PURE__ */ op({ log1p_ });
+const log1p$2 = /* @__PURE__ */ op({ log1p_ });
 
 /**
  * @license
@@ -8935,7 +8974,7 @@ function neg_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Neg, inputs);
 }
-const neg$1 = /* @__PURE__ */ op({ neg_ });
+const neg$2 = /* @__PURE__ */ op({ neg_ });
 
 /**
  * @license
@@ -8970,7 +9009,7 @@ function softplus_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Softplus$1, inputs);
 }
-const softplus$1 = /* @__PURE__ */ op({ softplus_ });
+const softplus$2 = /* @__PURE__ */ op({ softplus_ });
 
 /**
  * @license
@@ -9018,7 +9057,7 @@ function sub_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Sub, inputs);
 }
-const sub$1 = /* @__PURE__ */ op({ sub_ });
+const sub$2 = /* @__PURE__ */ op({ sub_ });
 
 /**
  * @license
@@ -9079,15 +9118,15 @@ function logSoftmax_(logits, axis = -1) {
     // Use a custom gradient for numerical stability.
     const customOp = customGrad((logits, save) => {
         const keepDims = true;
-        const xMax = max$1(logits, axis, true);
-        const shifted = sub$1(logits, xMax);
-        const value = sub$1(cast$2(shifted, 'float32'), log$1(sum$1(exp$1(shifted), axis, keepDims)));
+        const xMax = max$2(logits, axis, true);
+        const shifted = sub$2(logits, xMax);
+        const value = sub$2(cast$3(shifted, 'float32'), log$2(sum$2(exp$2(shifted), axis, keepDims)));
         save([value]);
         const gradFunc = (dy, saved) => {
             const [value] = saved;
             const keepDims = true;
-            const softmax = exp$1(value);
-            return sub$1(dy, mul(sum$1(dy, axis, keepDims), softmax));
+            const softmax = exp$2(value);
+            return sub$2(dy, mul(sum$2(dy, axis, keepDims), softmax));
         };
         return { value, gradFunc };
     });
@@ -9139,7 +9178,7 @@ function logicalAnd_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(LogicalAnd, inputs);
 }
-const logicalAnd$1 = /* @__PURE__ */ op({ logicalAnd_ });
+const logicalAnd$2 = /* @__PURE__ */ op({ logicalAnd_ });
 
 /**
  * @license
@@ -9175,7 +9214,7 @@ function logicalNot_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(LogicalNot, inputs);
 }
-const logicalNot$1 = /* @__PURE__ */ op({ logicalNot_ });
+const logicalNot$2 = /* @__PURE__ */ op({ logicalNot_ });
 
 /**
  * @license
@@ -9225,14 +9264,14 @@ function maximum_(a, b) {
     let $b = convertToTensor(b, 'b', 'maximum');
     [$a, $b] = makeTypesMatch($a, $b);
     if ($a.dtype === 'bool') {
-        $a = cast$2($a, 'int32');
-        $b = cast$2($b, 'int32');
+        $a = cast$3($a, 'int32');
+        $b = cast$3($b, 'int32');
     }
     assertAndGetBroadcastShape($a.shape, $b.shape);
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Maximum, inputs);
 }
-const maximum$1 = /* @__PURE__ */ op({ maximum_ });
+const maximum$2 = /* @__PURE__ */ op({ maximum_ });
 
 /**
  * @license
@@ -9285,7 +9324,7 @@ function mean_(x, axis = null, keepDims = false) {
     const attrs = { axis, keepDims };
     return ENGINE.runKernel(Mean, inputs, attrs);
 }
-const mean = /* @__PURE__ */ op({ mean_ });
+const mean$1 = /* @__PURE__ */ op({ mean_ });
 
 /**
  * @license
@@ -9316,12 +9355,12 @@ const mean = /* @__PURE__ */ op({ mean_ });
  *
  * @doc {heading: 'Tensors', subheading: 'Creation'}
  */
-function zeros(shape, dtype = 'float32') {
+function zeros$1(shape, dtype = 'float32') {
     assertNonNegativeIntegerDimensions(shape);
     if (dtype === 'complex64') {
-        const real = zeros(shape, 'float32');
-        const imag = zeros(shape, 'float32');
-        return complex$1(real, imag);
+        const real = zeros$1(shape, 'float32');
+        const imag = zeros$1(shape, 'float32');
+        return complex$2(real, imag);
     }
     const values = makeZerosTypedArray(sizeFromShape(shape), dtype);
     return ENGINE.makeTensor(values, shape, dtype);
@@ -9360,8 +9399,8 @@ function ones(shape, dtype = 'float32') {
     assertNonNegativeIntegerDimensions(shape);
     if (dtype === 'complex64') {
         const real = ones(shape, 'float32');
-        const imag = zeros(shape, 'float32');
-        return complex$1(real, imag);
+        const imag = zeros$1(shape, 'float32');
+        return complex$2(real, imag);
     }
     const values = makeOnesTypedArray(sizeFromShape(shape), dtype);
     return ENGINE.makeTensor(values, shape, dtype);
@@ -9415,14 +9454,14 @@ function minimum_(a, b) {
     let $b = convertToTensor(b, 'b', 'minimum');
     [$a, $b] = makeTypesMatch($a, $b);
     if ($a.dtype === 'bool') {
-        $a = cast$2($a, 'int32');
-        $b = cast$2($b, 'int32');
+        $a = cast$3($a, 'int32');
+        $b = cast$3($b, 'int32');
     }
     assertAndGetBroadcastShape($a.shape, $b.shape);
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(Minimum, inputs);
 }
-const minimum$1 = /* @__PURE__ */ op({ minimum_ });
+const minimum$2 = /* @__PURE__ */ op({ minimum_ });
 
 /**
  * @license
@@ -9462,7 +9501,7 @@ function notEqual_(a, b) {
     const inputs = { a: $a, b: $b };
     return ENGINE.runKernel(NotEqual, inputs);
 }
-const notEqual$1 = /* @__PURE__ */ op({ notEqual_ });
+const notEqual$2 = /* @__PURE__ */ op({ notEqual_ });
 
 /**
  * @license
@@ -9513,7 +9552,7 @@ function oneHot_(indices, depth, onValue = 1, offValue = 0, dtype = 'int32') {
     const attrs = { dtype, depth, onValue, offValue };
     return ENGINE.runKernel(OneHot, inputs, attrs);
 }
-const oneHot$1 = /* @__PURE__ */ op({ oneHot_ });
+const oneHot$2 = /* @__PURE__ */ op({ oneHot_ });
 
 /**
  * @license
@@ -9548,7 +9587,7 @@ function onesLike_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(OnesLike, inputs);
 }
-const onesLike$1 = /* @__PURE__ */ op({ onesLike_ });
+const onesLike$2 = /* @__PURE__ */ op({ onesLike_ });
 
 /**
  * @license
@@ -9683,7 +9722,7 @@ function spaceToBatchND_(x, blockShape, paddings) {
     const attrs = { blockShape, paddings };
     return ENGINE.runKernel(SpaceToBatchND, inputs, attrs);
 }
-const spaceToBatchND$1 = /* @__PURE__ */ op({ spaceToBatchND_ });
+const spaceToBatchND$2 = /* @__PURE__ */ op({ spaceToBatchND_ });
 
 /**
  * @license
@@ -9723,7 +9762,7 @@ function prelu_(x, alpha) {
     const inputs = { x: $x, alpha: $alpha };
     return ENGINE.runKernel(Prelu, inputs);
 }
-const prelu$1 = /* @__PURE__ */ op({ prelu_ });
+const prelu$2 = /* @__PURE__ */ op({ prelu_ });
 
 var alea$1 = {exports: {}};
 
@@ -10907,7 +10946,7 @@ const randomUniform = /* @__PURE__ */ op({ randomUniform_ });
  *
  * @doc {heading: 'Tensors', subheading: 'Creation'}
  */
-function range$2(start, stop, step = 1, dtype = 'float32') {
+function range$3(start, stop, step = 1, dtype = 'float32') {
     if (step === 0) {
         throw new Error('Cannot have a step of zero');
     }
@@ -10951,7 +10990,7 @@ function real_(input) {
     const inputs = { input: $input };
     return ENGINE.runKernel(Real, inputs);
 }
-const real$1 = /* @__PURE__ */ op({ real_ });
+const real$2 = /* @__PURE__ */ op({ real_ });
 
 /**
  * @license
@@ -10987,7 +11026,7 @@ function relu_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Relu$1, inputs);
 }
-const relu$1 = /* @__PURE__ */ op({ relu_ });
+const relu$2 = /* @__PURE__ */ op({ relu_ });
 
 /**
  * @license
@@ -11023,7 +11062,7 @@ function relu6_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Relu6$1, inputs);
 }
-const relu6$1 = /* @__PURE__ */ op({ relu6_ });
+const relu6$2 = /* @__PURE__ */ op({ relu6_ });
 
 /**
  * @license
@@ -11078,7 +11117,7 @@ function reverse_(x, axis) {
     const attrs = { dims: axis };
     return ENGINE.runKernel(Reverse, inputs, attrs);
 }
-const reverse$1 = /* @__PURE__ */ op({ reverse_ });
+const reverse$2 = /* @__PURE__ */ op({ reverse_ });
 
 /**
  * @license
@@ -11114,7 +11153,7 @@ function rsqrt_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Rsqrt, inputs);
 }
-const rsqrt$1 = /* @__PURE__ */ op({ rsqrt_ });
+const rsqrt$2 = /* @__PURE__ */ op({ rsqrt_ });
 
 /**
  * @license
@@ -11151,7 +11190,7 @@ function selu_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Selu$1, inputs);
 }
-const selu$1 = /* @__PURE__ */ op({ selu_ });
+const selu$2 = /* @__PURE__ */ op({ selu_ });
 
 /**
  * @license
@@ -11186,7 +11225,7 @@ function sin_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Sin, inputs);
 }
-const sin$1 = /* @__PURE__ */ op({ sin_ });
+const sin$2 = /* @__PURE__ */ op({ sin_ });
 
 /**
  * @license
@@ -11221,7 +11260,7 @@ function sinh_(x) {
     const inputs = { x: $x };
     return ENGINE.runKernel(Sinh, inputs);
 }
-const sinh$1 = /* @__PURE__ */ op({ sinh_ });
+const sinh$2 = /* @__PURE__ */ op({ sinh_ });
 
 /**
  * @license
@@ -11246,7 +11285,7 @@ const sinh$1 = /* @__PURE__ */ op({ sinh_ });
 function slice1d_(x, begin, size) {
     const $x = convertToTensor(x, 'x', 'slice1d');
     assert$1($x.rank === 1, () => `slice1d expects a rank-1 tensor, but got a rank-${$x.rank} tensor`);
-    return slice$1($x, [begin], [size]);
+    return slice$2($x, [begin], [size]);
 }
 const slice1d = /* @__PURE__ */ op({ slice1d_ });
 
@@ -11273,7 +11312,7 @@ const slice1d = /* @__PURE__ */ op({ slice1d_ });
 function slice2d_(x, begin, size) {
     const $x = convertToTensor(x, 'x', 'slice2d');
     assert$1($x.rank === 2, () => `slice2d expects a rank-2 tensor, but got a rank-${$x.rank} tensor`);
-    return slice$1($x, begin, size);
+    return slice$2($x, begin, size);
 }
 const slice2d = /* @__PURE__ */ op({ slice2d_ });
 
@@ -11300,7 +11339,7 @@ const slice2d = /* @__PURE__ */ op({ slice2d_ });
 function slice3d_(x, begin, size) {
     const $x = convertToTensor(x, 'x', 'slice3d');
     assert$1($x.rank === 3, () => `slice3d expects a rank-3 tensor, but got a rank-${$x.rank} tensor`);
-    return slice$1($x, begin, size);
+    return slice$2($x, begin, size);
 }
 const slice3d = /* @__PURE__ */ op({ slice3d_ });
 
@@ -11327,7 +11366,7 @@ const slice3d = /* @__PURE__ */ op({ slice3d_ });
 function slice4d_(x, begin, size) {
     const $x = convertToTensor(x, 'x', 'slice4d');
     assert$1($x.rank === 4, () => `slice4d expects a rank-4 tensor, but got a rank-${$x.rank} tensor`);
-    return slice$1($x, begin, size);
+    return slice$2($x, begin, size);
 }
 const slice4d = /* @__PURE__ */ op({ slice4d_ });
 
@@ -11381,7 +11420,7 @@ function softmax_(logits, dim = -1) {
     const attrs = { dim };
     return ENGINE.runKernel(Softmax$1, inputs, attrs);
 }
-const softmax$1 = /* @__PURE__ */ op({ softmax_ });
+const softmax$2 = /* @__PURE__ */ op({ softmax_ });
 
 /**
  * @license
@@ -11475,7 +11514,7 @@ const split$1 = /* @__PURE__ */ op({ split_ });
  */
 function squeeze_(x, axis) {
     const $x = convertToTensor(x, 'x', 'squeeze', 'string_or_numeric');
-    return reshape$1($x, squeezeShape($x.shape, axis).newShape);
+    return reshape$2($x, squeezeShape($x.shape, axis).newShape);
 }
 const squeeze = /* @__PURE__ */ op({ squeeze_ });
 
@@ -11557,7 +11596,7 @@ function step_(x, alpha = 0.0) {
     const attrs = { alpha };
     return ENGINE.runKernel(Step, inputs, attrs);
 }
-const step$1 = /* @__PURE__ */ op({ step_ });
+const step$2 = /* @__PURE__ */ op({ step_ });
 
 /**
  * @license
@@ -12044,7 +12083,7 @@ function unsortedSegmentSum_(x, segmentIds, numSegments) {
     const attrs = { numSegments };
     return ENGINE.runKernel(UnsortedSegmentSum, inputs, attrs);
 }
-const unsortedSegmentSum$1 = /* @__PURE__ */ op({ unsortedSegmentSum_ });
+const unsortedSegmentSum$2 = /* @__PURE__ */ op({ unsortedSegmentSum_ });
 
 /**
  * @license
@@ -12138,7 +12177,7 @@ function variable(initialValue, trainable = true, name, dtype) {
  * =============================================================================
  */
 /** An implementation of the Where kernel shared between cpu and webgl */
-function whereImpl$1(condShape, condVals) {
+function whereImpl$2(condShape, condVals) {
     const indices = [];
     for (let i = 0; i < condVals.length; i++) {
         if (condVals[i]) {
@@ -12209,19 +12248,19 @@ function transpose_(x, perm, conjugate) {
     const attrs = { perm };
     if ($x.dtype === 'complex64') {
         return tidy(() => {
-            let $real = real$1($x);
-            let $imag = imag$1($x);
+            let $real = real$2($x);
+            let $imag = imag$2($x);
             $real = ENGINE.runKernel(Transpose, { x: $real }, attrs);
             $imag = ENGINE.runKernel(Transpose, { x: $imag }, attrs);
             if (conjugate) {
-                $imag = neg$1($imag);
+                $imag = neg$2($imag);
             }
-            return complex$1($real, $imag);
+            return complex$2($real, $imag);
         });
     }
     return ENGINE.runKernel(Transpose, inputs, attrs);
 }
-const transpose$1 = /* @__PURE__ */ op({ transpose_ });
+const transpose$2 = /* @__PURE__ */ op({ transpose_ });
 
 /**
  * @license
@@ -12317,7 +12356,7 @@ function dropout_(x, rate, noiseShape, seed) {
     }
     const $noiseShape = getNoiseShape($x, noiseShape);
     const keepProb = 1 - rate;
-    const multiplier = div(floor$1(add(randomUniform($noiseShape, 0, 1, 'float32', seed), keepProb)), keepProb);
+    const multiplier = div$1(floor$2(add$1(randomUniform($noiseShape, 0, 1, 'float32', seed), keepProb)), keepProb);
     return mul($x, multiplier);
 }
 const dropout$2 = /* @__PURE__ */ op({ dropout_ });
@@ -12361,11 +12400,11 @@ const dropout$2 = /* @__PURE__ */ op({ dropout_ });
 function conv2DBackpropFilter_(x, dy, filterShape, strides, pad, dataFormat = 'NHWC', dimRoundingMode) {
     let x4D = x;
     if (x.rank === 3) {
-        x4D = reshape$1(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
+        x4D = reshape$2(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
     }
     let dy4D = dy;
     if (dy4D.rank === 3) {
-        dy4D = reshape$1(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
+        dy4D = reshape$2(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
     }
     assert$1(x4D.rank === 4, () => `Error in conv2dDerFilter: input must be rank 4, but got shape ` +
         `${x4D.shape}.`);
@@ -12385,7 +12424,7 @@ function conv2DBackpropFilter_(x, dy, filterShape, strides, pad, dataFormat = 'N
     // tslint:disable-next-line: no-unnecessary-type-assertion
     return ENGINE.runKernel(Conv2DBackpropFilter, inputs, attrs);
 }
-const conv2DBackpropFilter$1 = /* @__PURE__ */ op({ conv2DBackpropFilter_ });
+const conv2DBackpropFilter$2 = /* @__PURE__ */ op({ conv2DBackpropFilter_ });
 
 /**
  * @license
@@ -12409,7 +12448,7 @@ function getFusedDyActivation(dy, y, activation) {
         return dy;
     }
     if (activation === 'relu') {
-        return mul(dy, step$1(y));
+        return mul(dy, step$2(y));
     }
     throw new Error(`Cannot compute gradient for fused activation ${activation}.`);
 }
@@ -12418,31 +12457,31 @@ function getFusedBiasGradient(bias, dyActivation) {
     let res = dyActivation;
     const reduceAxes = getReductionAxes(bias.shape, dyActivation.shape);
     if (reduceAxes.length > 0) {
-        res = sum$1(res, reduceAxes);
+        res = sum$2(res, reduceAxes);
     }
-    return reshape$1(res, bias.shape);
+    return reshape$2(res, bias.shape);
 }
-function applyActivation(x, activation, preluActivationWeights, leakyreluAlpha) {
+function applyActivation$1(x, activation, preluActivationWeights, leakyreluAlpha) {
     if (activation === 'linear') {
         return x;
     }
     else if (activation === 'relu') {
-        return relu$1(x);
+        return relu$2(x);
     }
     else if (activation === 'elu') {
-        return elu$2(x);
+        return elu$3(x);
     }
     else if (activation === 'relu6') {
-        return relu6$1(x);
+        return relu6$2(x);
     }
     else if (activation === 'prelu') {
-        return prelu$1(x, preluActivationWeights);
+        return prelu$2(x, preluActivationWeights);
     }
     else if (activation === 'leakyrelu') {
-        return leakyRelu$1(x, leakyreluAlpha);
+        return leakyRelu$2(x, leakyreluAlpha);
     }
     else if (activation === 'sigmoid') {
-        return sigmoid$1(x);
+        return sigmoid$2(x);
     }
     throw new Error(`Unknown fused activation ${activation}.`);
 }
@@ -12471,18 +12510,18 @@ const shouldFuse = (gradientDepth, activation) => {
 function depthwiseConv2dNativeBackpropFilter_(x, dy, filterShape, strides, pad, dilations = [1, 1], dimRoundingMode) {
     let x4D = x;
     if (x.rank === 3) {
-        x4D = reshape$1(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
+        x4D = reshape$2(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
     }
     let dy4D = dy;
     if (dy4D.rank === 3) {
-        dy4D = reshape$1(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
+        dy4D = reshape$2(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
     }
     const inputs = { x: x4D, dy: dy4D };
     const attrs = { strides, pad, dimRoundingMode, dilations, filterShape };
     // tslint:disable-next-line: no-unnecessary-type-assertion
     return ENGINE.runKernel(DepthwiseConv2dNativeBackpropFilter, inputs, attrs);
 }
-const depthwiseConv2dNativeBackpropFilter$1 = op({ depthwiseConv2dNativeBackpropFilter_ });
+const depthwiseConv2dNativeBackpropFilter$2 = op({ depthwiseConv2dNativeBackpropFilter_ });
 
 /**
  * @license
@@ -12505,7 +12544,7 @@ function depthwiseConv2dNativeBackpropInput_(xShape, dy, filter, strides, pad, d
     let reshapedTo4D = false;
     if (dy.rank === 3) {
         reshapedTo4D = true;
-        dy4D = reshape$1(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
+        dy4D = reshape$2(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
     }
     const inputs = { dy: dy4D, filter };
     const attrs = { strides, pad, dimRoundingMode, dilations, inputShape: xShape };
@@ -12513,11 +12552,11 @@ function depthwiseConv2dNativeBackpropInput_(xShape, dy, filter, strides, pad, d
     // tslint:disable-next-line: no-unnecessary-type-assertion
     ENGINE.runKernel(DepthwiseConv2dNativeBackpropInput, inputs, attrs);
     if (reshapedTo4D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3]]);
     }
     return res;
 }
-const depthwiseConv2dNativeBackpropInput$1 = op({ depthwiseConv2dNativeBackpropInput_ });
+const depthwiseConv2dNativeBackpropInput$2 = op({ depthwiseConv2dNativeBackpropInput_ });
 
 /**
  * @license
@@ -12560,9 +12599,9 @@ function fusedMatMul_({ a, b, transposeA = false, transposeB = false, bias, acti
     if (shouldFuse(ENGINE.state.gradientDepth, activation) === false) {
         let result = matMul$1(a, b, transposeA, transposeB);
         if (bias != null) {
-            result = add(result, bias);
+            result = add$1(result, bias);
         }
-        return applyActivation(result, activation, preluActivationWeights, leakyreluAlpha);
+        return applyActivation$1(result, activation, preluActivationWeights, leakyreluAlpha);
     }
     let $a = convertToTensor(a, 'a', 'fused matMul');
     let $b = convertToTensor(b, 'b', 'fused matMul');
@@ -12582,11 +12621,11 @@ function fusedMatMul_({ a, b, transposeA = false, transposeB = false, bias, acti
     const outShapeOuterDims = assertAndGetBroadcastShape($a.shape.slice(0, -2), $b.shape.slice(0, -2));
     const outShape = outShapeOuterDims.concat([outerShapeA, outerShapeB]);
     const a3D = transposeA ?
-        reshape$1($a, [batchDimA, innerShapeA, outerShapeA]) :
-        reshape$1($a, [batchDimA, outerShapeA, innerShapeA]);
+        reshape$2($a, [batchDimA, innerShapeA, outerShapeA]) :
+        reshape$2($a, [batchDimA, outerShapeA, innerShapeA]);
     const b3D = transposeB ?
-        reshape$1($b, [batchDimB, outerShapeB, innerShapeB]) :
-        reshape$1($b, [batchDimB, innerShapeB, outerShapeB]);
+        reshape$2($b, [batchDimB, outerShapeB, innerShapeB]) :
+        reshape$2($b, [batchDimB, innerShapeB, outerShapeB]);
     let $bias;
     if (bias != null) {
         $bias = convertToTensor(bias, 'bias', 'fused matMul');
@@ -12602,7 +12641,7 @@ function fusedMatMul_({ a, b, transposeA = false, transposeB = false, bias, acti
         // we reshape dy because the result of the forward is not
         // necessarily going to be a 3d tensor due to a reshape done at the end of
         // the customOp.
-        const dyActivation = getFusedDyActivation(reshape$1(dy, y.shape), y, activation);
+        const dyActivation = getFusedDyActivation(reshape$2(dy, y.shape), y, activation);
         let aDer;
         let bDer;
         if (!transposeA && !transposeB) {
@@ -12644,7 +12683,7 @@ function fusedMatMul_({ a, b, transposeA = false, transposeB = false, bias, acti
             // tslint:disable-next-line: no-unnecessary-type-assertion
             ENGINE.runKernel(_FusedMatMul, inputs, attrs);
             save([a3D, b3D, res]);
-            return { value: reshape$1(res, outShape), gradFunc: grad };
+            return { value: reshape$2(res, outShape), gradFunc: grad };
         });
         return customOp(a3D, b3D);
     }
@@ -12654,7 +12693,7 @@ function fusedMatMul_({ a, b, transposeA = false, transposeB = false, bias, acti
             // tslint:disable-next-line: no-unnecessary-type-assertion
             ENGINE.runKernel(_FusedMatMul, inputs, attrs);
             save([a3D, b3D, res, $bias]);
-            return { value: reshape$1(res, outShape), gradFunc: grad };
+            return { value: reshape$2(res, outShape), gradFunc: grad };
         });
         return customOpWithBias(a3D, b3D, $bias);
     }
@@ -12760,14 +12799,14 @@ function binarySearch_(arr, target, comparator) {
  * limitations under the License.
  * =============================================================================
  */
-function nonMaxSuppressionV3Impl$1(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold) {
+function nonMaxSuppressionV3Impl$2(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold) {
     return nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, 0 /* softNmsSigma */);
 }
-function nonMaxSuppressionV4Impl$1(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize) {
+function nonMaxSuppressionV4Impl$2(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize) {
     return nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, 0 /* softNmsSigma */, false /* returnScoresTensor */, padToMaxOutputSize /* padToMaxOutputSize */, true
     /* returnValidOutputs */ );
 }
-function nonMaxSuppressionV5Impl$1(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma) {
+function nonMaxSuppressionV5Impl$2(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma) {
     return nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma, true /* returnScoresTensor */);
 }
 function nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma, returnScoresTensor = false, padToMaxOutputSize = false, returnValidOutputs = false) {
@@ -12961,7 +13000,7 @@ function bandPart_(a, numLower, numUpper) {
         assert$1(numLower.dtype === 'int32', () => `bandPart(): numLower's dtype must be an int32.`);
         // If numLower is a Scalar, checking `numLower <= M` could hurt performance,
         // but minimum(numLower, M) could avoid unexpected results.
-        $numLower = where(less$1(numLower, 0), M, minimum$1(numLower, M));
+        $numLower = where(less$2(numLower, 0), M, minimum$2(numLower, M));
     }
     if (typeof numUpper === 'number') {
         assert$1(numUpper % 1 === 0, () => `bandPart(): numUpper must be an integer, got ${numUpper}.`);
@@ -12972,14 +13011,14 @@ function bandPart_(a, numLower, numUpper) {
     }
     else {
         assert$1(numUpper.dtype === 'int32', () => `bandPart(): numUpper's dtype must be an int32.`);
-        $numUpper = where(less$1(numUpper, 0), N, minimum$1(numUpper, N));
+        $numUpper = where(less$2(numUpper, 0), N, minimum$2(numUpper, N));
     }
-    const i = reshape$1(range$2(0, M, 1, 'int32'), [-1, 1]);
-    const j = range$2(0, N, 1, 'int32');
-    const ij = sub$1(i, j);
-    const inBand = logicalAnd$1(lessEqual$1(ij, $numLower), greaterEqual$1(ij, neg$1($numUpper)));
-    const zero = zeros([M, N], $a.dtype);
-    return reshape$1(stack(unstack(reshape$1($a, [-1, M, N]))
+    const i = reshape$2(range$3(0, M, 1, 'int32'), [-1, 1]);
+    const j = range$3(0, N, 1, 'int32');
+    const ij = sub$2(i, j);
+    const inBand = logicalAnd$2(lessEqual$2(ij, $numLower), greaterEqual$2(ij, neg$2($numUpper)));
+    const zero = zeros$1([M, N], $a.dtype);
+    return reshape$2(stack(unstack(reshape$2($a, [-1, M, N]))
         .map(mat => where(inBand, mat, zero))), shape);
 }
 const bandPart = /* @__PURE__ */ op({ bandPart_ });
@@ -13053,11 +13092,11 @@ function gramSchmidt_(xs) {
             let x = xs1d[i];
             if (i > 0) {
                 for (let j = 0; j < i; ++j) {
-                    const proj = mul(sum$1(mul(ys[j], x)), ys[j]);
-                    x = sub$1(x, proj);
+                    const proj = mul(sum$2(mul(ys[j], x)), ys[j]);
+                    x = sub$2(x, proj);
                 }
             }
-            return div(x, norm(x, 'euclidean'));
+            return div$1(x, norm(x, 'euclidean'));
         }));
     }
     if (inputIsTensor2D) {
@@ -13140,7 +13179,7 @@ function qr_(x, fullMatrices = false) {
         //   together. We should explore whether this can be parallelized.
         const outerDimsProd = x.shape.slice(0, x.shape.length - 2)
             .reduce((value, prev) => value * prev);
-        const x2ds = unstack(reshape$1(x, [
+        const x2ds = unstack(reshape$2(x, [
             outerDimsProd, x.shape[x.shape.length - 2],
             x.shape[x.shape.length - 1]
         ]), 0);
@@ -13151,8 +13190,8 @@ function qr_(x, fullMatrices = false) {
             q2ds.push(q2d);
             r2ds.push(r2d);
         });
-        const q = reshape$1(stack(q2ds, 0), x.shape);
-        const r = reshape$1(stack(r2ds, 0), x.shape);
+        const q = reshape$2(stack(q2ds, 0), x.shape);
+        const r = reshape$2(stack(r2ds, 0), x.shape);
         return [q, r];
     }
 }
@@ -13174,50 +13213,50 @@ function qr2d(x, fullMatrices = false) {
             const qTemp = q;
             [w, r, q] = ENGINE.tidy(() => {
                 // Find H = I - tau * w * w', to put zeros below R(j, j).
-                const rjEnd1 = slice$1(r, [j, j], [m - j, 1]);
+                const rjEnd1 = slice$2(r, [j, j], [m - j, 1]);
                 const normX = norm(rjEnd1);
-                const rjj = slice$1(r, [j, j], [1, 1]);
+                const rjj = slice$2(r, [j, j], [1, 1]);
                 // The sign() function returns 0 on 0, which causes division by zero.
-                const s = where(greater$1(rjj, 0), tensor2d([[-1]]), tensor2d([[1]]));
-                const u1 = sub$1(rjj, mul(s, normX));
-                const wPre = div(rjEnd1, u1);
+                const s = where(greater$2(rjj, 0), tensor2d([[-1]]), tensor2d([[1]]));
+                const u1 = sub$2(rjj, mul(s, normX));
+                const wPre = div$1(rjEnd1, u1);
                 if (wPre.shape[0] === 1) {
                     w = clone(one2D);
                 }
                 else {
-                    w = concat$1([
+                    w = concat$2([
                         one2D,
-                        slice$1(wPre, [1, 0], [wPre.shape[0] - 1, wPre.shape[1]])
+                        slice$2(wPre, [1, 0], [wPre.shape[0] - 1, wPre.shape[1]])
                     ], 0);
                 }
-                const tau = neg$1(div(matMul$1(s, u1), normX));
+                const tau = neg$2(div$1(matMul$1(s, u1), normX));
                 // -- R := HR, Q := QH.
-                const rjEndAll = slice$1(r, [j, 0], [m - j, n]);
+                const rjEndAll = slice$2(r, [j, 0], [m - j, n]);
                 const tauTimesW = mul(tau, w);
-                const wT = transpose$1(w);
+                const wT = transpose$2(w);
                 if (j === 0) {
-                    r = sub$1(rjEndAll, matMul$1(tauTimesW, matMul$1(wT, rjEndAll)));
+                    r = sub$2(rjEndAll, matMul$1(tauTimesW, matMul$1(wT, rjEndAll)));
                 }
                 else {
-                    const rTimesTau = sub$1(rjEndAll, matMul$1(tauTimesW, matMul$1(wT, rjEndAll)));
-                    r = concat$1([slice$1(r, [0, 0], [j, n]), rTimesTau], 0);
+                    const rTimesTau = sub$2(rjEndAll, matMul$1(tauTimesW, matMul$1(wT, rjEndAll)));
+                    r = concat$2([slice$2(r, [0, 0], [j, n]), rTimesTau], 0);
                 }
-                const tawTimesWT = transpose$1(tauTimesW);
-                const qAllJEnd = slice$1(q, [0, j], [m, q.shape[1] - j]);
+                const tawTimesWT = transpose$2(tauTimesW);
+                const qAllJEnd = slice$2(q, [0, j], [m, q.shape[1] - j]);
                 if (j === 0) {
-                    q = sub$1(qAllJEnd, matMul$1(matMul$1(qAllJEnd, w), tawTimesWT));
+                    q = sub$2(qAllJEnd, matMul$1(matMul$1(qAllJEnd, w), tawTimesWT));
                 }
                 else {
-                    const qTimesTau = sub$1(qAllJEnd, matMul$1(matMul$1(qAllJEnd, w), tawTimesWT));
-                    q = concat$1([slice$1(q, [0, 0], [m, j]), qTimesTau], 1);
+                    const qTimesTau = sub$2(qAllJEnd, matMul$1(matMul$1(qAllJEnd, w), tawTimesWT));
+                    q = concat$2([slice$2(q, [0, 0], [m, j]), qTimesTau], 1);
                 }
                 return [w, r, q];
             });
             dispose([rTemp, wTemp, qTemp]);
         }
         if (!fullMatrices && m > n) {
-            q = slice$1(q, [0, 0], [m, n]);
-            r = slice$1(r, [0, 0], [n, n]);
+            q = slice$2(q, [0, 0], [m, n]);
+            r = slice$2(r, [0, 0], [n, n]);
         }
         return [q, r];
     });
@@ -13270,7 +13309,7 @@ function stringToHashBucketFast_(input, numBuckets) {
     const inputs = { input: $input };
     return ENGINE.runKernel(StringToHashBucketFast, inputs, attrs);
 }
-const stringToHashBucketFast$1 = /* @__PURE__ */ op({ stringToHashBucketFast_ });
+const stringToHashBucketFast$2 = /* @__PURE__ */ op({ stringToHashBucketFast_ });
 
 /**
  * @license
@@ -13657,13 +13696,13 @@ class AdadeltaOptimizer extends Optimizer {
             if (this.accumulatedGrads[i] == null) {
                 this.accumulatedGrads[i] = {
                     originalName: `${name}/accum_grad`,
-                    variable: tidy(() => zerosLike$1(value).variable(trainable))
+                    variable: tidy(() => zerosLike$2(value).variable(trainable))
                 };
             }
             if (this.accumulatedUpdates[i] == null) {
                 this.accumulatedUpdates[i] = {
                     originalName: `${name}/accum_var`,
-                    variable: tidy(() => zerosLike$1(value).variable(trainable))
+                    variable: tidy(() => zerosLike$2(value).variable(trainable))
                 };
             }
             const gradient = Array.isArray(variableGradients) ?
@@ -13675,12 +13714,12 @@ class AdadeltaOptimizer extends Optimizer {
             const accumulatedGrad = this.accumulatedGrads[i].variable;
             const accumulatedUpdate = this.accumulatedUpdates[i].variable;
             tidy(() => {
-                const newAccumulatedGrad = add(mul(accumulatedGrad, this.rho), mul(square$2(gradient), 1 - this.rho));
-                const updates = mul(div(sqrt$1(add(accumulatedUpdate, this.epsilon)), sqrt$1(add(accumulatedGrad, this.epsilon))), gradient);
-                const newAccumulatedUpdate = add(mul(accumulatedUpdate, this.rho), mul(square$2(updates), 1 - this.rho));
+                const newAccumulatedGrad = add$1(mul(accumulatedGrad, this.rho), mul(square$2(gradient), 1 - this.rho));
+                const updates = mul(div$1(sqrt$2(add$1(accumulatedUpdate, this.epsilon)), sqrt$2(add$1(accumulatedGrad, this.epsilon))), gradient);
+                const newAccumulatedUpdate = add$1(mul(accumulatedUpdate, this.rho), mul(square$2(updates), 1 - this.rho));
                 accumulatedGrad.assign(newAccumulatedGrad);
                 accumulatedUpdate.assign(newAccumulatedUpdate);
-                const newValue = add(mul(updates, -this.learningRate), value);
+                const newValue = add$1(mul(updates, -this.learningRate), value);
                 value.assign(newValue);
             });
         });
@@ -13767,7 +13806,7 @@ class AdagradOptimizer extends Optimizer {
                 const trainable = false;
                 this.accumulatedGrads[i] = {
                     originalName: `${name}/accumulator`,
-                    variable: tidy(() => fill$1(value.shape, this.initialAccumulatorValue)
+                    variable: tidy(() => fill$2(value.shape, this.initialAccumulatorValue)
                         .variable(trainable))
                 };
             }
@@ -13779,9 +13818,9 @@ class AdagradOptimizer extends Optimizer {
             }
             const accumulatedGrad = this.accumulatedGrads[i].variable;
             tidy(() => {
-                const newAccumulatedGrad = add(accumulatedGrad, square$2(gradient));
+                const newAccumulatedGrad = add$1(accumulatedGrad, square$2(gradient));
                 accumulatedGrad.assign(newAccumulatedGrad);
-                const newValue = add(mul(div(gradient, sqrt$1(add(newAccumulatedGrad, ENGINE.backend.epsilon()))), -this.learningRate), value);
+                const newValue = add$1(mul(div$1(gradient, sqrt$2(add$1(newAccumulatedGrad, ENGINE.backend.epsilon()))), -this.learningRate), value);
                 value.assign(newValue);
             });
         });
@@ -13859,21 +13898,21 @@ class AdamOptimizer extends Optimizer {
             variableGradients.map(v => v.name) :
             Object.keys(variableGradients);
         tidy(() => {
-            const oneMinusAccBeta1 = sub$1(1, this.accBeta1);
-            const oneMinusAccBeta2 = sub$1(1, this.accBeta2);
+            const oneMinusAccBeta1 = sub$2(1, this.accBeta1);
+            const oneMinusAccBeta2 = sub$2(1, this.accBeta2);
             varNames.forEach((name, i) => {
                 const value = ENGINE.registeredVariables[name];
                 const trainable = false;
                 if (this.accumulatedFirstMoment[i] == null) {
                     this.accumulatedFirstMoment[i] = {
                         originalName: `${name}/m`,
-                        variable: tidy(() => zerosLike$1(value).variable(trainable))
+                        variable: tidy(() => zerosLike$2(value).variable(trainable))
                     };
                 }
                 if (this.accumulatedSecondMoment[i] == null) {
                     this.accumulatedSecondMoment[i] = {
                         originalName: `${name}/v`,
-                        variable: tidy(() => zerosLike$1(value).variable(trainable))
+                        variable: tidy(() => zerosLike$2(value).variable(trainable))
                     };
                 }
                 const gradient = Array.isArray(variableGradients) ?
@@ -13884,13 +13923,13 @@ class AdamOptimizer extends Optimizer {
                 }
                 const firstMoment = this.accumulatedFirstMoment[i].variable;
                 const secondMoment = this.accumulatedSecondMoment[i].variable;
-                const newFirstMoment = add(mul(firstMoment, this.beta1), mul(gradient, 1 - this.beta1));
-                const newSecondMoment = add(mul(secondMoment, this.beta2), mul(square$2(gradient), 1 - this.beta2));
-                const biasCorrectedFirstMoment = div(newFirstMoment, oneMinusAccBeta1);
-                const biasCorrectedSecondMoment = div(newSecondMoment, oneMinusAccBeta2);
+                const newFirstMoment = add$1(mul(firstMoment, this.beta1), mul(gradient, 1 - this.beta1));
+                const newSecondMoment = add$1(mul(secondMoment, this.beta2), mul(square$2(gradient), 1 - this.beta2));
+                const biasCorrectedFirstMoment = div$1(newFirstMoment, oneMinusAccBeta1);
+                const biasCorrectedSecondMoment = div$1(newSecondMoment, oneMinusAccBeta2);
                 firstMoment.assign(newFirstMoment);
                 secondMoment.assign(newSecondMoment);
-                const newValue = add(mul(div(biasCorrectedFirstMoment, add(sqrt$1(biasCorrectedSecondMoment), this.epsilon)), -this.learningRate), value);
+                const newValue = add$1(mul(div$1(biasCorrectedFirstMoment, add$1(sqrt$2(biasCorrectedSecondMoment), this.epsilon)), -this.learningRate), value);
                 value.assign(newValue);
             });
             this.accBeta1.assign(mul(this.accBeta1, this.beta1));
@@ -13916,8 +13955,8 @@ class AdamOptimizer extends Optimizer {
     async setWeights(weightValues) {
         weightValues = await this.extractIterations(weightValues);
         tidy(() => {
-            this.accBeta1.assign(pow$1(this.beta1, this.iterations_ + 1));
-            this.accBeta2.assign(pow$1(this.beta2, this.iterations_ + 1));
+            this.accBeta1.assign(pow$2(this.beta1, this.iterations_ + 1));
+            this.accBeta2.assign(pow$2(this.beta2, this.iterations_ + 1));
         });
         const variableCount = weightValues.length / 2;
         const trainable = false;
@@ -13993,21 +14032,21 @@ class AdamaxOptimizer extends Optimizer {
             variableGradients.map(item => item.name) :
             Object.keys(variableGradients);
         tidy(() => {
-            const oneMinusAccBeta1 = sub$1(1, this.accBeta1);
-            const lr = div(-this.learningRate, add(mul(this.iteration, this.decay), 1));
+            const oneMinusAccBeta1 = sub$2(1, this.accBeta1);
+            const lr = div$1(-this.learningRate, add$1(mul(this.iteration, this.decay), 1));
             variableNames.forEach((name, i) => {
                 const value = ENGINE.registeredVariables[name];
                 const trainable = false;
                 if (this.accumulatedFirstMoment[i] == null) {
                     this.accumulatedFirstMoment[i] = {
                         originalName: `${name}/m`,
-                        variable: zerosLike$1(value).variable(trainable)
+                        variable: zerosLike$2(value).variable(trainable)
                     };
                 }
                 if (this.accumulatedWeightedInfNorm[i] == null) {
                     this.accumulatedWeightedInfNorm[i] = {
                         originalName: `${name}/v`,
-                        variable: zerosLike$1(value).variable(trainable)
+                        variable: zerosLike$2(value).variable(trainable)
                     };
                 }
                 const gradient = Array.isArray(variableGradients) ?
@@ -14018,16 +14057,16 @@ class AdamaxOptimizer extends Optimizer {
                 }
                 const firstMoment = this.accumulatedFirstMoment[i].variable;
                 const weightedInfNorm = this.accumulatedWeightedInfNorm[i].variable;
-                const newFirstMoment = add(mul(firstMoment, this.beta1), mul(gradient, 1 - this.beta1));
+                const newFirstMoment = add$1(mul(firstMoment, this.beta1), mul(gradient, 1 - this.beta1));
                 const ut0 = mul(weightedInfNorm, this.beta2);
-                const ut1 = abs$1(gradient);
-                const newWeightedInfNorm = maximum$1(ut0, ut1);
+                const ut1 = abs$2(gradient);
+                const newWeightedInfNorm = maximum$2(ut0, ut1);
                 firstMoment.assign(newFirstMoment);
                 weightedInfNorm.assign(newWeightedInfNorm);
-                const newValue = add(mul(div(lr, oneMinusAccBeta1), div(newFirstMoment, add(newWeightedInfNorm, this.epsilon))), value);
+                const newValue = add$1(mul(div$1(lr, oneMinusAccBeta1), div$1(newFirstMoment, add$1(newWeightedInfNorm, this.epsilon))), value);
                 value.assign(newValue);
             });
-            this.iteration.assign(add(this.iteration, 1));
+            this.iteration.assign(add$1(this.iteration, 1));
             this.accBeta1.assign(mul(this.accBeta1, this.beta1));
         });
         this.incrementIterations();
@@ -14106,7 +14145,7 @@ class SGDOptimizer extends Optimizer {
             }
             const value = ENGINE.registeredVariables[name];
             tidy(() => {
-                const newValue = add(mul(this.c, gradient), value);
+                const newValue = add$1(mul(this.c, gradient), value);
                 value.assign(newValue);
             });
         });
@@ -14187,7 +14226,7 @@ class MomentumOptimizer extends SGDOptimizer {
                 const trainable = false;
                 this.accumulations[i] = {
                     originalName: `${name}/momentum`,
-                    variable: tidy(() => zerosLike$1(value).variable(trainable))
+                    variable: tidy(() => zerosLike$2(value).variable(trainable))
                 };
             }
             const accumulation = this.accumulations[i].variable;
@@ -14199,12 +14238,12 @@ class MomentumOptimizer extends SGDOptimizer {
             }
             tidy(() => {
                 let newValue;
-                const newAccumulation = add(mul(this.m, accumulation), gradient);
+                const newAccumulation = add$1(mul(this.m, accumulation), gradient);
                 if (this.useNesterov) {
-                    newValue = add(mul(this.c, add(gradient, mul(newAccumulation, this.m))), value);
+                    newValue = add$1(mul(this.c, add$1(gradient, mul(newAccumulation, this.m))), value);
                 }
                 else {
-                    newValue = add(mul(this.c, newAccumulation), value);
+                    newValue = add$1(mul(this.c, newAccumulation), value);
                 }
                 accumulation.assign(newAccumulation);
                 value.assign(newValue);
@@ -14300,19 +14339,19 @@ class RMSPropOptimizer extends Optimizer {
             if (this.accumulatedMeanSquares[i] == null) {
                 this.accumulatedMeanSquares[i] = {
                     originalName: `${name}/rms`,
-                    variable: tidy(() => zerosLike$1(value).variable(trainable))
+                    variable: tidy(() => zerosLike$2(value).variable(trainable))
                 };
             }
             if (this.accumulatedMoments[i] == null) {
                 this.accumulatedMoments[i] = {
                     originalName: `${name}/momentum`,
-                    variable: tidy(() => zerosLike$1(value).variable(trainable))
+                    variable: tidy(() => zerosLike$2(value).variable(trainable))
                 };
             }
             if (this.accumulatedMeanGrads[i] == null && this.centered) {
                 this.accumulatedMeanGrads[i] = {
                     originalName: `${name}/mg`,
-                    variable: tidy(() => zerosLike$1(value).variable(trainable))
+                    variable: tidy(() => zerosLike$2(value).variable(trainable))
                 };
             }
             const gradient = Array.isArray(variableGradients) ?
@@ -14324,26 +14363,26 @@ class RMSPropOptimizer extends Optimizer {
             const accumulatedMeanSquare = this.accumulatedMeanSquares[i].variable;
             const accumulatedMoments = this.accumulatedMoments[i].variable;
             tidy(() => {
-                const newAccumulatedMeanSquare = add(mul(accumulatedMeanSquare, this.decay), mul(square$2(gradient), 1 - this.decay));
+                const newAccumulatedMeanSquare = add$1(mul(accumulatedMeanSquare, this.decay), mul(square$2(gradient), 1 - this.decay));
                 if (this.centered) {
                     const accumulatedMeanGrad = this.accumulatedMeanGrads[i].variable;
                     // Centered gradient
-                    const newAccumulatedMeanGrad = add(mul(accumulatedMeanGrad, this.decay), mul(gradient, 1 - this.decay));
-                    const gradContribution = div(mul(gradient, this.learningRate), sqrt$1(sub$1(newAccumulatedMeanSquare, add(square$2(newAccumulatedMeanGrad), this.epsilon))));
-                    const newAccumulatedMoments = add(mul(accumulatedMoments, this.momentum), gradContribution);
+                    const newAccumulatedMeanGrad = add$1(mul(accumulatedMeanGrad, this.decay), mul(gradient, 1 - this.decay));
+                    const gradContribution = div$1(mul(gradient, this.learningRate), sqrt$2(sub$2(newAccumulatedMeanSquare, add$1(square$2(newAccumulatedMeanGrad), this.epsilon))));
+                    const newAccumulatedMoments = add$1(mul(accumulatedMoments, this.momentum), gradContribution);
                     accumulatedMeanSquare.assign(newAccumulatedMeanSquare);
                     accumulatedMeanGrad.assign(newAccumulatedMeanGrad);
                     accumulatedMoments.assign(newAccumulatedMoments);
-                    const newValue = sub$1(value, newAccumulatedMoments);
+                    const newValue = sub$2(value, newAccumulatedMoments);
                     value.assign(newValue);
                 }
                 else {
                     // Plain gradient
-                    const newAccumulatedMeanSquare = add(mul(accumulatedMeanSquare, this.decay), mul(square$2(gradient), 1 - this.decay));
-                    const newAccumulatedMoments = add(mul(accumulatedMoments, this.momentum), div(mul(gradient, this.learningRate), sqrt$1(add(newAccumulatedMeanSquare, this.epsilon))));
+                    const newAccumulatedMeanSquare = add$1(mul(accumulatedMeanSquare, this.decay), mul(square$2(gradient), 1 - this.decay));
+                    const newAccumulatedMoments = add$1(mul(accumulatedMoments, this.momentum), div$1(mul(gradient, this.learningRate), sqrt$2(add$1(newAccumulatedMeanSquare, this.epsilon))));
                     accumulatedMeanSquare.assign(newAccumulatedMeanSquare);
                     accumulatedMoments.assign(newAccumulatedMoments);
-                    const newValue = sub$1(value, newAccumulatedMoments);
+                    const newValue = sub$2(value, newAccumulatedMoments);
                     value.assign(newValue);
                 }
             });
@@ -14871,7 +14910,7 @@ function decodeWeight(spec, byteBuffer) {
             }
             const realTensor = tensor(real, shape, 'float32');
             const imageTensor = tensor(image, shape, 'float32');
-            const complexTensor = complex$1(realTensor, imageTensor);
+            const complexTensor = complex$2(realTensor, imageTensor);
             realTensor.dispose();
             imageTensor.dispose();
             return complexTensor;
@@ -17867,7 +17906,7 @@ var backend_util = /*#__PURE__*/Object.freeze({
     get RowPartitionType () { return RowPartitionType$1; },
     SELU_SCALE: SELU_SCALE,
     SELU_SCALEALPHA: SELU_SCALEALPHA,
-    applyActivation: applyActivation,
+    applyActivation: applyActivation$1,
     assertAndGetBroadcastShape: assertAndGetBroadcastShape,
     assertAxesAreInnerMostDims: assertAxesAreInnerMostDims,
     assertParamsConsistent: assertParamsConsistent,
@@ -17928,7 +17967,7 @@ var backend_util = /*#__PURE__*/Object.freeze({
     getSparseSegmentReductionSegmentIdOutOfRangeErrorMessage: getSparseSegmentReductionSegmentIdOutOfRangeErrorMessage,
     getUndoAxesPermutation: getUndoAxesPermutation,
     isIdentityPermutation: isIdentityPermutation,
-    log: log$2,
+    log: log$3,
     mergeRealAndImagArrays: mergeRealAndImagArrays,
     prepareAndValidate: prepareAndValidate,
     prepareSplitSize: prepareSplitSize,
@@ -18726,7 +18765,7 @@ function isWebGLFenceEnabled(webGLVersion) {
     const isEnabled = gl.fenceSync != null;
     return isEnabled;
 }
-function assertNotComplex(tensor, opName) {
+function assertNotComplex$1(tensor, opName) {
     if (!Array.isArray(tensor)) {
         tensor = [tensor];
     }
@@ -22273,6 +22312,33 @@ function linearSearchLastTrue(arr) {
     return i - 1;
 }
 
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function assertNotComplex(tensor, opName) {
+    if (!Array.isArray(tensor)) {
+        tensor = [tensor];
+    }
+    tensor.forEach(t => {
+        if (t != null) {
+            assert$1(t.dtype !== 'complex64', () => `${opName} does not support complex64 tensors in the CPU backend.`);
+        }
+    });
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -22296,6 +22362,20 @@ function simpleAbsImpl(vals) {
     }
     return resultValues;
 }
+const abs$1 = (args) => {
+    const { x } = args.inputs;
+    const cpuBackend = args.backend;
+    assertNotComplex(x, 'abs');
+    let resultValues = new Float32Array(sizeFromShape(x.shape));
+    const values = cpuBackend.data.get(x.dataId).values;
+    resultValues = simpleAbsImpl(values);
+    return cpuBackend.makeOutput(resultValues, x.shape, x.dtype);
+};
+const absConfig$1 = {
+    kernelName: Abs,
+    backendName: 'cpu',
+    kernelFunc: abs$1,
+};
 
 /**
  * @license
@@ -22350,6 +22430,136 @@ function createSimpleBinaryKernelImpl(op) {
     };
 }
 
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function complex$1(args) {
+    const { inputs, backend } = args;
+    const { real, imag } = inputs;
+    const realVals = backend.data.get(real.dataId).values;
+    const imagVals = backend.data.get(imag.dataId).values;
+    const complexInfo = backend.makeTensorInfo(real.shape, 'complex64');
+    const complex = backend.data.get(complexInfo.dataId);
+    // The complex tensor owns the underlying real and imag tensorInfos, only the
+    // complex tensor tracks refCount, when complexData is disposed the
+    // underlying tensorData will be disposed.
+    complex.complexTensorInfos = {
+        real: backend.makeTensorInfo(real.shape, 'float32', realVals),
+        imag: backend.makeTensorInfo(imag.shape, 'float32', imagVals)
+    };
+    return complexInfo;
+}
+const complexConfig$1 = {
+    kernelName: Complex,
+    backendName: 'cpu',
+    kernelFunc: complex$1
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * Generates a tensorInfo with all zeros value.
+ * @param backend cpu backend.
+ * @param shape Shape for the zeros tensor.
+ * @param dtype Optional. If set, the result has this dtype.
+ */
+function zeros(backend, shape, dtype = 'float32') {
+    if (dtype === 'complex64') {
+        const real = zeros(backend, shape, 'float32');
+        const imag = zeros(backend, shape, 'float32');
+        return complex$1({ inputs: { real, imag }, backend });
+    }
+    const values = makeZerosTypedArray(sizeFromShape(shape), dtype);
+    return backend.makeTensorInfo(shape, dtype, values);
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function identity$1(args) {
+    const { inputs, backend } = args;
+    const { x } = inputs;
+    backend.incRef(x.dataId);
+    return { dataId: x.dataId, shape: x.shape, dtype: x.dtype };
+}
+const identityConfig$1 = {
+    kernelName: Identity$1,
+    backendName: 'cpu',
+    kernelFunc: identity$1
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function real$1(args) {
+    const { inputs, backend } = args;
+    const { input } = inputs;
+    const real = backend.data.get(input.dataId).complexTensorInfos.real;
+    const realVal = backend.data.get(real.dataId).values;
+    // When complex tensor is disposed, its underlying parts will be disposed too.
+    // Make new tensor out of the real value of the complex. This makes sure the
+    // value is still accessible even if complex tensor is disposed.
+    return backend.makeTensorInfo(real.shape, real.dtype, realVal);
+}
+const realConfig$1 = {
+    kernelName: Real,
+    backendName: 'cpu',
+    kernelFunc: real$1
+};
+
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -22381,6 +22591,174 @@ function castImpl(values, shape, inputType, dtype) {
     }
     throw new Error(`Error in Cast: failed to cast ${inputType} to ${dtype}`);
 }
+function cast$2(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { dtype } = attrs;
+    // Casting to complex64.
+    if (dtype === 'complex64') {
+        if (x.dtype === 'complex64') {
+            return identity$1({ inputs: { x }, backend });
+        }
+        const zerosTensorInfo = zeros(backend, x.shape, x.dtype);
+        const floatX = cast$2({ inputs: { x }, backend, attrs: { dtype: 'float32' } });
+        const result = complex$1({ inputs: { real: floatX, imag: zerosTensorInfo }, backend });
+        backend.disposeIntermediateTensorInfo(zerosTensorInfo);
+        backend.disposeIntermediateTensorInfo(floatX);
+        return result;
+    }
+    // Casting from complex64
+    if (x.dtype === 'complex64') {
+        const realPart = real$1({ inputs: { input: x }, backend });
+        const result = cast$2({ inputs: { x: realPart }, backend, attrs: { dtype } });
+        backend.disposeIntermediateTensorInfo(realPart);
+        return result;
+    }
+    if (!hasEncodingLoss(x.dtype, dtype)) {
+        // We don't change the underlying data, since we cast to higher
+        // precision.
+        const result = identity$1({ inputs: { x }, backend });
+        return { dataId: result.dataId, shape: result.shape, dtype };
+    }
+    const values = backend.data.get(x.dataId).values;
+    const [resultShape, resultType, resultData] = castImpl(values, x.shape, x.dtype, dtype);
+    return backend.makeTensorInfo(resultShape, resultType, resultData);
+}
+const castConfig$1 = {
+    kernelName: Cast,
+    backendName: 'cpu',
+    kernelFunc: cast$2
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * Template that creates a `KernelFunc` for binary ops.
+ * @param name Kernel name.
+ * @param binaryKernelImpl A `SimpleBinaryKernelImpl` for the kernel.
+ * @param binaryKernelComplexImpl Optional. If exists, represents a
+ *     `ComplexBinaryKernelImpl` for the kernel, will be used when input dtype
+ *     is `complex64`.
+ * @param dtype Optional. If set, the result has this dtype. Otherwise, the
+ *     result has the same dtype as the first input. This is mainly used in
+ *     comparison kernels, such as Equal, Less, Greater, etc.
+ */
+function binaryKernelFunc$1(name, simpleImpl, complexImpl, dtype) {
+    if (complexImpl == null) {
+        return ({ inputs, backend }) => {
+            const { a, b } = inputs;
+            const cpuBackend = backend;
+            assertNotComplex([a, b], name);
+            const aVals = cpuBackend.data.get(a.dataId).values;
+            const bVals = cpuBackend.data.get(b.dataId).values;
+            const decodedAVals = a.dtype === 'string' ?
+                // tslint:disable-next-line: no-any
+                fromUint8ToStringArray(aVals) :
+                aVals;
+            const decodedBVals = a.dtype === 'string' ?
+                // tslint:disable-next-line: no-any
+                fromUint8ToStringArray(bVals) :
+                bVals;
+            const $dtype = dtype || a.dtype;
+            const [resultData, resultShape] = simpleImpl(a.shape, b.shape, decodedAVals, decodedBVals, $dtype);
+            return cpuBackend.makeTensorInfo(resultShape, $dtype, resultData);
+        };
+    }
+    return ({ inputs, backend }) => {
+        const { a, b } = inputs;
+        const cpuBackend = backend;
+        if (a.dtype === 'complex64' || b.dtype === 'complex64') {
+            const $aComplex = cast$2({ inputs: { x: a }, backend: cpuBackend, attrs: { dtype: 'complex64' } });
+            const $aComplexVals = cpuBackend.data.get($aComplex.dataId);
+            const aReal = $aComplexVals.complexTensorInfos.real;
+            const aImag = $aComplexVals.complexTensorInfos.imag;
+            const aRealVals = cpuBackend.data.get(aReal.dataId).values;
+            const aImagVals = cpuBackend.data.get(aImag.dataId).values;
+            const $bComplex = cast$2({ inputs: { x: b }, backend: cpuBackend, attrs: { dtype: 'complex64' } });
+            const $bComplexVals = cpuBackend.data.get($bComplex.dataId);
+            const bReal = $bComplexVals.complexTensorInfos.real;
+            const bImag = $bComplexVals.complexTensorInfos.imag;
+            const bRealVals = cpuBackend.data.get(bReal.dataId).values;
+            const bImagVals = cpuBackend.data.get(bImag.dataId).values;
+            const [resultRealData, resultImagData, resultShape] = complexImpl(a.shape, b.shape, aRealVals, aImagVals, bRealVals, bImagVals);
+            const resultReal = cpuBackend.makeTensorInfo(resultShape, 'float32', resultRealData);
+            const resultImag = cpuBackend.makeTensorInfo(resultShape, 'float32', resultImagData);
+            const result = complex$1({ inputs: { real: resultReal, imag: resultImag }, backend: cpuBackend });
+            cpuBackend.disposeIntermediateTensorInfo($aComplex);
+            cpuBackend.disposeIntermediateTensorInfo($bComplex);
+            cpuBackend.disposeIntermediateTensorInfo(resultReal);
+            cpuBackend.disposeIntermediateTensorInfo(resultImag);
+            return result;
+        }
+        else {
+            const aVals = cpuBackend.data.get(a.dataId).values;
+            const bVals = cpuBackend.data.get(b.dataId).values;
+            const $dtype = dtype || a.dtype;
+            const [resultData, resultShape] = simpleImpl(a.shape, b.shape, aVals, bVals, $dtype);
+            return cpuBackend.makeTensorInfo(resultShape, $dtype, resultData);
+        }
+    };
+}
+/**
+ * Template that creates the complex type implementation for binary ops.
+ * Supports broadcast.
+ */
+function createComplexBinaryKernelImpl(op) {
+    return (aShape, bShape, aRealVals, aImagVals, bRealVals, bImagVals) => {
+        const resultShape = assertAndGetBroadcastShape(aShape, bShape);
+        const resultSize = sizeFromShape(resultShape);
+        const resultRank = resultShape.length;
+        const resultStrides = computeStrides(resultShape);
+        const resultRealVals = getTypedArrayFromDType('float32', resultSize);
+        const resultImagVals = getTypedArrayFromDType('float32', resultSize);
+        const aBroadcastDims = getBroadcastDims$1(aShape, resultShape);
+        const bBroadcastDims = getBroadcastDims$1(bShape, resultShape);
+        const aVals = mergeRealAndImagArrays(aRealVals, aImagVals);
+        const bVals = mergeRealAndImagArrays(bRealVals, bImagVals);
+        const aRank = aShape.length;
+        const aStrides = computeStrides(aShape);
+        const bRank = bShape.length;
+        const bStrides = computeStrides(bShape);
+        if (aBroadcastDims.length + bBroadcastDims.length === 0) {
+            for (let i = 0; i < resultRealVals.length; i++) {
+                const aIdx = i % aVals.length;
+                const bIdx = i % bVals.length;
+                const result = op(aVals[aIdx * 2], aVals[aIdx * 2 + 1], bVals[bIdx * 2], bVals[bIdx * 2 + 1]);
+                resultRealVals[i] = result.real;
+                resultImagVals[i] = result.imag;
+            }
+        }
+        else {
+            for (let i = 0; i < resultRealVals.length; i++) {
+                const loc = indexToLoc(i, resultRank, resultStrides);
+                const aLoc = loc.slice(-aRank);
+                aBroadcastDims.forEach(d => aLoc[d] = 0);
+                const aIndex = locToIndex(aLoc, aRank, aStrides);
+                const bLoc = loc.slice(-bRank);
+                bBroadcastDims.forEach(d => bLoc[d] = 0);
+                const bIndex = locToIndex(bLoc, bRank, bStrides);
+                const opResult = op(aVals[aIndex * 2], aVals[aIndex * 2 + 1], bVals[bIndex * 2], bVals[bIndex * 2 + 1]);
+                resultRealVals[i] = opResult.real;
+                resultImagVals[i] = opResult.imag;
+            }
+        }
+        return [resultRealVals, resultImagVals, resultShape];
+    };
+}
 
 /**
  * @license
@@ -22399,6 +22777,15 @@ function castImpl(values, shape, inputType, dtype) {
  * =============================================================================
  */
 const addImpl = createSimpleBinaryKernelImpl(((a, b) => a + b));
+const addComplexImpl = createComplexBinaryKernelImpl(((aReal, aImag, bReal, bImag) => {
+    return { real: aReal + bReal, imag: aImag + bImag };
+}));
+const add = binaryKernelFunc$1(Add, addImpl, addComplexImpl);
+const addConfig$1 = {
+    kernelName: Add,
+    backendName: 'cpu',
+    kernelFunc: add
+};
 
 /**
  * @license
@@ -22482,6 +22869,12 @@ function bincountReduceImpl(xBuf, weightsBuf, size, binaryOutput = false) {
  * =============================================================================
  */
 const bitwiseAndImpl = createSimpleBinaryKernelImpl(((a, b) => a & b));
+const bitwiseAnd$1 = binaryKernelFunc$1(BitwiseAnd, bitwiseAndImpl);
+const bitwiseAndConfig$1 = {
+    kernelName: BitwiseAnd,
+    backendName: 'cpu',
+    kernelFunc: bitwiseAnd$1
+};
 
 /**
  * @license
@@ -22512,6 +22905,65 @@ function createSimpleUnaryImpl(op) {
     };
 }
 
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * Template that creates a `KernelFunc` for unary ops.
+ * @param name Kernel name.
+ * @param op A `SimpleUnaryOperation` for the kernel.
+ * @param dtype Optional. If set, the result has this dtype. Otherwise, the
+ *     result has the same dtype as the input. This is mainly used in certain
+ *     kernels that return bool type, such as isFinite, isInf, etc.
+ */
+function unaryKernelFunc$1(name, op, dtype) {
+    const impl = createSimpleUnaryImpl(op);
+    return unaryKernelFuncFromImpl(name, impl, dtype);
+}
+/**
+ * Template that creates a `KernelFunc` for unary ops from the given
+ * `SimpleUnaryImpl`..
+ * @param name Kernel name.
+ * @param unaryImpl A `SimpleUnaryImpl` that implements the op.
+ * @param dtype Optional. If set, the result has this dtype. Otherwise, the
+ *     result has the same dtype as the input. This is mainly used in certain
+ *     kernels that return bool type, such as isFinite, isInf, etc.
+ */
+function unaryKernelFuncFromImpl(name, unaryImpl, dtype) {
+    return ({ inputs, attrs, backend }) => {
+        const { x } = inputs;
+        assertNotComplex(x, name);
+        const cpuBackend = backend;
+        const values = cpuBackend.data.get(x.dataId).values;
+        let decoded;
+        if (x.dtype === 'string') {
+            if (!Array.isArray(values)) {
+                throw new Error('String tensor\'s value was not an instance of Array');
+            }
+            decoded = fromUint8ToStringArray(values);
+        }
+        else {
+            decoded = values;
+        }
+        const $dtype = dtype || x.dtype;
+        const newValues = unaryImpl(decoded, $dtype, attrs);
+        return cpuBackend.makeTensorInfo(x.shape, $dtype, newValues);
+    };
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -22529,6 +22981,12 @@ function createSimpleUnaryImpl(op) {
  * =============================================================================
  */
 const ceilImpl = createSimpleUnaryImpl((xi) => Math.ceil(xi));
+const ceil$1 = unaryKernelFuncFromImpl(Ceil, ceilImpl);
+const ceilConfig$1 = {
+    kernelName: Ceil,
+    backendName: 'cpu',
+    kernelFunc: ceil$1,
+};
 
 /**
  * @license
@@ -22593,6 +23051,12 @@ function concatImpl$1(inputs, outShape, dtype, simplyConcat) {
  * =============================================================================
  */
 const equalImpl = createSimpleBinaryKernelImpl((a, b) => (a === b) ? 1 : 0);
+const equal$1 = binaryKernelFunc$1(Equal, equalImpl, null /* complexImpl */, 'bool');
+const equalConfig$1 = {
+    kernelName: Equal,
+    backendName: 'cpu',
+    kernelFunc: equal$1
+};
 
 /**
  * @license
@@ -22611,6 +23075,12 @@ const equalImpl = createSimpleBinaryKernelImpl((a, b) => (a === b) ? 1 : 0);
  * =============================================================================
  */
 const expImpl = createSimpleUnaryImpl((xi) => Math.exp(xi));
+const exp$1 = unaryKernelFuncFromImpl(Exp, expImpl, 'float32');
+const expConfig$1 = {
+    kernelName: Exp,
+    backendName: 'cpu',
+    kernelFunc: exp$1,
+};
 
 /**
  * @license
@@ -22629,6 +23099,12 @@ const expImpl = createSimpleUnaryImpl((xi) => Math.exp(xi));
  * =============================================================================
  */
 const expm1Impl = createSimpleUnaryImpl((xi) => Math.expm1(xi));
+const expm1$1 = unaryKernelFuncFromImpl(Expm1, expm1Impl);
+const expm1Config$1 = {
+    kernelName: Expm1,
+    backendName: 'cpu',
+    kernelFunc: expm1$1,
+};
 
 /**
  * @license
@@ -22647,6 +23123,12 @@ const expm1Impl = createSimpleUnaryImpl((xi) => Math.expm1(xi));
  * =============================================================================
  */
 const floorImpl = createSimpleUnaryImpl((xi) => Math.floor(xi));
+const floor$1 = unaryKernelFuncFromImpl(Floor, floorImpl);
+const floorConfig$1 = {
+    kernelName: Floor,
+    backendName: 'cpu',
+    kernelFunc: floor$1,
+};
 
 /**
  * @license
@@ -22665,6 +23147,12 @@ const floorImpl = createSimpleUnaryImpl((xi) => Math.floor(xi));
  * =============================================================================
  */
 const floorDivImpl = createSimpleBinaryKernelImpl((a, b) => Math.floor(a / b));
+const floorDiv$1 = binaryKernelFunc$1(FloorDiv, floorDivImpl, null /* complexImpl */, 'int32');
+const floorDivConfig$1 = {
+    kernelName: FloorDiv,
+    backendName: 'cpu',
+    kernelFunc: floorDiv$1
+};
 
 /**
  * @license
@@ -22753,6 +23241,12 @@ function gatherV2Impl(xBuf, indicesBuf, flattenOutputShape) {
  * =============================================================================
  */
 const greaterImpl = createSimpleBinaryKernelImpl((a, b) => (a > b) ? 1 : 0);
+const greater$1 = binaryKernelFunc$1(Greater, greaterImpl, null /* complexImpl */, 'bool');
+const greaterConfig$1 = {
+    kernelName: Greater,
+    backendName: 'cpu',
+    kernelFunc: greater$1
+};
 
 /**
  * @license
@@ -22771,6 +23265,12 @@ const greaterImpl = createSimpleBinaryKernelImpl((a, b) => (a > b) ? 1 : 0);
  * =============================================================================
  */
 const greaterEqualImpl = createSimpleBinaryKernelImpl((a, b) => (a >= b) ? 1 : 0);
+const greaterEqual$1 = binaryKernelFunc$1(GreaterEqual, greaterEqualImpl, null /* complexImpl */, 'bool');
+const greaterEqualConfig$1 = {
+    kernelName: GreaterEqual,
+    backendName: 'cpu',
+    kernelFunc: greaterEqual$1
+};
 
 /**
  * @license
@@ -22789,6 +23289,12 @@ const greaterEqualImpl = createSimpleBinaryKernelImpl((a, b) => (a >= b) ? 1 : 0
  * =============================================================================
  */
 const lessImpl = createSimpleBinaryKernelImpl((a, b) => (a < b) ? 1 : 0);
+const less$1 = binaryKernelFunc$1(Less, lessImpl, null /* complexImpl */, 'bool');
+const lessConfig$1 = {
+    kernelName: Less,
+    backendName: 'cpu',
+    kernelFunc: less$1
+};
 
 /**
  * @license
@@ -22807,6 +23313,12 @@ const lessImpl = createSimpleBinaryKernelImpl((a, b) => (a < b) ? 1 : 0);
  * =============================================================================
  */
 const lessEqualImpl = createSimpleBinaryKernelImpl((a, b) => (a <= b) ? 1 : 0);
+const lessEqual$1 = binaryKernelFunc$1(LessEqual, lessEqualImpl, null /* complexImpl */, 'bool');
+const lessEqualConfig$1 = {
+    kernelName: LessEqual,
+    backendName: 'cpu',
+    kernelFunc: lessEqual$1
+};
 
 /**
  * @license
@@ -22851,6 +23363,12 @@ function linSpaceImpl(start, stop, num) {
  * =============================================================================
  */
 const logImpl = createSimpleUnaryImpl((xi) => Math.log(xi));
+const log$1 = unaryKernelFuncFromImpl(Log, logImpl);
+const logConfig$1 = {
+    kernelName: Log,
+    backendName: 'cpu',
+    kernelFunc: log$1,
+};
 
 /**
  * @license
@@ -22902,6 +23420,12 @@ function maxImpl$1(aVals, reduceSize, outShape, dtype) {
  * =============================================================================
  */
 const maximumImpl = createSimpleBinaryKernelImpl(((aValue, bValue) => Math.max(aValue, bValue)));
+const maximum$1 = binaryKernelFunc$1(Maximum, maximumImpl);
+const maximumConfig$1 = {
+    kernelName: Maximum,
+    backendName: 'cpu',
+    kernelFunc: maximum$1
+};
 
 /**
  * @license
@@ -22920,6 +23444,12 @@ const maximumImpl = createSimpleBinaryKernelImpl(((aValue, bValue) => Math.max(a
  * =============================================================================
  */
 const minimumImpl = createSimpleBinaryKernelImpl(((aValue, bValue) => Math.min(aValue, bValue)));
+const minimum$1 = binaryKernelFunc$1(Minimum, minimumImpl);
+const minimumConfig$1 = {
+    kernelName: Minimum,
+    backendName: 'cpu',
+    kernelFunc: minimum$1
+};
 
 /**
  * @license
@@ -22938,6 +23468,18 @@ const minimumImpl = createSimpleBinaryKernelImpl(((aValue, bValue) => Math.min(a
  * =============================================================================
  */
 const multiplyImpl = createSimpleBinaryKernelImpl(((aValue, bValue) => aValue * bValue));
+const multiplyComplexImpl = createComplexBinaryKernelImpl(((aReal, aImag, bReal, bImag) => {
+    return {
+        real: aReal * bReal - aImag * bImag,
+        imag: aReal * bImag + aImag * bReal
+    };
+}));
+const multiply$1 = binaryKernelFunc$1(Multiply, multiplyImpl, multiplyComplexImpl);
+const multiplyConfig$1 = {
+    kernelName: Multiply,
+    backendName: 'cpu',
+    kernelFunc: multiply$1
+};
 
 /**
  * @license
@@ -22959,6 +23501,19 @@ function negImpl(xVals, xShape, xDtype) {
     const minusOne = createScalarValue(-1, xDtype);
     return multiplyImpl([], xShape, minusOne, xVals, xDtype);
 }
+function neg$1(args) {
+    const { inputs, backend } = args;
+    const { x } = inputs;
+    assertNotComplex(x, 'neg');
+    const xVals = backend.data.get(x.dataId).values;
+    const [res, newShape] = negImpl(xVals, x.shape, x.dtype);
+    return backend.makeTensorInfo(newShape, x.dtype, res);
+}
+const negConfig$1 = {
+    kernelName: Neg,
+    backendName: 'cpu',
+    kernelFunc: neg$1
+};
 
 /**
  * @license
@@ -22977,6 +23532,12 @@ function negImpl(xVals, xShape, xDtype) {
  * =============================================================================
  */
 const notEqualImpl = createSimpleBinaryKernelImpl(((a, b) => (a !== b) ? 1 : 0));
+const notEqual$1 = binaryKernelFunc$1(NotEqual, notEqualImpl, null /* complexOp */, 'bool');
+const notEqualConfig$1 = {
+    kernelName: NotEqual,
+    backendName: 'cpu',
+    kernelFunc: notEqual$1
+};
 
 /**
  * @license
@@ -23013,6 +23574,43 @@ function transposeImpl$1(xVals, xShape, dtype, perm, newShape) {
     return result;
 }
 
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function transpose$1(args) {
+    const { inputs, attrs, backend } = args;
+    const { x } = inputs;
+    const { perm } = attrs;
+    assertNotComplex(x, 'transpose');
+    const xRank = x.shape.length;
+    const newShape = new Array(xRank);
+    for (let i = 0; i < newShape.length; i++) {
+        newShape[i] = x.shape[perm[i]];
+    }
+    const values = backend.data.get(x.dataId).values;
+    const result = transposeImpl$1(values, x.shape, x.dtype, perm, newShape);
+    const dataId = backend.write(result, newShape, x.dtype);
+    return { dataId, shape: newShape, dtype: x.dtype };
+}
+const transposeConfig$1 = {
+    kernelName: Transpose,
+    backendName: 'cpu',
+    kernelFunc: transpose$1
+};
+
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -23044,6 +23642,36 @@ function prodImpl(xShape, xDtype, xVals, reductionAxes) {
     }
     return { outVals, outShape, outDtype };
 }
+function prod$1(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, keepDims } = attrs;
+    assertNotComplex(x, 'prod');
+    const xRank = x.shape.length;
+    const axes = parseAxisParam(axis, x.shape);
+    const permutation = getAxesPermutation(axes, xRank);
+    let reductionAxes = axes;
+    let permutedX = x;
+    const intermediateTensorInfos = [];
+    if (permutation != null) {
+        permutedX = transpose$1({ inputs: { x }, backend, attrs: { perm: permutation } });
+        intermediateTensorInfos.push(permutedX);
+        reductionAxes = getInnerMostAxes(reductionAxes.length, xRank);
+    }
+    const xVals = backend.data.get(permutedX.dataId).values;
+    const { outVals, outShape, outDtype } = prodImpl(permutedX.shape, permutedX.dtype, xVals, reductionAxes);
+    let resultShape = outShape;
+    if (keepDims) {
+        resultShape = expandShapeToKeepDim(outShape, axes);
+    }
+    intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return backend.makeTensorInfo(resultShape, outDtype, outVals);
+}
+const prodConfig$1 = {
+    kernelName: Prod,
+    backendName: 'cpu',
+    kernelFunc: prod$1
+};
 
 /**
  * @license
@@ -23610,7 +24238,7 @@ class RaggedTensorToTensorOp {
         if (defaultValue.length !== valueElementSize && defaultValue.length !== 1) {
             const srcShape = this.defaultValueShape;
             tidy(() => {
-                const defaultValueTensor = reshape$1(defaultValue, srcShape);
+                const defaultValueTensor = reshape$2(defaultValue, srcShape);
                 const bCastDefault = broadcastTo(defaultValueTensor, elementShape);
                 defaultValue = bCastDefault.dataSync();
             });
@@ -23758,6 +24386,12 @@ function rangeImpl(start, stop, step, dtype) {
  * =============================================================================
  */
 const rsqrtImpl = createSimpleUnaryImpl((xi) => 1 / Math.sqrt(xi));
+const rsqrt$1 = unaryKernelFuncFromImpl(Rsqrt, rsqrtImpl);
+const rsqrtConfig$1 = {
+    kernelName: Rsqrt,
+    backendName: 'cpu',
+    kernelFunc: rsqrt$1,
+};
 
 /**
  * @license
@@ -23837,6 +24471,12 @@ function scatterImpl(indices, updates, shape, outputSize, sliceSize, numUpdates,
  * =============================================================================
  */
 const sigmoidImpl = createSimpleUnaryImpl((xi) => 1 / (1 + Math.exp(-xi)));
+const sigmoid$1 = unaryKernelFunc$1(Sigmoid$1, (xi) => 1 / (1 + Math.exp(-xi)));
+const sigmoidConfig$1 = {
+    kernelName: Sigmoid$1,
+    backendName: 'cpu',
+    kernelFunc: sigmoid$1,
+};
 
 /**
  * @license
@@ -23880,6 +24520,22 @@ function sliceImpl(vals, begin, size, shape, dtype) {
     }
     return outBuf.values;
 }
+function slice$1(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { begin, size } = attrs;
+    assertNotComplex(x, 'slice');
+    const [$begin, $size] = parseSliceParams(x, begin, size);
+    assertParamsValid(x, $begin, $size);
+    const vals = backend.data.get(x.dataId).values;
+    const outVals = sliceImpl(vals, $begin, $size, x.shape, x.dtype);
+    return backend.makeTensorInfo($size, x.dtype, outVals);
+}
+const sliceConfig$1 = {
+    kernelName: Slice,
+    backendName: 'cpu',
+    kernelFunc: slice$1
+};
 
 /**
  * @license
@@ -24203,6 +24859,12 @@ function sparseSegmentReductionImpl(input, inputShape, inputDType, indices, segm
  * =============================================================================
  */
 const sqrtImpl = createSimpleUnaryImpl((xi) => Math.sqrt(xi));
+const sqrt$1 = unaryKernelFunc$1(Sqrt, (xi) => Math.sqrt(xi));
+const sqrtConfig$1 = {
+    kernelName: Sqrt,
+    backendName: 'cpu',
+    kernelFunc: sqrt$1,
+};
 
 /**
  * @license
@@ -24224,6 +24886,12 @@ const squaredDifferenceImpl = createSimpleBinaryKernelImpl(((a, b) => {
     const diff = a - b;
     return diff * diff;
 }));
+const squaredDifference$1 = binaryKernelFunc$1(SquaredDifference, squaredDifferenceImpl);
+const squaredDifferenceConfig$1 = {
+    kernelName: SquaredDifference,
+    backendName: 'cpu',
+    kernelFunc: squaredDifference$1
+};
 
 /**
  * @license
@@ -24246,6 +24914,12 @@ const staticRegexReplaceImpl = createSimpleUnaryImpl((x, attrs) => {
     // TODO(mattSoulanille): Don't create a regex each time.
     return x.replace(new RegExp(pattern, replaceGlobal ? 'g' : ''), rewrite);
 });
+const staticRegexReplace$1 = unaryKernelFuncFromImpl(StaticRegexReplace, staticRegexReplaceImpl);
+const staticRegexReplaceConfig$1 = {
+    kernelName: StaticRegexReplace,
+    backendName: 'cpu',
+    kernelFunc: staticRegexReplace$1,
+};
 
 /**
  * @license
@@ -24592,6 +25266,15 @@ function stringToHashBucketFastImpl(input, numBuckets) {
  * =============================================================================
  */
 const subImpl = createSimpleBinaryKernelImpl(((aValue, bValue) => aValue - bValue));
+const subComplexImpl = createComplexBinaryKernelImpl(((aReal, aImag, bReal, bImag) => {
+    return { real: aReal - bReal, imag: aImag - bImag };
+}));
+const sub$1 = binaryKernelFunc$1(Sub, subImpl, subComplexImpl);
+const subConfig$1 = {
+    kernelName: Sub,
+    backendName: 'cpu',
+    kernelFunc: sub$1
+};
 
 /**
  * @license
@@ -24663,7 +25346,7 @@ const comparePair = (a, b) => {
  * @param k: Desired index value, where array[k] is the (k+1)th smallest element
  *           when left = 0
  */
-function select$1(array, k, left = 0, right = array.length - 1) {
+function select$2(array, k, left = 0, right = array.length - 1) {
     while (right > left) {
         // Use select recursively to sample a smaller set of size s
         // the arbitrary constants 600 and 0.5 are used in the original
@@ -24676,7 +25359,7 @@ function select$1(array, k, left = 0, right = array.length - 1) {
             const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * Math.sign(i - n / 2);
             const newLeft = Math.max(left, Math.floor(k - i * s / n + sd));
             const newRight = Math.min(right, Math.floor(k + (n - i) * s / n + sd));
-            select$1(array, k, newLeft, newRight);
+            select$2(array, k, newLeft, newRight);
         }
         // partition the elements between left and right around t
         const t = array[k];
@@ -24726,7 +25409,7 @@ function topKImpl(x, xShape, xDtype, k, sorted) {
         let valAndInd = new Array(vals.length);
         vals.forEach((value, index) => valAndInd[index] = { value, index });
         if (k < valAndInd.length) {
-            select$1(valAndInd, k);
+            select$2(valAndInd, k);
             valAndInd = valAndInd.slice(0, k);
         }
         if (sorted) {
@@ -25636,7 +26319,7 @@ class UnpackProgram {
  * =============================================================================
  */
 // Import webgl flags.
-const whereImpl = whereImpl$1;
+const whereImpl$1 = whereImpl$2;
 const EPSILON_FLOAT32 = 1e-7;
 const EPSILON_FLOAT16 = 1e-4;
 const binaryCaches = {};
@@ -26051,7 +26734,7 @@ class MathBackendWebGL extends KernelBackend {
             if (env().getNumber('WEBGL_DISJOINT_QUERY_TIMER_EXTENSION_RELIABLE') >
                 0) {
                 const kernelMs = await Promise.all(flattenedActiveTimerQueries);
-                res['kernelMs'] = sum$2(kernelMs);
+                res['kernelMs'] = sum$3(kernelMs);
                 res['getExtraProfileInfo'] = () => kernelMs
                     .map((d, i) => ({ name: flattenedActiveTimerNames[i], ms: d }))
                     .map(d => `${d.name}: ${d.ms}`)
@@ -26190,7 +26873,7 @@ class MathBackendWebGL extends KernelBackend {
         warn('tf.where() in webgl locks the UI thread. ' +
             'Call tf.whereAsync() instead');
         const condVals = condition.dataSync();
-        return whereImpl(condition.shape, condVals);
+        return whereImpl$1(condition.shape, condVals);
     }
     packedUnaryOp(x, op, dtype) {
         const program = new UnaryOpPackedProgram(x.shape, op);
@@ -26925,7 +27608,7 @@ const LEAKYRELU_PACKED = `
   vec4 aLessThanZero = vec4(lessThan(a, vec4(0.)));
   return (aLessThanZero * (b * a)) + ((vec4(1.0) - aLessThanZero) * a);
 `;
-function leakyRelu(args) {
+function leakyRelu$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { alpha } = attrs;
@@ -26937,10 +27620,10 @@ function leakyRelu(args) {
     backend.disposeIntermediateTensorInfo($alpha);
     return result;
 }
-const leakyReluConfig = {
+const leakyReluConfig$1 = {
     kernelName: LeakyRelu,
     backendName: 'webgl',
-    kernelFunc: leakyRelu
+    kernelFunc: leakyRelu$1
 };
 
 /**
@@ -26964,7 +27647,7 @@ const PRELU_PACKED = `
   vec4 aLessThanZero = vec4(lessThan(a, vec4(0.)));
   return (aLessThanZero * (b * a)) + ((vec4(1.0) - aLessThanZero) * a);
 `;
-function prelu(args) {
+function prelu$1(args) {
     const { inputs, backend } = args;
     const { x, alpha } = inputs;
     const program = env().getBool('WEBGL_PACK_BINARY_OPERATIONS') ?
@@ -26972,10 +27655,10 @@ function prelu(args) {
         new BinaryOpProgram(PRELU, x.shape, alpha.shape);
     return backend.runWebGLProgram(program, [x, alpha], 'float32');
 }
-const preluConfig = {
+const preluConfig$1 = {
     kernelName: Prelu,
     backendName: 'webgl',
-    kernelFunc: prelu
+    kernelFunc: prelu$1
 };
 
 /**
@@ -27420,7 +28103,7 @@ function packedReshape(input, afterShape, backend) {
  * limitations under the License.
  * =============================================================================
  */
-function reshape(args) {
+function reshape$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { shape } = attrs;
@@ -27439,10 +28122,10 @@ function reshape(args) {
     webglBackend.incRef(x.dataId);
     return { dataId: x.dataId, shape: $shape, dtype: x.dtype };
 }
-const reshapeConfig = {
+const reshapeConfig$1 = {
     kernelName: Reshape$1,
     backendName: 'webgl',
-    kernelFunc: reshape
+    kernelFunc: reshape$1
 };
 
 /**
@@ -27923,10 +28606,10 @@ function sumImpl(x, axis, keepDims, backend) {
     const inSize = sizeFromShape(reduceShape);
     const xSize = sizeFromShape(x.shape);
     const batchSize = xSize / inSize;
-    const reshapedInput = reshape({ inputs: { x: sumInput }, attrs: { shape: [batchSize, inSize] }, backend });
+    const reshapedInput = reshape$1({ inputs: { x: sumInput }, attrs: { shape: [batchSize, inSize] }, backend });
     const outType = sumOutType(x.dtype);
     const reduced = reduce(reshapedInput, outType, 'sum', backend);
-    const out = reshape({ inputs: { x: reduced }, attrs: { shape: outShape }, backend });
+    const out = reshape$1({ inputs: { x: reduced }, attrs: { shape: outShape }, backend });
     backend.disposeIntermediateTensorInfo(reshapedInput);
     backend.disposeIntermediateTensorInfo(reduced);
     if (sumInputIsTransposed) {
@@ -27951,16 +28634,16 @@ function sumImpl(x, axis, keepDims, backend) {
  * limitations under the License.
  * =============================================================================
  */
-function sum(args) {
+function sum$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis, keepDims } = attrs;
     return sumImpl(x, axis, keepDims, backend);
 }
-const sumConfig = {
+const sumConfig$1 = {
     kernelName: Sum,
     backendName: 'webgl',
-    kernelFunc: sum
+    kernelFunc: sum$1
 };
 
 /**
@@ -28053,8 +28736,8 @@ function batchMatMulImpl({ a, b, transposeA, transposeB, backend, bias = null, p
         [batchDimB, outerShapeB, innerShapeB] :
         [batchDimB, innerShapeB, outerShapeB];
     // The rest of the implementation is designed to operate on rank-3 tensors
-    const a3d = reshape({ inputs: { x: a }, backend, attrs: { shape: a3dShape } });
-    const b3d = reshape({ inputs: { x: b }, backend, attrs: { shape: b3dShape } });
+    const a3d = reshape$1({ inputs: { x: a }, backend, attrs: { shape: a3dShape } });
+    const b3d = reshape$1({ inputs: { x: b }, backend, attrs: { shape: b3dShape } });
     const intermediates = [a3d, b3d];
     const batchDim = Math.max(batchDimA, batchDimB);
     const sharedDim = transposeA ? a3d.shape[1] : a3d.shape[2];
@@ -28085,7 +28768,7 @@ function batchMatMulImpl({ a, b, transposeA, transposeB, backend, bias = null, p
         const shouldReshapeB = outerShapeB === 1;
         let aVec3d = aVec;
         if (shouldReshapeA) {
-            aVec3d = reshape({
+            aVec3d = reshape$1({
                 inputs: { x: aVec },
                 backend,
                 attrs: { shape: [batchDim, sharedDim, 1] }
@@ -28095,7 +28778,7 @@ function batchMatMulImpl({ a, b, transposeA, transposeB, backend, bias = null, p
         const axis = outerShapeB === 1 ? 2 : 1;
         let bVec3d = bVec;
         if (shouldReshapeB) {
-            bVec3d = reshape({
+            bVec3d = reshape$1({
                 inputs: { x: bVec },
                 backend,
                 attrs: { shape: [batchDim, 1, sharedDim] }
@@ -28103,7 +28786,7 @@ function batchMatMulImpl({ a, b, transposeA, transposeB, backend, bias = null, p
             intermediates.push(bVec3d);
         }
         const product = multiply({ inputs: { a: aVec3d, b: bVec3d }, backend });
-        out = sum({ inputs: { x: product }, backend, attrs: { axis, keepDims: true } });
+        out = sum$1({ inputs: { x: product }, backend, attrs: { axis, keepDims: true } });
         intermediates.push(product);
     }
     else {
@@ -28123,7 +28806,7 @@ function batchMatMulImpl({ a, b, transposeA, transposeB, backend, bias = null, p
         }
         out = backend.runWebGLProgram(program, inputs, dtype);
     }
-    const outReshaped = reshape({ inputs: { x: out }, backend, attrs: { shape: outShape } });
+    const outReshaped = reshape$1({ inputs: { x: out }, backend, attrs: { shape: outShape } });
     intermediates.push(out);
     for (const i of intermediates) {
         backend.disposeIntermediateTensorInfo(i);
@@ -28147,7 +28830,7 @@ function batchMatMulImpl({ a, b, transposeA, transposeB, backend, bias = null, p
  * limitations under the License.
  * =============================================================================
  */
-function _fusedMatMul(args) {
+function _fusedMatMul$1(args) {
     const { inputs, backend, attrs } = args;
     const { a, b, bias, preluActivationWeights } = inputs;
     const { transposeA, transposeB, activation, leakyreluAlpha } = attrs;
@@ -28163,10 +28846,10 @@ function _fusedMatMul(args) {
         activation
     });
 }
-const _fusedMatMulConfig = {
+const _fusedMatMulConfig$1 = {
     kernelName: _FusedMatMul,
     backendName: 'webgl',
-    kernelFunc: _fusedMatMul,
+    kernelFunc: _fusedMatMul$1,
 };
 
 /**
@@ -28233,11 +28916,11 @@ const ACOS = CHECK_NAN_SNIPPET$1 + `
   }
   return acos(x);
 `;
-const acos = unaryKernelFunc({ opSnippet: ACOS });
-const acosConfig = {
+const acos$1 = unaryKernelFunc({ opSnippet: ACOS });
+const acosConfig$1 = {
     kernelName: Acos,
     backendName: 'webgl',
-    kernelFunc: acos,
+    kernelFunc: acos$1,
 };
 
 /**
@@ -28259,11 +28942,11 @@ const acosConfig = {
 const ACOSH = CHECK_NAN_SNIPPET$1 + `
   if (x < 1.0) return NAN;
 return log(x + sqrt(x * x - 1.0));`;
-const acosh = unaryKernelFunc({ opSnippet: ACOSH });
-const acoshConfig = {
+const acosh$1 = unaryKernelFunc({ opSnippet: ACOSH });
+const acoshConfig$1 = {
     kernelName: Acosh,
     backendName: 'webgl',
-    kernelFunc: acosh,
+    kernelFunc: acosh$1,
 };
 
 /**
@@ -28399,7 +29082,7 @@ class AddNPackedProgram {
  * limitations under the License.
  * =============================================================================
  */
-function addN(args) {
+function addN$1(args) {
     const { inputs, backend } = args;
     const tensors = inputs;
     if (tensors.length === 1) {
@@ -28408,9 +29091,9 @@ function addN(args) {
     // Limit the number of uploaded textures for optimization.
     if (tensors.length > env().getNumber('WEBGL_MAX_TEXTURES_IN_SHADER')) {
         const midIndex = Math.floor(tensors.length / 2);
-        const leftSide = addN({ inputs: tensors.slice(0, midIndex), backend });
-        const rightSide = addN({ inputs: tensors.slice(midIndex), backend });
-        return addN({ inputs: [leftSide, rightSide], backend });
+        const leftSide = addN$1({ inputs: tensors.slice(0, midIndex), backend });
+        const rightSide = addN$1({ inputs: tensors.slice(midIndex), backend });
+        return addN$1({ inputs: [leftSide, rightSide], backend });
     }
     const dtype = tensors.map(t => t.dtype).reduce((d1, d2) => upcastType(d1, d2));
     const shapes = tensors.map(t => t.shape);
@@ -28421,10 +29104,10 @@ function addN(args) {
         new AddNProgram(tensors[0].shape, shapes);
     return backend.runWebGLProgram(program, tensors, dtype);
 }
-const addNConfig = {
+const addNConfig$1 = {
     kernelName: AddN,
     backendName: 'webgl',
-    kernelFunc: addN
+    kernelFunc: addN$1
 };
 
 /**
@@ -28443,7 +29126,7 @@ const addNConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function all(args) {
+function all$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis, keepDims } = attrs;
@@ -28459,15 +29142,15 @@ function all(args) {
     assertAxesAreInnerMostDims('all', axes, xRank);
     const [outShape, reduceShape] = computeOutAndReduceShapes(permutedX.shape, axes);
     const inSize = sizeFromShape(reduceShape);
-    const a2D = reshape({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
+    const a2D = reshape$1({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
     const reduced = reduce(a2D, a2D.dtype, 'all', backend);
     let res;
     if (keepDims) {
         const newShape = expandShapeToKeepDim(outShape, origAxes);
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: newShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: newShape } });
     }
     else {
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
     }
     backend.disposeIntermediateTensorInfo(a2D);
     backend.disposeIntermediateTensorInfo(reduced);
@@ -28476,10 +29159,10 @@ function all(args) {
     }
     return res;
 }
-const allConfig = {
+const allConfig$1 = {
     kernelName: All,
     backendName: 'webgl',
-    kernelFunc: all
+    kernelFunc: all$1
 };
 
 /**
@@ -28498,7 +29181,7 @@ const allConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function any(args) {
+function any$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis, keepDims } = attrs;
@@ -28514,15 +29197,15 @@ function any(args) {
     assertAxesAreInnerMostDims('any', axes, xRank);
     const [outShape, reduceShape] = computeOutAndReduceShapes(permutedX.shape, axes);
     const inSize = sizeFromShape(reduceShape);
-    const a2D = reshape({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
+    const a2D = reshape$1({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
     const reduced = reduce(a2D, a2D.dtype, 'any', backend);
     let res;
     if (keepDims) {
         const newShape = expandShapeToKeepDim(outShape, origAxes);
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: newShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: newShape } });
     }
     else {
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
     }
     backend.disposeIntermediateTensorInfo(a2D);
     backend.disposeIntermediateTensorInfo(reduced);
@@ -28531,10 +29214,10 @@ function any(args) {
     }
     return res;
 }
-const anyConfig = {
+const anyConfig$1 = {
     kernelName: Any,
     backendName: 'webgl',
-    kernelFunc: any
+    kernelFunc: any$1
 };
 
 /**
@@ -28782,11 +29465,11 @@ function argMinMaxReduce(backend, x, axis, reduceType) {
         }
         const [outShape, reduceShape] = computeOutAndReduceShapes(xUnPacked.shape, axes);
         const inSize = sizeFromShape(reduceShape);
-        const a2D = reshape({ inputs: { x: xUnPacked }, backend, attrs: { shape: [-1, inSize] } });
+        const a2D = reshape$1({ inputs: { x: xUnPacked }, backend, attrs: { shape: [-1, inSize] } });
         intermediateTensorInfos.push(a2D);
         const reduced = argReduce(backend, a2D, reduceType);
         intermediateTensorInfos.push(reduced);
-        const reshaped = reshape({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
+        const reshaped = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
         intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
         return reshaped;
     }
@@ -28809,7 +29492,7 @@ function argMinMaxReduce(backend, x, axis, reduceType) {
  * limitations under the License.
  * =============================================================================
  */
-function argMax(args) {
+function argMax$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis } = attrs;
@@ -28827,10 +29510,10 @@ function argMax(args) {
     intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return out;
 }
-const argMaxConfig = {
+const argMaxConfig$1 = {
     kernelName: ArgMax,
     backendName: 'webgl',
-    kernelFunc: argMax
+    kernelFunc: argMax$1
 };
 
 /**
@@ -28849,7 +29532,7 @@ const argMaxConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function argMin(args) {
+function argMin$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis } = attrs;
@@ -28867,10 +29550,10 @@ function argMin(args) {
     intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return out;
 }
-const argMinConfig = {
+const argMinConfig$1 = {
     kernelName: ArgMin,
     backendName: 'webgl',
-    kernelFunc: argMin
+    kernelFunc: argMin$1
 };
 
 /**
@@ -28895,11 +29578,11 @@ const ASIN = CHECK_NAN_SNIPPET$1 + `
   }
   return asin(x);
 `;
-const asin = unaryKernelFunc({ opSnippet: ASIN });
-const asinConfig = {
+const asin$1 = unaryKernelFunc({ opSnippet: ASIN });
+const asinConfig$1 = {
     kernelName: Asin,
     backendName: 'webgl',
-    kernelFunc: asin,
+    kernelFunc: asin$1,
 };
 
 /**
@@ -28919,11 +29602,11 @@ const asinConfig = {
  * =============================================================================
  */
 const ASINH = CHECK_NAN_SNIPPET$1 + `return log(x + sqrt(x * x + 1.0));`;
-const asinh = unaryKernelFunc({ opSnippet: ASINH });
-const asinhConfig = {
+const asinh$1 = unaryKernelFunc({ opSnippet: ASINH });
+const asinhConfig$1 = {
     kernelName: Asinh,
     backendName: 'webgl',
-    kernelFunc: asinh,
+    kernelFunc: asinh$1,
 };
 
 /**
@@ -28945,11 +29628,11 @@ const asinhConfig = {
 const ATAN = CHECK_NAN_SNIPPET$1 + `
   return atan(x);
 `;
-const atan = unaryKernelFunc({ opSnippet: ATAN });
-const atanConfig = {
+const atan$1 = unaryKernelFunc({ opSnippet: ATAN });
+const atanConfig$1 = {
     kernelName: Atan,
     backendName: 'webgl',
-    kernelFunc: atan,
+    kernelFunc: atan$1,
 };
 
 /**
@@ -28980,11 +29663,11 @@ const ATAN2_PACKED = `
     CHECK_NAN_SNIPPET_PACKED + `
   return result;
 `;
-const atan2 = binaryKernelFunc({ opSnippet: ATAN2, packedOpSnippet: ATAN2_PACKED });
-const atan2Config = {
+const atan2$1 = binaryKernelFunc({ opSnippet: ATAN2, packedOpSnippet: ATAN2_PACKED });
+const atan2Config$1 = {
     kernelName: Atan2,
     backendName: 'webgl',
-    kernelFunc: atan2,
+    kernelFunc: atan2$1,
 };
 
 /**
@@ -29006,11 +29689,11 @@ const atan2Config = {
 const ATANH = CHECK_NAN_SNIPPET$1 + `
   if ((x < -1.0) || (x > 1.0)) return NAN;
 return (log(1.0 + x) - log(1.0 - x)) / 2.0;`;
-const atanh = unaryKernelFunc({ opSnippet: ATANH });
-const atanhConfig = {
+const atanh$1 = unaryKernelFunc({ opSnippet: ATANH });
+const atanhConfig$1 = {
     kernelName: Atanh,
     backendName: 'webgl',
-    kernelFunc: atanh,
+    kernelFunc: atanh$1,
 };
 
 /**
@@ -29443,10 +30126,10 @@ class Pool3DProgram {
  * limitations under the License.
  * =============================================================================
  */
-function avgPool(args) {
+function avgPool$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
-    assertNotComplex(x, 'avgPool');
+    assertNotComplex$1(x, 'avgPool');
     const { filterSize, strides, pad, dimRoundingMode } = attrs;
     const dilations = 1;
     assert$1(eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in avgPool: Either strides or dilations must be 1. ' +
@@ -29459,10 +30142,10 @@ function avgPool(args) {
     const avgPoolProgram = new Pool2DProgram(convInfo, 'avg', false);
     return backend.runWebGLProgram(avgPoolProgram, [x], 'float32');
 }
-const avgPoolConfig = {
+const avgPoolConfig$1 = {
     kernelName: AvgPool,
     backendName: 'webgl',
-    kernelFunc: avgPool
+    kernelFunc: avgPool$1
 };
 
 /**
@@ -29481,7 +30164,7 @@ const avgPoolConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function avgPool3D(args) {
+function avgPool3D$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { filterSize, strides, pad, dimRoundingMode, dataFormat } = attrs;
@@ -29490,10 +30173,10 @@ function avgPool3D(args) {
     const avgPoolProgram = new Pool3DProgram(convInfo, 'avg', false);
     return backend.runWebGLProgram(avgPoolProgram, [x], 'float32');
 }
-const avgPool3DConfig = {
+const avgPool3DConfig$1 = {
     kernelName: AvgPool3D,
     backendName: 'webgl',
-    kernelFunc: avgPool3D
+    kernelFunc: avgPool3D$1
 };
 
 /**
@@ -29668,7 +30351,7 @@ class AvgPool3DBackpropProgram {
  * limitations under the License.
  * =============================================================================
  */
-function avgPool3DGrad(args) {
+function avgPool3DGrad$1(args) {
     const { inputs, backend, attrs } = args;
     const { dy, input } = inputs;
     const x = input;
@@ -29678,10 +30361,10 @@ function avgPool3DGrad(args) {
     const avgPoolBackpropProgram = new AvgPool3DBackpropProgram(convInfo);
     return backend.runWebGLProgram(avgPoolBackpropProgram, [dy], x.dtype);
 }
-const avgPool3DGradConfig$1 = {
+const avgPool3DGradConfig$2 = {
     kernelName: AvgPool3DGrad,
     backendName: 'webgl',
-    kernelFunc: avgPool3DGrad
+    kernelFunc: avgPool3DGrad$1
 };
 
 /**
@@ -29700,20 +30383,20 @@ const avgPool3DGradConfig$1 = {
  * limitations under the License.
  * =============================================================================
  */
-function avgPoolGrad$1(args) {
+function avgPoolGrad$2(args) {
     const { inputs, backend, attrs } = args;
     const { dy, input } = inputs;
     const x = input;
-    assertNotComplex([dy, input], 'avgPoolGrad');
+    assertNotComplex$1([dy, input], 'avgPoolGrad');
     const { filterSize, strides, pad } = attrs;
     const convInfo = computePool2DInfo(x.shape, filterSize, strides, 1 /* dilations */, pad);
     const avgPoolBackpropProgram = new AvgPool2DBackpropProgram(convInfo);
     return backend.runWebGLProgram(avgPoolBackpropProgram, [dy], x.dtype);
 }
-const avgPoolGradConfig$1 = {
+const avgPoolGradConfig$2 = {
     kernelName: AvgPoolGrad,
     backendName: 'webgl',
-    kernelFunc: avgPoolGrad$1
+    kernelFunc: avgPoolGrad$2
 };
 
 /**
@@ -29732,16 +30415,16 @@ const avgPoolGradConfig$1 = {
  * limitations under the License.
  * =============================================================================
  */
-function batchMatMul(args) {
+function batchMatMul$1(args) {
     const { inputs, backend, attrs } = args;
     const { a, b } = inputs;
     const { transposeA, transposeB } = attrs;
     return batchMatMulImpl({ a, b, transposeA, transposeB, backend });
 }
-const batchMatMulConfig = {
+const batchMatMulConfig$1 = {
     kernelName: BatchMatMul,
     backendName: 'webgl',
-    kernelFunc: batchMatMul,
+    kernelFunc: batchMatMul$1,
 };
 
 /**
@@ -29862,7 +30545,7 @@ class BatchNormPackedProgram {
  * limitations under the License.
  * =============================================================================
  */
-const batchNorm = ({ inputs, backend, attrs }) => {
+const batchNorm$1 = ({ inputs, backend, attrs }) => {
     const { x, mean, variance, offset, scale } = inputs;
     assert$1(mean.shape.length === variance.shape.length, () => 'Batch normalization gradient requires mean and variance to have ' +
         'equal ranks.');
@@ -29891,10 +30574,10 @@ const batchNorm = ({ inputs, backend, attrs }) => {
     const output = backend.runWebGLProgram(program, finalInputs, finalInputs[0].dtype);
     return output;
 };
-const batchNormConfig = {
+const batchNormConfig$1 = {
     kernelName: FusedBatchNorm,
     backendName: 'webgl',
-    kernelFunc: batchNorm,
+    kernelFunc: batchNorm$1,
 };
 
 /**
@@ -30113,7 +30796,7 @@ const sliceConfig = {
  * limitations under the License.
  * =============================================================================
  */
-const batchToSpaceND = (args) => {
+const batchToSpaceND$1 = (args) => {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { blockShape, crops } = attrs;
@@ -30126,9 +30809,9 @@ const batchToSpaceND = (args) => {
     const sliceBeginCoords = getSliceBeginCoords(crops, blockShape.length);
     const sliceSize = getSliceSize(reshapedPermuted, crops, blockShape.length);
     const toDispose = [];
-    const reshapedIntermediate = reshape({ inputs: { x }, backend, attrs: { shape: reshaped } });
+    const reshapedIntermediate = reshape$1({ inputs: { x }, backend, attrs: { shape: reshaped } });
     const transposedIntermediate = transpose({ inputs: { x: reshapedIntermediate }, backend, attrs: { perm: permuted } });
-    const reshapedIntermediate2 = reshape({
+    const reshapedIntermediate2 = reshape$1({
         inputs: { x: transposedIntermediate },
         backend,
         attrs: { shape: reshapedPermuted }
@@ -30144,10 +30827,10 @@ const batchToSpaceND = (args) => {
     toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return sliced;
 };
-const batchToSpaceNDConfig = {
+const batchToSpaceNDConfig$1 = {
     kernelName: BatchToSpaceND,
     backendName: 'webgl',
-    kernelFunc: batchToSpaceND
+    kernelFunc: batchToSpaceND$1
 };
 
 /**
@@ -30166,7 +30849,7 @@ const batchToSpaceNDConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function bincount(args) {
+function bincount$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, weights } = inputs;
     const { size } = attrs;
@@ -30175,10 +30858,10 @@ function bincount(args) {
     const outVals = bincountImplCPU(xVals, weightsVals, weights.dtype, weights.shape, size);
     return backend.makeTensorInfo([size], weights.dtype, outVals);
 }
-const bincountConfig = {
+const bincountConfig$1 = {
     kernelName: Bincount,
     backendName: 'webgl',
-    kernelFunc: bincount
+    kernelFunc: bincount$1
 };
 
 /**
@@ -30254,7 +30937,7 @@ const bitwiseAndConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function broadcastArgs(args) {
+function broadcastArgs$1(args) {
     const { inputs, backend } = args;
     const { s0, s1 } = inputs;
     const s0Vals = backend.readSync(s0.dataId);
@@ -30262,10 +30945,10 @@ function broadcastArgs(args) {
     const broadcastShape = assertAndGetBroadcastShape(Array.from(s0Vals), Array.from(s1Vals));
     return backend.makeTensorInfo([broadcastShape.length], 'int32', Int32Array.from(broadcastShape));
 }
-const broadcastArgsConfig = {
+const broadcastArgsConfig$1 = {
     kernelName: BroadcastArgs,
     backendName: 'webgl',
-    kernelFunc: broadcastArgs
+    kernelFunc: broadcastArgs$1
 };
 
 /**
@@ -30369,7 +31052,7 @@ function cast$1(args) {
             return identity({ inputs: { x }, backend });
         }
         // TODO(annxingyuan): Import kernel function once zeros is modularized.
-        const zerosTensor = zeros(x.shape);
+        const zerosTensor = zeros$1(x.shape);
         const floatX = cast$1({ inputs: { x }, backend, attrs: { dtype: 'float32' } });
         const result = complex({ inputs: { real: floatX, imag: zerosTensor }, backend });
         zerosTensor.dispose();
@@ -30532,7 +31215,7 @@ class ClipPackedProgram {
  * limitations under the License.
  * =============================================================================
  */
-function clipByValue(args) {
+function clipByValue$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { clipValueMin, clipValueMax } = attrs;
@@ -30546,10 +31229,10 @@ function clipByValue(args) {
     const customValues = [[clipValueMin], [clipValueMax]];
     return backend.runWebGLProgram(program, [x], x.dtype, customValues);
 }
-const clipByValueConfig = {
+const clipByValueConfig$1 = {
     kernelName: ClipByValue,
     backendName: 'webgl',
-    kernelFunc: clipByValue
+    kernelFunc: clipByValue$1
 };
 
 /**
@@ -30615,7 +31298,7 @@ function makeComplexComponentTensorInfo(complexTensor, complexPart) {
         shape: complexTensor.shape
     };
 }
-function complexAbs(args) {
+function complexAbs$1(args) {
     const { inputs, backend } = args;
     const { x } = inputs;
     const xData = backend.texData.get(x.dataId);
@@ -30626,10 +31309,10 @@ function complexAbs(args) {
     ];
     return backend.runWebGLProgram(program, programInputs, programInputs[0].dtype);
 }
-const complexAbsConfig = {
+const complexAbsConfig$1 = {
     kernelName: ComplexAbs,
     backendName: 'webgl',
-    kernelFunc: complexAbs
+    kernelFunc: complexAbs$1
 };
 
 /**
@@ -30808,16 +31491,16 @@ function shiftedChannels(channels, channel, shift) {
  * limitations under the License.
  * =============================================================================
  */
-function imag(args) {
+function imag$1(args) {
     const { inputs, backend } = args;
     const { input } = inputs;
     const inputData = backend.texData.get(input.dataId);
     return identity({ inputs: { x: inputData.complexTensorInfos.imag }, backend });
 }
-const imagConfig = {
+const imagConfig$1 = {
     kernelName: Imag,
     backendName: 'webgl',
-    kernelFunc: imag
+    kernelFunc: imag$1
 };
 
 /**
@@ -30840,7 +31523,7 @@ function concatImpl(inputs, axis, backend) {
     const dtype = inputs[0].dtype;
     if (dtype === 'complex64') {
         const reals = inputs.map((t) => real({ inputs: { input: t }, backend }));
-        const imags = inputs.map((t) => imag({ inputs: { input: t }, backend }));
+        const imags = inputs.map((t) => imag$1({ inputs: { input: t }, backend }));
         const realConcated = concatImpl(reals, axis, backend);
         const imagConcated = concatImpl(imags, axis, backend);
         const result = complex({ inputs: { real: realConcated, imag: imagConcated }, backend });
@@ -30871,7 +31554,7 @@ function concatImpl(inputs, axis, backend) {
         const tensors2D = inputs.map(t => {
             const innerSize = sizeFromShape(t.shape.slice(axis));
             const shape = [-1, innerSize];
-            return reshape({ inputs: { x: t }, backend, attrs: { shape } });
+            return reshape$1({ inputs: { x: t }, backend, attrs: { shape } });
         });
         const inputsValShapes = tensors2D.map(t => {
             return { vals: backend.readSync(t.dataId), shape: t.shape };
@@ -30917,7 +31600,7 @@ function concatImpl(inputs, axis, backend) {
     const program = new ConcatProgram(tensors2D.map(t => t.shape));
     const result = backend.runWebGLProgram(program, tensors2D, dtype);
     tensors2D.forEach(r => backend.disposeIntermediateTensorInfo(r));
-    const reshapedResult = reshape({ inputs: { x: result }, attrs: { shape: outShape }, backend });
+    const reshapedResult = reshape$1({ inputs: { x: result }, attrs: { shape: outShape }, backend });
     backend.disposeIntermediateTensorInfo(result);
     return reshapedResult;
 }
@@ -30930,7 +31613,7 @@ function computeTensors2D(inputs, axis, backend) {
     // concatenate the resulting matrices across the axis 1, finally reshaping
     // the result to have the proper shape.
     const outShape = computeOutShape$1(inputs.map(t => t.shape), axis);
-    const tensors2D = inputs.map(x => reshape({
+    const tensors2D = inputs.map(x => reshape$1({
         inputs: { x },
         attrs: { shape: [-1, sizeFromShape(x.shape.slice(axis))] },
         backend
@@ -30954,7 +31637,7 @@ function computeTensors2D(inputs, axis, backend) {
  * limitations under the License.
  * =============================================================================
  */
-function concat(args) {
+function concat$1(args) {
     const { inputs, backend, attrs } = args;
     const { axis } = attrs;
     const $axis = parseAxisParam(axis, inputs[0].shape)[0];
@@ -30971,10 +31654,10 @@ function concat(args) {
     }
     return concatImpl($inputs, $axis, backend);
 }
-const concatConfig = {
+const concatConfig$1 = {
     kernelName: Concat,
     backendName: 'webgl',
-    kernelFunc: concat
+    kernelFunc: concat$1
 };
 
 /**
@@ -31821,7 +32504,7 @@ function conv2dByMatMul({ x, filter, convInfo, backend, bias = null, preluActiva
     if (preluActivationWeights != null) {
         const targetShape = getShapeForBatchMatMul(preluActivationWeights.shape, isChannelsLast);
         if (targetShape != null) {
-            preluActivationWeights = reshape({
+            preluActivationWeights = reshape$1({
                 inputs: { x: preluActivationWeights },
                 backend,
                 attrs: { shape: targetShape }
@@ -31832,7 +32515,7 @@ function conv2dByMatMul({ x, filter, convInfo, backend, bias = null, preluActiva
     if (bias != null) {
         const targetShape = getShapeForBatchMatMul(bias.shape, isChannelsLast);
         if (targetShape != null) {
-            bias = reshape({ inputs: { x: bias }, backend, attrs: { shape: targetShape } });
+            bias = reshape$1({ inputs: { x: bias }, backend, attrs: { shape: targetShape } });
             intermediates.push(bias);
         }
     }
@@ -31872,7 +32555,7 @@ function conv2dByMatMul({ x, filter, convInfo, backend, bias = null, preluActiva
         xTexData.shape = xTexData.shape.slice();
         xTexData.shape[xTexData.shape.length - 2]++;
         assert$1(isReshapeFree(xTexData.shape, xReshaped.shape), () => `packed reshape ${xTexData.shape} to ${xReshaped.shape} isn't free`);
-        const filterReshaped = reshape({
+        const filterReshaped = reshape$1({
             inputs: { x: filter },
             backend,
             attrs: { shape: [1, convInfo.inChannels, convInfo.outChannels] }
@@ -31902,7 +32585,7 @@ function conv2dByMatMul({ x, filter, convInfo, backend, bias = null, preluActiva
     }
     else {
         const numCols = convInfo.outHeight * convInfo.outWidth;
-        const xReshaped = reshape({
+        const xReshaped = reshape$1({
             inputs: { x },
             backend,
             attrs: {
@@ -31911,7 +32594,7 @@ function conv2dByMatMul({ x, filter, convInfo, backend, bias = null, preluActiva
                     [convInfo.batchSize, convInfo.inChannels, numCols]
             }
         });
-        const filterReshaped = reshape({
+        const filterReshaped = reshape$1({
             inputs: { x: filter },
             backend,
             attrs: { shape: [1, convInfo.inChannels, convInfo.outChannels] }
@@ -31927,7 +32610,7 @@ function conv2dByMatMul({ x, filter, convInfo, backend, bias = null, preluActiva
             preluActivationWeights,
             leakyreluAlpha
         });
-        out = reshape({ inputs: { x: result }, backend, attrs: { shape: convInfo.outShape } });
+        out = reshape$1({ inputs: { x: result }, backend, attrs: { shape: convInfo.outShape } });
         intermediates.push(xReshaped);
         intermediates.push(filterReshaped);
         intermediates.push(result);
@@ -31957,7 +32640,7 @@ function conv2dWithIm2Row({ x, filter, convInfo, backend, bias = null, preluActi
     if (preluActivationWeights != null) {
         const targetShape = getShapeForBatchMatMul(preluActivationWeights.shape, isChannelsLast);
         if (targetShape != null) {
-            preluActivationWeights = reshape({
+            preluActivationWeights = reshape$1({
                 inputs: { x: preluActivationWeights },
                 backend,
                 attrs: { shape: targetShape }
@@ -31968,11 +32651,11 @@ function conv2dWithIm2Row({ x, filter, convInfo, backend, bias = null, preluActi
     if (bias != null) {
         const targetShape = getShapeForBatchMatMul(bias.shape, isChannelsLast);
         if (targetShape != null) {
-            bias = reshape({ inputs: { x: bias }, backend, attrs: { shape: targetShape } });
+            bias = reshape$1({ inputs: { x: bias }, backend, attrs: { shape: targetShape } });
             intermediates.push(bias);
         }
     }
-    const w2Row = reshape({
+    const w2Row = reshape$1({
         inputs: { x: filter },
         backend,
         attrs: { shape: [1, sharedDim, sizeFromShape(filter.shape) / sharedDim] }
@@ -31986,7 +32669,7 @@ function conv2dWithIm2Row({ x, filter, convInfo, backend, bias = null, preluActi
         [convInfo.filterWidth * convInfo.inChannels], [convInfo.outWidth]
     ];
     const im2Col = backend.runWebGLProgram(im2ColProgram, [x], 'float32', customValues);
-    const im2ColReshaped = reshape({ inputs: { x: im2Col }, backend, attrs: { shape: x2ColShape } });
+    const im2ColReshaped = reshape$1({ inputs: { x: im2Col }, backend, attrs: { shape: x2ColShape } });
     intermediates.push(im2Col);
     intermediates.push(im2ColReshaped);
     const hasBias = bias != null;
@@ -32010,7 +32693,7 @@ function conv2dWithIm2Row({ x, filter, convInfo, backend, bias = null, preluActi
         intermediates.push($leakyreluAlpha);
     }
     const product = backend.runWebGLProgram(matmulProgram, inputs, 'float32');
-    const out = reshape({ inputs: { x: product }, backend, attrs: { shape: convInfo.outShape } });
+    const out = reshape$1({ inputs: { x: product }, backend, attrs: { shape: convInfo.outShape } });
     intermediates.push(product);
     for (const i of intermediates) {
         backend.disposeIntermediateTensorInfo(i);
@@ -32066,11 +32749,11 @@ function conv2d(args) {
         const program = new Conv2DProgram(convInfo);
         out = backend.runWebGLProgram(program, [x, filter], 'float32');
     }
-    const outReshaped = reshape({ inputs: { x: out }, backend, attrs: { shape: convInfo.outShape } });
+    const outReshaped = reshape$1({ inputs: { x: out }, backend, attrs: { shape: convInfo.outShape } });
     backend.disposeIntermediateTensorInfo(out);
     return outReshaped;
 }
-const conv2DConfig = {
+const conv2DConfig$1 = {
     kernelName: Conv2D,
     backendName: 'webgl',
     kernelFunc: conv2d,
@@ -32358,7 +33041,7 @@ class Conv3DDerInputProgram {
  * limitations under the License.
  * =============================================================================
  */
-function conv2DBackpropFilter(args) {
+function conv2DBackpropFilter$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, dy } = inputs;
     const { strides, pad, dataFormat, dimRoundingMode, filterShape } = attrs;
@@ -32367,10 +33050,10 @@ function conv2DBackpropFilter(args) {
     const program = new Conv2DDerFilterProgram(convInfo);
     return backend.runWebGLProgram(program, [x, dy], 'float32');
 }
-const conv2DBackpropFilterConfig = {
+const conv2DBackpropFilterConfig$1 = {
     kernelName: Conv2DBackpropFilter,
     backendName: 'webgl',
-    kernelFunc: conv2DBackpropFilter,
+    kernelFunc: conv2DBackpropFilter$1,
 };
 
 /**
@@ -32497,7 +33180,7 @@ class Conv2DDerInputPackedProgram {
  * limitations under the License.
  * =============================================================================
  */
-function conv2DBackpropInput(args) {
+function conv2DBackpropInput$1(args) {
     const { inputs, backend, attrs } = args;
     const { dy, filter } = inputs;
     const { inputShape, strides, pad, dataFormat, dimRoundingMode } = attrs;
@@ -32516,10 +33199,10 @@ function conv2DBackpropInput(args) {
         return backend.runWebGLProgram(program, [dy, filter], 'float32');
     }
 }
-const conv2DBackpropInputConfig = {
+const conv2DBackpropInputConfig$1 = {
     kernelName: Conv2DBackpropInput,
     backendName: 'webgl',
-    kernelFunc: conv2DBackpropInput,
+    kernelFunc: conv2DBackpropInput$1,
 };
 
 /**
@@ -32538,7 +33221,7 @@ const conv2DBackpropInputConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function conv3D(args) {
+function conv3D$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, filter } = inputs;
     const { strides, pad, dilations } = attrs;
@@ -32546,10 +33229,10 @@ function conv3D(args) {
     const program = new Conv3DProgram(convInfo);
     return backend.runWebGLProgram(program, [x, filter], 'float32');
 }
-const conv3DConfig = {
+const conv3DConfig$1 = {
     kernelName: Conv3D,
     backendName: 'webgl',
-    kernelFunc: conv3D,
+    kernelFunc: conv3D$1,
 };
 
 /**
@@ -32568,7 +33251,7 @@ const conv3DConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function conv3DBackpropFilterV2(args) {
+function conv3DBackpropFilterV2$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, dy } = inputs;
     const { strides, pad, filterShape } = attrs;
@@ -32576,10 +33259,10 @@ function conv3DBackpropFilterV2(args) {
     const program = new Conv3DDerFilterProgram(convInfo);
     return backend.runWebGLProgram(program, [x, dy], 'float32');
 }
-const conv3DBackpropFilterV2Config = {
+const conv3DBackpropFilterV2Config$1 = {
     kernelName: Conv3DBackpropFilterV2,
     backendName: 'webgl',
-    kernelFunc: conv3DBackpropFilterV2
+    kernelFunc: conv3DBackpropFilterV2$1
 };
 
 /**
@@ -32637,11 +33320,11 @@ const COS_PACKED = `
   ${CHECK_NAN_SNIPPET_PACKED}
   return result;
 `;
-const cos = unaryKernelFunc({ opSnippet: COS, packedOpSnippet: COS_PACKED });
-const cosConfig = {
+const cos$1 = unaryKernelFunc({ opSnippet: COS, packedOpSnippet: COS_PACKED });
+const cosConfig$1 = {
     kernelName: Cos,
     backendName: 'webgl',
-    kernelFunc: cos,
+    kernelFunc: cos$1,
 };
 
 /**
@@ -32664,11 +33347,11 @@ const COSH = `
   float e2x = exp(-x);
   return (e2x + 1.0 / e2x) / 2.0;
 `;
-const cosh = unaryKernelFunc({ opSnippet: COSH });
-const coshConfig = {
+const cosh$1 = unaryKernelFunc({ opSnippet: COSH });
+const coshConfig$1 = {
     kernelName: Cosh,
     backendName: 'webgl',
-    kernelFunc: cosh,
+    kernelFunc: cosh$1,
 };
 
 /**
@@ -32803,17 +33486,17 @@ class CropAndResizeProgram {
  * limitations under the License.
  * =============================================================================
  */
-const cropAndResize = (args) => {
+const cropAndResize$1 = (args) => {
     const { inputs, backend, attrs } = args;
     const { image, boxes, boxInd } = inputs;
     const { cropSize, method, extrapolationValue } = attrs;
     const program = new CropAndResizeProgram(image.shape, boxes.shape, cropSize, method, extrapolationValue);
     return backend.runWebGLProgram(program, [image, boxes, boxInd], 'float32');
 };
-const cropAndResizeConfig = {
+const cropAndResizeConfig$1 = {
     kernelName: CropAndResize,
     backendName: 'webgl',
-    kernelFunc: cropAndResize
+    kernelFunc: cropAndResize$1
 };
 
 var CumOpType;
@@ -32971,16 +33654,16 @@ function cumImpl(op, x, backend, axis, exclusive, reverse) {
  * limitations under the License.
  * =============================================================================
  */
-function cumprod(args) {
+function cumprod$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis, exclusive, reverse } = attrs;
     return cumImpl(CumOpType.Prod, x, backend, axis, exclusive, reverse);
 }
-const cumprodConfig = {
+const cumprodConfig$1 = {
     kernelName: Cumprod,
     backendName: 'webgl',
-    kernelFunc: cumprod
+    kernelFunc: cumprod$1
 };
 
 /**
@@ -32999,16 +33682,16 @@ const cumprodConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function cumsum(args) {
+function cumsum$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis, exclusive, reverse } = attrs;
     return cumImpl(CumOpType.Sum, x, backend, axis, exclusive, reverse);
 }
-const cumsumConfig = {
+const cumsumConfig$1 = {
     kernelName: Cumsum,
     backendName: 'webgl',
-    kernelFunc: cumsum
+    kernelFunc: cumsum$1
 };
 
 /**
@@ -33027,7 +33710,7 @@ const cumsumConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function denseBincount(args) {
+function denseBincount$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, weights } = inputs;
     const { size, binaryOutput } = attrs;
@@ -33046,10 +33729,10 @@ function denseBincount(args) {
     throw new Error(`Error in denseBincount: input must be at most rank 2, but got rank` +
         `${x.shape.length}.`);
 }
-const denseBincountConfig = {
+const denseBincountConfig$1 = {
     kernelName: DenseBincount,
     backendName: 'webgl',
-    kernelFunc: denseBincount
+    kernelFunc: denseBincount$1
 };
 
 /**
@@ -33154,7 +33837,7 @@ class DepthToSpaceProgram {
  * limitations under the License.
  * =============================================================================
  */
-function depthToSpace(args) {
+function depthToSpace$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { blockSize, dataFormat } = attrs;
@@ -33171,10 +33854,10 @@ function depthToSpace(args) {
     const program = new DepthToSpaceProgram(outputShape, blockSize, dataFormat);
     return backend.runWebGLProgram(program, [x], x.dtype);
 }
-const depthToSpaceConfig = {
+const depthToSpaceConfig$1 = {
     kernelName: DepthToSpace,
     backendName: 'webgl',
-    kernelFunc: depthToSpace
+    kernelFunc: depthToSpace$1
 };
 
 /**
@@ -33671,7 +34354,7 @@ class DepthwiseConvPacked2DProgram {
  * limitations under the License.
  * =============================================================================
  */
-function depthwiseConv2dNative(args) {
+function depthwiseConv2dNative$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, filter } = inputs;
     const { strides, pad, dilations, dimRoundingMode } = attrs;
@@ -33698,10 +34381,10 @@ function depthwiseConv2dNative(args) {
     ];
     return backend.runWebGLProgram(program, [x, filter], 'float32', customValues);
 }
-const depthwiseConv2dNativeConfig = {
+const depthwiseConv2dNativeConfig$1 = {
     kernelName: DepthwiseConv2dNative,
     backendName: 'webgl',
-    kernelFunc: depthwiseConv2dNative,
+    kernelFunc: depthwiseConv2dNative$1,
 };
 
 /**
@@ -33843,7 +34526,7 @@ class DepthwiseConv2DDerInputProgram {
  * limitations under the License.
  * =============================================================================
  */
-function depthwiseConv2dNativeBackpropFilter(args) {
+function depthwiseConv2dNativeBackpropFilter$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, dy } = inputs;
     const { strides, dilations, pad, dimRoundingMode, filterShape } = attrs;
@@ -33851,10 +34534,10 @@ function depthwiseConv2dNativeBackpropFilter(args) {
     const program = new DepthwiseConv2DDerFilterProgram(convInfo);
     return backend.runWebGLProgram(program, [x, dy], 'float32');
 }
-const depthwiseConv2dNativeBackpropFilterConfig = {
+const depthwiseConv2dNativeBackpropFilterConfig$1 = {
     kernelName: DepthwiseConv2dNativeBackpropFilter,
     backendName: 'webgl',
-    kernelFunc: depthwiseConv2dNativeBackpropFilter
+    kernelFunc: depthwiseConv2dNativeBackpropFilter$1
 };
 
 /**
@@ -33873,7 +34556,7 @@ const depthwiseConv2dNativeBackpropFilterConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function depthwiseConv2dNativeBackpropInput(args) {
+function depthwiseConv2dNativeBackpropInput$1(args) {
     const { inputs, backend, attrs } = args;
     const { dy, filter } = inputs;
     const { strides, dilations, pad, dimRoundingMode, inputShape } = attrs;
@@ -33881,10 +34564,10 @@ function depthwiseConv2dNativeBackpropInput(args) {
     const program = new DepthwiseConv2DDerInputProgram(convInfo);
     return backend.runWebGLProgram(program, [dy, filter], 'float32');
 }
-const depthwiseConv2dNativeBackpropInputConfig = {
+const depthwiseConv2dNativeBackpropInputConfig$1 = {
     kernelName: DepthwiseConv2dNativeBackpropInput,
     backendName: 'webgl',
-    kernelFunc: depthwiseConv2dNativeBackpropInput
+    kernelFunc: depthwiseConv2dNativeBackpropInput$1
 };
 
 /**
@@ -33933,23 +34616,23 @@ class DiagProgram {
  * limitations under the License.
  * =============================================================================
  */
-function diag(args) {
+function diag$1(args) {
     const { inputs, backend } = args;
     const { x } = inputs;
     const outShape = [...x.shape, ...x.shape];
     const xSize = sizeFromShape(x.shape);
-    const flat = reshape({ inputs: { x }, backend, attrs: { shape: [xSize] } });
+    const flat = reshape$1({ inputs: { x }, backend, attrs: { shape: [xSize] } });
     const program = new DiagProgram(xSize);
     const res = backend.runWebGLProgram(program, [flat], flat.dtype);
-    const out = reshape({ inputs: { x: res }, backend, attrs: { shape: outShape } });
+    const out = reshape$1({ inputs: { x: res }, backend, attrs: { shape: outShape } });
     backend.disposeIntermediateTensorInfo(flat);
     backend.disposeIntermediateTensorInfo(res);
     return out;
 }
-const diagConfig = {
+const diagConfig$1 = {
     kernelName: Diag,
     backendName: 'webgl',
-    kernelFunc: diag
+    kernelFunc: diag$1
 };
 
 /**
@@ -34040,11 +34723,11 @@ function dilation2D(args) {
     let out;
     const program = new Dilation2DProgram(convInfo);
     out = backend.runWebGLProgram(program, [x, filter], 'float32');
-    const outReshaped = reshape({ inputs: { x: out }, backend, attrs: { shape: convInfo.outShape } });
+    const outReshaped = reshape$1({ inputs: { x: out }, backend, attrs: { shape: convInfo.outShape } });
     backend.disposeIntermediateTensorInfo(out);
     return outReshaped;
 }
-const dilation2DConfig = {
+const dilation2DConfig$1 = {
     kernelName: Dilation2D,
     backendName: 'webgl',
     kernelFunc: dilation2D,
@@ -34066,7 +34749,7 @@ const dilation2DConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function einsum(args) {
+function einsum$1(args) {
     const { inputs, backend, attrs } = args;
     const { equation } = attrs;
     const tensors = inputs;
@@ -34093,7 +34776,7 @@ function einsum(args) {
                 targetShape.splice(dimsToExpand[k], 0, 1);
             }
             if (!arraysEqual(x.shape, targetShape)) {
-                x = reshape({ inputs: { x }, backend, attrs: { shape: targetShape } });
+                x = reshape$1({ inputs: { x }, backend, attrs: { shape: targetShape } });
                 tensorsToDispose.push(x);
             }
             if (out === null) {
@@ -34107,7 +34790,7 @@ function einsum(args) {
         }
         if (i < nSteps - 1) {
             if (path[i] >= 0) {
-                out = sum({
+                out = sum$1({
                     inputs: { x: out },
                     backend,
                     attrs: {
@@ -34129,10 +34812,10 @@ function einsum(args) {
     }
     return out;
 }
-const einsumConfig = {
+const einsumConfig$1 = {
     kernelName: Einsum,
     backendName: 'webgl',
-    kernelFunc: einsum
+    kernelFunc: einsum$1
 };
 
 /**
@@ -34162,11 +34845,11 @@ const ELU_PACKED = `
 
   return result;
 `;
-const elu$1 = unaryKernelFunc({ opSnippet: ELU, packedOpSnippet: ELU_PACKED });
-const eluConfig = {
+const elu$2 = unaryKernelFunc({ opSnippet: ELU, packedOpSnippet: ELU_PACKED });
+const eluConfig$1 = {
     kernelName: Elu$1,
     backendName: 'webgl',
-    kernelFunc: elu$1
+    kernelFunc: elu$2
 };
 
 /**
@@ -34190,7 +34873,7 @@ const ELU_DER_PACKED = `
   vec4 bGTEZero = vec4(greaterThanEqual(b, vec4(0.)));
   return (bGTEZero * a) + ((vec4(1.0) - bGTEZero) * (a * (b + vec4(1.0))));
 `;
-const eluGrad = (args) => {
+const eluGrad$1 = (args) => {
     const { inputs, backend } = args;
     const { dy, y } = inputs;
     const program = env().getBool('WEBGL_PACK_BINARY_OPERATIONS') ?
@@ -34198,10 +34881,10 @@ const eluGrad = (args) => {
         new BinaryOpProgram(ELU_DER, dy.shape, y.shape);
     return backend.runWebGLProgram(program, [dy, y], dy.dtype);
 };
-const eluGradConfig$1 = {
+const eluGradConfig$2 = {
     kernelName: EluGrad,
     backendName: 'webgl',
-    kernelFunc: eluGrad
+    kernelFunc: eluGrad$1
 };
 
 /**
@@ -34268,11 +34951,11 @@ const ERF = `
   float t = 1.0 / (1.0 + p * x);
   return sign * (1.0 - (((((a5*t + a4)*t) + a3)*t + a2)*t + a1)*t*exp(-x*x));
 `;
-const erf = unaryKernelFunc({ opSnippet: ERF });
-const erfConfig = {
+const erf$1 = unaryKernelFunc({ opSnippet: ERF });
+const erfConfig$1 = {
     kernelName: Erf,
     backendName: 'webgl',
-    kernelFunc: erf,
+    kernelFunc: erf$1,
 };
 
 /**
@@ -34332,7 +35015,7 @@ const expConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function expandDims$1(args) {
+function expandDims$2(args) {
     const { inputs, attrs, backend } = args;
     const { dim } = attrs;
     const { input } = inputs;
@@ -34345,12 +35028,12 @@ function expandDims$1(args) {
         $dim = inputRank + dim + 1;
     }
     newShape.splice($dim, 0, 1);
-    return reshape({ inputs: { x: input }, backend, attrs: { shape: newShape } });
+    return reshape$1({ inputs: { x: input }, backend, attrs: { shape: newShape } });
 }
-const expandDimsConfig = {
+const expandDimsConfig$1 = {
     kernelName: ExpandDims,
     backendName: 'webgl',
-    kernelFunc: expandDims$1,
+    kernelFunc: expandDims$2,
 };
 
 /**
@@ -34463,13 +35146,13 @@ class FFTProgram {
  * limitations under the License.
  * =============================================================================
  */
-function fftImpl(x, inverse, backend) {
+function fftImpl$1(x, inverse, backend) {
     const xData = backend.texData.get(x.dataId);
     const inputSize = sizeFromShape(x.shape);
     // Collapse all outer dimensions to a single batch dimension.
     const innerDimensionSize = x.shape[x.shape.length - 1];
     const batch = inputSize / innerDimensionSize;
-    const input2D = reshape({ inputs: { x }, backend, attrs: { shape: [batch, innerDimensionSize] } });
+    const input2D = reshape$1({ inputs: { x }, backend, attrs: { shape: [batch, innerDimensionSize] } });
     const xShape = input2D.shape;
     const realProgram = new FFTProgram('real', xShape, inverse);
     const imagProgram = new FFTProgram('imag', xShape, inverse);
@@ -34490,7 +35173,7 @@ function fftImpl(x, inverse, backend) {
     const complexOutput = complex({ inputs: { real: realPart, imag: imagPart }, backend });
     backend.disposeIntermediateTensorInfo(realPart);
     backend.disposeIntermediateTensorInfo(imagPart);
-    const complexOutputReshaped = reshape({ inputs: { x: complexOutput }, backend, attrs: { shape: x.shape } });
+    const complexOutputReshaped = reshape$1({ inputs: { x: complexOutput }, backend, attrs: { shape: x.shape } });
     backend.disposeIntermediateTensorInfo(input2D);
     backend.disposeIntermediateTensorInfo(complexOutput);
     return complexOutputReshaped;
@@ -34512,15 +35195,15 @@ function fftImpl(x, inverse, backend) {
  * limitations under the License.
  * =============================================================================
  */
-function fft(args) {
+function fft$1(args) {
     const { inputs, backend } = args;
     const { input } = inputs;
-    return fftImpl(input, false /* inverse */, backend);
+    return fftImpl$1(input, false /* inverse */, backend);
 }
-const fftConfig = {
+const fftConfig$1 = {
     kernelName: FFT,
     backendName: 'webgl',
-    kernelFunc: fft
+    kernelFunc: fft$1
 };
 
 /**
@@ -34570,7 +35253,7 @@ class FillProgram {
  * limitations under the License.
  * =============================================================================
  */
-function fill(args) {
+function fill$1(args) {
     const { backend, attrs } = args;
     const { shape, value } = attrs;
     let { dtype } = attrs;
@@ -34587,10 +35270,10 @@ function fill(args) {
         return backend.runWebGLProgram(program, [], dtype, customValues);
     }
 }
-const fillConfig = {
+const fillConfig$1 = {
     kernelName: Fill,
     backendName: 'webgl',
-    kernelFunc: fill
+    kernelFunc: fill$1
 };
 
 /**
@@ -34649,7 +35332,7 @@ class FlipLeftRightProgram {
  * limitations under the License.
  * =============================================================================
  */
-const flipLeftRightConfig = {
+const flipLeftRightConfig$1 = {
     kernelName: FlipLeftRight,
     backendName: 'webgl',
     kernelFunc: ({ inputs, backend }) => {
@@ -34958,7 +35641,7 @@ function fusedConv2d(args) {
         const alignInputWithDataFormat = (input, dataFormat) => {
             if (dataFormat === 'NCHW' && input.shape.length === 1 &&
                 input.shape[0] !== 1) {
-                const alignedInput = reshape({
+                const alignedInput = reshape$1({
                     inputs: { x: input },
                     backend,
                     attrs: { shape: [input.shape[0], 1, 1] }
@@ -35027,12 +35710,12 @@ function fusedConv2d(args) {
         const inputs = prepareInputs();
         out = backend.runWebGLProgram(program, inputs, 'float32');
     }
-    const outReshaped = reshape({ inputs: { x: out }, backend, attrs: { shape: convInfo.outShape } });
+    const outReshaped = reshape$1({ inputs: { x: out }, backend, attrs: { shape: convInfo.outShape } });
     intermediates.push(out);
     intermediates.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return outReshaped;
 }
-const fusedConv2DConfig = {
+const fusedConv2DConfig$1 = {
     kernelName: FusedConv2D,
     backendName: 'webgl',
     kernelFunc: fusedConv2d,
@@ -35054,7 +35737,7 @@ const fusedConv2DConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function fusedDepthwiseConv2D(args) {
+function fusedDepthwiseConv2D$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, filter, bias, preluActivationWeights } = inputs;
     const { strides, pad, dilations, dimRoundingMode, activation, leakyreluAlpha } = attrs;
@@ -35104,10 +35787,10 @@ function fusedDepthwiseConv2D(args) {
     intermediates.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return result;
 }
-const fusedDepthwiseConv2DConfig = {
+const fusedDepthwiseConv2DConfig$1 = {
     kernelName: FusedDepthwiseConv2D,
     backendName: 'webgl',
-    kernelFunc: fusedDepthwiseConv2D,
+    kernelFunc: fusedDepthwiseConv2D$1,
 };
 
 class GatherNDProgram {
@@ -35157,15 +35840,15 @@ class GatherNDProgram {
  * limitations under the License.
  * =============================================================================
  */
-function gatherNd(args) {
+function gatherNd$1(args) {
     const { inputs, backend } = args;
     const { params, indices } = inputs;
     const indicesShape = indices.shape;
     const sliceRank = indicesShape[indicesShape.length - 1];
     const paramsSize = sizeFromShape(params.shape);
     const [resultShape, numSlices, sliceSize, strides] = prepareAndValidate(params, indices);
-    const flattenIndices = reshape({ inputs: { x: indices }, backend, attrs: { shape: [numSlices, sliceRank] } });
-    const flattenX = reshape({
+    const flattenIndices = reshape$1({ inputs: { x: indices }, backend, attrs: { shape: [numSlices, sliceRank] } });
+    const flattenX = reshape$1({
         inputs: { x: params },
         backend,
         attrs: { shape: [(sizeFromShape(params.shape) / sliceSize), sliceSize] }
@@ -35179,16 +35862,16 @@ function gatherNd(args) {
     }
     const program = new GatherNDProgram(sliceRank, strides, [numSlices, sliceSize], params.shape);
     const res = backend.runWebGLProgram(program, [flattenX, flattenIndices], flattenX.dtype);
-    const reshaped = reshape({ inputs: { x: res }, backend, attrs: { shape: resultShape } });
+    const reshaped = reshape$1({ inputs: { x: res }, backend, attrs: { shape: resultShape } });
     backend.disposeIntermediateTensorInfo(flattenIndices);
     backend.disposeIntermediateTensorInfo(flattenX);
     backend.disposeIntermediateTensorInfo(res);
     return reshaped;
 }
-const gatherNdConfig = {
+const gatherNdConfig$1 = {
     kernelName: GatherNd,
     backendName: 'webgl',
-    kernelFunc: gatherNd
+    kernelFunc: gatherNd$1
 };
 
 /**
@@ -35255,7 +35938,7 @@ function getSourceCoords$1(aShape, axis) {
  * limitations under the License.
  * =============================================================================
  */
-function gatherV2(args) {
+function gatherV2$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, indices } = inputs;
     const { axis, batchDims } = attrs;
@@ -35273,7 +35956,7 @@ function gatherV2(args) {
     const shapeInfo = collectGatherOpShapeInfo(x, indices, parsedAxis, batchDims);
     const indicesSize = sizeFromShape(indices.shape);
     const toDispose = [];
-    const flattenX = reshape({
+    const flattenX = reshape$1({
         inputs: { x },
         backend,
         attrs: {
@@ -35283,7 +35966,7 @@ function gatherV2(args) {
             ]
         }
     });
-    const flattenIndex = reshape({
+    const flattenIndex = reshape$1({
         inputs: { x: indices },
         backend,
         attrs: { shape: [shapeInfo.batchSize, indicesSize / shapeInfo.batchSize] }
@@ -35304,14 +35987,14 @@ function gatherV2(args) {
     const program = new GatherProgram(flattenX.shape, flattenOutputShape);
     const res = backend.runWebGLProgram(program, [flattenX, flattenIndex], flattenX.dtype);
     toDispose.push(res);
-    const reshaped = reshape({ inputs: { x: res }, backend, attrs: { shape: shapeInfo.outputShape } });
+    const reshaped = reshape$1({ inputs: { x: res }, backend, attrs: { shape: shapeInfo.outputShape } });
     toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return reshaped;
 }
-const gatherV2Config = {
+const gatherV2Config$1 = {
     kernelName: GatherV2,
     backendName: 'webgl',
-    kernelFunc: gatherV2
+    kernelFunc: gatherV2$1
 };
 
 /**
@@ -35394,15 +36077,15 @@ const greaterEqualConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function ifft(args) {
+function ifft$1(args) {
     const { inputs, backend } = args;
     const { input } = inputs;
-    return fftImpl(input, true /* inverse */, backend);
+    return fftImpl$1(input, true /* inverse */, backend);
 }
-const ifftConfig = {
+const ifftConfig$1 = {
     kernelName: IFFT,
     backendName: 'webgl',
-    kernelFunc: ifft
+    kernelFunc: ifft$1
 };
 
 /**
@@ -35422,11 +36105,11 @@ const ifftConfig = {
  * =============================================================================
  */
 const IS_FINITE = `return float(!isnan(x) && !isinf(x));`;
-const isFinite$1 = unaryKernelFunc({ opSnippet: IS_FINITE, dtype: 'bool' });
-const isFiniteConfig = {
+const isFinite$2 = unaryKernelFunc({ opSnippet: IS_FINITE, dtype: 'bool' });
+const isFiniteConfig$1 = {
     kernelName: IsFinite,
     backendName: 'webgl',
-    kernelFunc: isFinite$1,
+    kernelFunc: isFinite$2,
 };
 
 /**
@@ -35446,11 +36129,11 @@ const isFiniteConfig = {
  * =============================================================================
  */
 const IS_INF = `return float(isinf(x));`;
-const isInf = unaryKernelFunc({ opSnippet: IS_INF, dtype: 'bool' });
-const isInfConfig = {
+const isInf$1 = unaryKernelFunc({ opSnippet: IS_INF, dtype: 'bool' });
+const isInfConfig$1 = {
     kernelName: IsInf,
     backendName: 'webgl',
-    kernelFunc: isInf,
+    kernelFunc: isInf$1,
 };
 
 /**
@@ -35470,11 +36153,11 @@ const isInfConfig = {
  * =============================================================================
  */
 const IS_NAN = `return float(isnan(x));`;
-const isNaN$1 = unaryKernelFunc({ opSnippet: IS_NAN, dtype: 'bool' });
-const isNaNConfig = {
+const isNaN$2 = unaryKernelFunc({ opSnippet: IS_NAN, dtype: 'bool' });
+const isNaNConfig$1 = {
     kernelName: IsNan,
     backendName: 'webgl',
-    kernelFunc: isNaN$1,
+    kernelFunc: isNaN$2,
 };
 
 /**
@@ -35557,17 +36240,17 @@ const lessEqualConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function linSpace(args) {
+function linSpace$1(args) {
     const { backend, attrs } = args;
     const { start, stop, num } = attrs;
     // TODO: Use CPU implementation due to the precision problem in Safari.
     const outVals = linSpaceImplCPU(start, stop, num);
     return backend.makeTensorInfo([outVals.length], 'float32', outVals);
 }
-const linSpaceConfig = {
+const linSpaceConfig$1 = {
     kernelName: LinSpace,
     backendName: 'webgl',
-    kernelFunc: linSpace
+    kernelFunc: linSpace$1
 };
 
 /**
@@ -35626,11 +36309,11 @@ const logConfig = {
 const LOG1P = CHECK_NAN_SNIPPET_UNARY + `
   return log(1.0 + x);
 `;
-const log1p = unaryKernelFunc({ opSnippet: LOG1P });
-const log1pConfig = {
+const log1p$1 = unaryKernelFunc({ opSnippet: LOG1P });
+const log1pConfig$1 = {
     kernelName: Log1p,
     backendName: 'webgl',
-    kernelFunc: log1p,
+    kernelFunc: log1p$1,
 };
 
 /**
@@ -35655,15 +36338,15 @@ const LOGICAL_AND_PACKED = `
     vec4(greaterThanEqual(a, vec4(1.0))) *
     vec4(greaterThanEqual(b, vec4(1.0))));
 `;
-const logicalAnd = binaryKernelFunc({
+const logicalAnd$1 = binaryKernelFunc({
     opSnippet: LOGICAL_AND,
     packedOpSnippet: LOGICAL_AND_PACKED,
     dtype: 'bool'
 });
-const logicalAndConfig = {
+const logicalAndConfig$1 = {
     kernelName: LogicalAnd,
     backendName: 'webgl',
-    kernelFunc: logicalAnd
+    kernelFunc: logicalAnd$1
 };
 
 /**
@@ -35683,11 +36366,11 @@ const logicalAndConfig = {
  * =============================================================================
  */
 const LOGICAL_NOT = `return float(!(x >= 1.0));`;
-const logicalNot = unaryKernelFunc({ opSnippet: LOGICAL_NOT });
-const logicalNotConfig = {
+const logicalNot$1 = unaryKernelFunc({ opSnippet: LOGICAL_NOT });
+const logicalNotConfig$1 = {
     kernelName: LogicalNot,
     backendName: 'webgl',
-    kernelFunc: logicalNot,
+    kernelFunc: logicalNot$1,
 };
 
 /**
@@ -35713,11 +36396,11 @@ const LOGICAL_OR_PACKED = `
     vec4(greaterThanEqual(b, vec4(1.0))),
     vec4(1.0));
 `;
-const logicalOr = binaryKernelFunc({ opSnippet: LOGICAL_OR, packedOpSnippet: LOGICAL_OR_PACKED, dtype: 'bool' });
-const logicalOrConfig = {
+const logicalOr$1 = binaryKernelFunc({ opSnippet: LOGICAL_OR, packedOpSnippet: LOGICAL_OR_PACKED, dtype: 'bool' });
+const logicalOrConfig$1 = {
     kernelName: LogicalOr,
     backendName: 'webgl',
-    kernelFunc: logicalOr
+    kernelFunc: logicalOr$1
 };
 
 /**
@@ -35913,7 +36596,7 @@ const lrn = (args) => {
     return backend.runWebGLProgram(program, [x], x.dtype);
 };
 // tslint:disable-next-line: variable-name
-const LRNConfig = {
+const LRNConfig$1 = {
     kernelName: LRN,
     backendName: 'webgl',
     kernelFunc: lrn
@@ -36028,7 +36711,7 @@ const lrnGrad = (args) => {
     return backend.runWebGLProgram(program, [x, y, dy], x.dtype);
 };
 // tslint:disable-next-line: variable-name
-const LRNGradConfig = {
+const LRNGradConfig$1 = {
     kernelName: LRNGrad,
     backendName: 'webgl',
     kernelFunc: lrnGrad
@@ -36054,9 +36737,9 @@ function maxImpl(x, reduceShape, outShape, backend) {
     const inSize = sizeFromShape(reduceShape);
     const xSize = sizeFromShape(x.shape);
     const batchSize = xSize / inSize;
-    const reshapedInput = reshape({ inputs: { x }, attrs: { shape: [batchSize, inSize] }, backend });
+    const reshapedInput = reshape$1({ inputs: { x }, attrs: { shape: [batchSize, inSize] }, backend });
     const reduced = reduce(reshapedInput, x.dtype, 'max', backend);
-    const reshapedOutput = reshape({ inputs: { x: reduced }, attrs: { shape: outShape }, backend });
+    const reshapedOutput = reshape$1({ inputs: { x: reduced }, attrs: { shape: outShape }, backend });
     backend.disposeIntermediateTensorInfo(reshapedInput);
     backend.disposeIntermediateTensorInfo(reduced);
     return reshapedOutput;
@@ -36078,7 +36761,7 @@ function maxImpl(x, reduceShape, outShape, backend) {
  * limitations under the License.
  * =============================================================================
  */
-function max(args) {
+function max$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { reductionIndices, keepDims } = attrs;
@@ -36131,10 +36814,10 @@ function max(args) {
     }
     return out;
 }
-const maxConfig = {
+const maxConfig$1 = {
     kernelName: Max,
     backendName: 'webgl',
-    kernelFunc: max
+    kernelFunc: max$1
 };
 
 /**
@@ -36192,10 +36875,10 @@ const maximumConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function maxPool(args) {
+function maxPool$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
-    assertNotComplex(x, 'maxPool');
+    assertNotComplex$1(x, 'maxPool');
     const { filterSize, strides, pad, dimRoundingMode } = attrs;
     const dilations = 1;
     assert$1(eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in maxPool: Either strides or dilations must be 1. ' +
@@ -36208,10 +36891,10 @@ function maxPool(args) {
     const maxPoolProgram = new Pool2DProgram(convInfo, 'max', false);
     return backend.runWebGLProgram(maxPoolProgram, [x], x.dtype);
 }
-const maxPoolConfig = {
+const maxPoolConfig$1 = {
     kernelName: MaxPool,
     backendName: 'webgl',
-    kernelFunc: maxPool
+    kernelFunc: maxPool$1
 };
 
 /**
@@ -36239,7 +36922,7 @@ function maxPool3d(args) {
     const maxPoolProgram = new Pool3DProgram(convInfo, 'max', false);
     return backend.runWebGLProgram(maxPoolProgram, [x], x.dtype);
 }
-const maxPool3DConfig = {
+const maxPool3DConfig$1 = {
     kernelName: MaxPool3D,
     backendName: 'webgl',
     kernelFunc: maxPool3d
@@ -36423,7 +37106,7 @@ class MaxPool3DBackpropProgram {
  * limitations under the License.
  * =============================================================================
  */
-function maxPool3DGrad(args) {
+function maxPool3DGrad$1(args) {
     const { inputs, backend, attrs } = args;
     const { dy, input } = inputs;
     const x = input;
@@ -36437,10 +37120,10 @@ function maxPool3DGrad(args) {
     backend.disposeIntermediateTensorInfo(maxPool3dPositions);
     return result;
 }
-const maxPool3DGradConfig$1 = {
+const maxPool3DGradConfig$2 = {
     kernelName: MaxPool3DGrad,
     backendName: 'webgl',
-    kernelFunc: maxPool3DGrad
+    kernelFunc: maxPool3DGrad$1
 };
 
 /**
@@ -36459,11 +37142,11 @@ const maxPool3DGradConfig$1 = {
  * limitations under the License.
  * =============================================================================
  */
-function maxPoolGrad$1(args) {
+function maxPoolGrad$2(args) {
     const { inputs, backend, attrs } = args;
     const { dy, input, output } = inputs;
     const x = input;
-    assertNotComplex([input, output], 'maxPoolGrad');
+    assertNotComplex$1([input, output], 'maxPoolGrad');
     const { filterSize, strides, pad, dimRoundingMode } = attrs;
     const convInfo = computePool2DInfo(x.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode);
     const getPositions = true;
@@ -36474,10 +37157,10 @@ function maxPoolGrad$1(args) {
     backend.disposeIntermediateTensorInfo(maxPoolPositions);
     return result;
 }
-const maxPoolGradConfig$1 = {
+const maxPoolGradConfig$2 = {
     kernelName: MaxPoolGrad,
     backendName: 'webgl',
-    kernelFunc: maxPoolGrad$1
+    kernelFunc: maxPoolGrad$2
 };
 
 /**
@@ -36496,7 +37179,7 @@ const maxPoolGradConfig$1 = {
  * limitations under the License.
  * =============================================================================
  */
-function maxPoolWithArgmaxImpl(x, includeBatchInIndex, convInfo, backend) {
+function maxPoolWithArgmaxImpl$1(x, includeBatchInIndex, convInfo, backend) {
     let program = new Pool2DProgram(convInfo, 'max', false);
     const poolOutput = backend.runWebGLProgram(program, [x], 'float32');
     program = new Pool2DProgram(convInfo, 'max', true, true, includeBatchInIndex);
@@ -36520,7 +37203,7 @@ function maxPoolWithArgmaxImpl(x, includeBatchInIndex, convInfo, backend) {
  * limitations under the License.
  * =============================================================================
  */
-const maxPoolWithArgmaxConfig = {
+const maxPoolWithArgmaxConfig$1 = {
     kernelName: MaxPoolWithArgmax,
     backendName: 'webgl',
     kernelFunc: ({ inputs, attrs, backend }) => {
@@ -36532,7 +37215,7 @@ const maxPoolWithArgmaxConfig = {
         assert$1(eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in maxPool: Either strides or dilations must be 1. ' +
             `Got strides ${strides} and dilations '${dilations}'`);
         const convInfo = computePool2DInfo(x.shape, filterSize, strides, dilations, pad);
-        const [result, indexes] = maxPoolWithArgmaxImpl(x, includeBatchInIndex, convInfo, webglBackend);
+        const [result, indexes] = maxPoolWithArgmaxImpl$1(x, includeBatchInIndex, convInfo, webglBackend);
         return [result, indexes];
     }
 };
@@ -36557,9 +37240,9 @@ function meanImpl(x, reduceShape, outShape, backend) {
     const inSize = sizeFromShape(reduceShape);
     const xSize = sizeFromShape(x.shape);
     const batchSize = xSize / inSize;
-    const reshapedInput = reshape({ inputs: { x }, attrs: { shape: [batchSize, inSize] }, backend });
+    const reshapedInput = reshape$1({ inputs: { x }, attrs: { shape: [batchSize, inSize] }, backend });
     const reduced = reduce(reshapedInput, 'float32', 'mean', backend);
-    const reshapedOutput = reshape({ inputs: { x: reduced }, attrs: { shape: outShape }, backend });
+    const reshapedOutput = reshape$1({ inputs: { x: reduced }, attrs: { shape: outShape }, backend });
     backend.disposeIntermediateTensorInfo(reshapedInput);
     backend.disposeIntermediateTensorInfo(reduced);
     return reshapedOutput;
@@ -36581,7 +37264,7 @@ function meanImpl(x, reduceShape, outShape, backend) {
  * limitations under the License.
  * =============================================================================
  */
-const meanConfig = {
+const meanConfig$1 = {
     kernelName: Mean,
     backendName: 'webgl',
     kernelFunc: ({ inputs, attrs, backend }) => {
@@ -36646,7 +37329,7 @@ const meanConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function min(args) {
+function min$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { axis, keepDims } = attrs;
@@ -36662,15 +37345,15 @@ function min(args) {
     assertAxesAreInnerMostDims('min', axes, xRank);
     const [outShape, reduceShape] = computeOutAndReduceShapes(permutedX.shape, axes);
     const inSize = sizeFromShape(reduceShape);
-    const a2D = reshape({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
+    const a2D = reshape$1({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
     const reduced = reduce(a2D, a2D.dtype, 'min', backend);
     let res;
     if (keepDims) {
         const newShape = expandShapeToKeepDim(outShape, origAxes);
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: newShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: newShape } });
     }
     else {
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
     }
     backend.disposeIntermediateTensorInfo(a2D);
     backend.disposeIntermediateTensorInfo(reduced);
@@ -36679,10 +37362,10 @@ function min(args) {
     }
     return res;
 }
-const minConfig = {
+const minConfig$1 = {
     kernelName: Min,
     backendName: 'webgl',
-    kernelFunc: min
+    kernelFunc: min$1
 };
 
 /**
@@ -36951,7 +37634,7 @@ const mirrorPadKernelFunc = ({ inputs, backend, attrs }) => {
     const output = backend.runWebGLProgram(program, [x], x.dtype);
     return output;
 };
-const mirrorPadConfig = {
+const mirrorPadConfig$1 = {
     kernelName: MirrorPad,
     backendName: 'webgl',
     kernelFunc: mirrorPadKernelFunc,
@@ -36982,14 +37665,14 @@ const MOD_PACKED = `
     CHECK_NAN_SNIPPET_PACKED + `
   return result;
 `;
-const mod = binaryKernelFunc({
+const mod$1 = binaryKernelFunc({
     opSnippet: MOD,
     packedOpSnippet: MOD_PACKED,
 });
-const modConfig = {
+const modConfig$1 = {
     kernelName: Mod,
     backendName: 'webgl',
-    kernelFunc: mod
+    kernelFunc: mod$1
 };
 
 /**
@@ -37082,7 +37765,7 @@ const DIV_PACKED = `
   return result;
 `;
 const realDiv = binaryKernelFunc({ opSnippet: DIV, packedOpSnippet: DIV_PACKED, checkOutOfBounds: true });
-const realDivConfig = {
+const realDivConfig$1 = {
     kernelName: RealDiv,
     backendName: 'webgl',
     kernelFunc: realDiv,
@@ -37133,22 +37816,22 @@ const subConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function softmax(args) {
+function softmax$1(args) {
     const { inputs, backend, attrs } = args;
     const { logits } = inputs;
     const { dim } = attrs;
     const axes = parseAxisParam([dim], logits.shape);
-    const maxLogit = max({
+    const maxLogit = max$1({
         inputs: { x: logits },
         backend,
         attrs: { reductionIndices: axes, keepDims: false }
     });
     const expandedShape = expandShapeToKeepDim(maxLogit.shape, axes);
-    const maxLogitsReshaped = reshape({ inputs: { x: maxLogit }, backend, attrs: { shape: expandedShape } });
+    const maxLogitsReshaped = reshape$1({ inputs: { x: maxLogit }, backend, attrs: { shape: expandedShape } });
     const a = sub({ inputs: { a: logits, b: maxLogitsReshaped }, backend });
     const b = exp({ inputs: { x: a }, backend });
-    const sumExp = sum({ inputs: { x: b }, backend, attrs: { axis: axes, keepDims: false } });
-    const sumExpReshaped = reshape({ inputs: { x: sumExp }, backend, attrs: { shape: expandedShape } });
+    const sumExp = sum$1({ inputs: { x: b }, backend, attrs: { axis: axes, keepDims: false } });
+    const sumExpReshaped = reshape$1({ inputs: { x: sumExp }, backend, attrs: { shape: expandedShape } });
     const res = realDiv({ inputs: { a: b, b: sumExpReshaped }, backend });
     backend.disposeIntermediateTensorInfo(maxLogit);
     backend.disposeIntermediateTensorInfo(maxLogitsReshaped);
@@ -37158,10 +37841,10 @@ function softmax(args) {
     backend.disposeIntermediateTensorInfo(sumExpReshaped);
     return res;
 }
-const softmaxConfig = {
+const softmaxConfig$1 = {
     kernelName: Softmax$1,
     backendName: 'webgl',
-    kernelFunc: softmax
+    kernelFunc: softmax$1
 };
 
 /**
@@ -37180,13 +37863,13 @@ const softmaxConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function multinomial(args) {
+function multinomial$1(args) {
     const { inputs, backend, attrs } = args;
     const { logits } = inputs;
     const { numSamples, seed, normalized } = attrs;
     const probs = normalized ?
         logits :
-        softmax({ inputs: { logits }, backend, attrs: { dim: logits.shape.length - 1 } });
+        softmax$1({ inputs: { logits }, backend, attrs: { dim: logits.shape.length - 1 } });
     const batchSize = probs.shape[0];
     const numOutcomes = probs.shape[1];
     const program = new MultinomialProgram(batchSize, numOutcomes, numSamples);
@@ -37197,10 +37880,10 @@ function multinomial(args) {
     }
     return res;
 }
-const multinomialConfig = {
+const multinomialConfig$1 = {
     kernelName: Multinomial,
     backendName: 'webgl',
-    kernelFunc: multinomial
+    kernelFunc: multinomial$1
 };
 
 /**
@@ -37274,8 +37957,8 @@ const negConfig = {
  * limitations under the License.
  * =============================================================================
  */
-const nonMaxSuppressionV3Impl = nonMaxSuppressionV3Impl$1;
-function nonMaxSuppressionV3(args) {
+const nonMaxSuppressionV3Impl$1 = nonMaxSuppressionV3Impl$2;
+function nonMaxSuppressionV3$1(args) {
     warn('tf.nonMaxSuppression() in webgl locks the UI thread. ' +
         'Call tf.nonMaxSuppressionAsync() instead');
     const { inputs, backend, attrs } = args;
@@ -37283,13 +37966,13 @@ function nonMaxSuppressionV3(args) {
     const { maxOutputSize, iouThreshold, scoreThreshold } = attrs;
     const boxesVals = backend.readSync(boxes.dataId);
     const scoresVals = backend.readSync(scores.dataId);
-    const { selectedIndices } = nonMaxSuppressionV3Impl(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold);
+    const { selectedIndices } = nonMaxSuppressionV3Impl$1(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold);
     return backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices));
 }
-const nonMaxSuppressionV3Config = {
+const nonMaxSuppressionV3Config$1 = {
     kernelName: NonMaxSuppressionV3,
     backendName: 'webgl',
-    kernelFunc: nonMaxSuppressionV3
+    kernelFunc: nonMaxSuppressionV3$1
 };
 
 /**
@@ -37308,8 +37991,8 @@ const nonMaxSuppressionV3Config = {
  * limitations under the License.
  * =============================================================================
  */
-const nonMaxSuppressionV4Impl = nonMaxSuppressionV4Impl$1;
-function nonMaxSuppressionV4(args) {
+const nonMaxSuppressionV4Impl$1 = nonMaxSuppressionV4Impl$2;
+function nonMaxSuppressionV4$1(args) {
     warn('tf.nonMaxSuppression() in webgl locks the UI thread. ' +
         'Call tf.nonMaxSuppressionAsync() instead');
     const { inputs, backend, attrs } = args;
@@ -37317,16 +38000,16 @@ function nonMaxSuppressionV4(args) {
     const { maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize } = attrs;
     const boxesVals = backend.readSync(boxes.dataId);
     const scoresVals = backend.readSync(scores.dataId);
-    const { selectedIndices, validOutputs } = nonMaxSuppressionV4Impl(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize);
+    const { selectedIndices, validOutputs } = nonMaxSuppressionV4Impl$1(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize);
     return [
         backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices)),
         backend.makeTensorInfo([], 'int32', new Int32Array([validOutputs]))
     ];
 }
-const nonMaxSuppressionV4Config = {
+const nonMaxSuppressionV4Config$1 = {
     kernelName: NonMaxSuppressionV4,
     backendName: 'webgl',
-    kernelFunc: nonMaxSuppressionV4
+    kernelFunc: nonMaxSuppressionV4$1
 };
 
 /**
@@ -37345,8 +38028,8 @@ const nonMaxSuppressionV4Config = {
  * limitations under the License.
  * =============================================================================
  */
-const nonMaxSuppressionV5Impl = nonMaxSuppressionV5Impl$1;
-function nonMaxSuppressionV5(args) {
+const nonMaxSuppressionV5Impl$1 = nonMaxSuppressionV5Impl$2;
+function nonMaxSuppressionV5$1(args) {
     warn('tf.nonMaxSuppression() in webgl locks the UI thread. ' +
         'Call tf.nonMaxSuppressionAsync() instead');
     const { inputs, backend, attrs } = args;
@@ -37358,16 +38041,16 @@ function nonMaxSuppressionV5(args) {
     const iouThresholdVal = iouThreshold;
     const scoreThresholdVal = scoreThreshold;
     const softNmsSigmaVal = softNmsSigma;
-    const { selectedIndices, selectedScores } = nonMaxSuppressionV5Impl(boxesVals, scoresVals, maxOutputSizeVal, iouThresholdVal, scoreThresholdVal, softNmsSigmaVal);
+    const { selectedIndices, selectedScores } = nonMaxSuppressionV5Impl$1(boxesVals, scoresVals, maxOutputSizeVal, iouThresholdVal, scoreThresholdVal, softNmsSigmaVal);
     return [
         backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices)),
         backend.makeTensorInfo([selectedScores.length], 'float32', new Float32Array(selectedScores))
     ];
 }
-const nonMaxSuppressionV5Config = {
+const nonMaxSuppressionV5Config$1 = {
     kernelName: NonMaxSuppressionV5,
     backendName: 'webgl',
-    kernelFunc: nonMaxSuppressionV5
+    kernelFunc: nonMaxSuppressionV5$1
 };
 
 /**
@@ -37417,24 +38100,24 @@ class OneHotProgram {
  * limitations under the License.
  * =============================================================================
  */
-const oneHot = (args) => {
+const oneHot$1 = (args) => {
     const { inputs, backend, attrs } = args;
     const { indices } = inputs;
     const { dtype, depth, onValue, offValue } = attrs;
     const indicesSize = sizeFromShape(indices.shape);
     const program = new OneHotProgram(indicesSize, depth, onValue, offValue);
-    const reshaped = reshape({ inputs: { x: indices }, backend, attrs: { shape: [indicesSize] } });
+    const reshaped = reshape$1({ inputs: { x: indices }, backend, attrs: { shape: [indicesSize] } });
     const result = backend.runWebGLProgram(program, [reshaped], dtype);
     backend.disposeIntermediateTensorInfo(reshaped);
     const outShape = [...indices.shape, depth];
-    const out = reshape({ inputs: { x: result }, backend, attrs: { shape: outShape } });
+    const out = reshape$1({ inputs: { x: result }, backend, attrs: { shape: outShape } });
     backend.disposeIntermediateTensorInfo(result);
     return out;
 };
-const oneHotConfig = {
+const oneHotConfig$1 = {
     kernelName: OneHot,
     backendName: 'webgl',
-    kernelFunc: oneHot
+    kernelFunc: oneHot$1
 };
 
 /**
@@ -37453,14 +38136,14 @@ const oneHotConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function zerosLike(args) {
+function zerosLike$1(args) {
     const { inputs, backend } = args;
     const { x } = inputs;
     if (x.dtype === 'complex64') {
         const realPart = real({ inputs: { input: x }, backend });
-        const r = zerosLike({ inputs: { x: realPart }, backend });
-        const imagPart = imag({ inputs: { input: x }, backend });
-        const i = zerosLike({ inputs: { x: imagPart }, backend });
+        const r = zerosLike$1({ inputs: { x: realPart }, backend });
+        const imagPart = imag$1({ inputs: { input: x }, backend });
+        const i = zerosLike$1({ inputs: { x: imagPart }, backend });
         const result = complex({ inputs: { real: r, imag: i }, backend });
         backend.disposeIntermediateTensorInfo(realPart);
         backend.disposeIntermediateTensorInfo(r);
@@ -37469,7 +38152,7 @@ function zerosLike(args) {
         return result;
     }
     else {
-        return fill({
+        return fill$1({
             attrs: {
                 shape: x.shape,
                 dtype: x.dtype,
@@ -37479,10 +38162,10 @@ function zerosLike(args) {
         });
     }
 }
-const zerosLikeConfig = {
+const zerosLikeConfig$1 = {
     kernelName: ZerosLike,
     backendName: 'webgl',
-    kernelFunc: zerosLike
+    kernelFunc: zerosLike$1
 };
 
 /**
@@ -37501,7 +38184,7 @@ const zerosLikeConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function onesLike(args) {
+function onesLike$1(args) {
     const { inputs, backend } = args;
     const { x } = inputs;
     if (x.dtype === 'string') {
@@ -37509,9 +38192,9 @@ function onesLike(args) {
     }
     else if (x.dtype === 'complex64') {
         const realPart = real({ inputs: { input: x }, backend });
-        const r = onesLike({ inputs: { x: realPart }, backend });
-        const imagPart = imag({ inputs: { input: x }, backend });
-        const i = zerosLike({ inputs: { x: imagPart }, backend });
+        const r = onesLike$1({ inputs: { x: realPart }, backend });
+        const imagPart = imag$1({ inputs: { input: x }, backend });
+        const i = zerosLike$1({ inputs: { x: imagPart }, backend });
         const result = complex({ inputs: { real: r, imag: i }, backend });
         backend.disposeIntermediateTensorInfo(realPart);
         backend.disposeIntermediateTensorInfo(r);
@@ -37522,13 +38205,13 @@ function onesLike(args) {
     else {
         // TODO(cais, smilkov): Add WebGL shader for onesLike:
         //   https://github.com/tensorflow/tfjs/issues/1293
-        return fill({ attrs: { shape: x.shape, dtype: x.dtype, value: 1 }, backend });
+        return fill$1({ attrs: { shape: x.shape, dtype: x.dtype, value: 1 }, backend });
     }
 }
-const onesLikeConfig = {
+const onesLikeConfig$1 = {
     kernelName: OnesLike,
     backendName: 'webgl',
-    kernelFunc: onesLike
+    kernelFunc: onesLike$1
 };
 
 /**
@@ -37547,11 +38230,11 @@ const onesLikeConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function pack(args) {
+function pack$1(args) {
     const { inputs, backend, attrs } = args;
     const { axis } = attrs;
     if (inputs.length === 1) {
-        return expandDims$1({ inputs: { input: inputs[0] }, backend, attrs: { dim: axis } });
+        return expandDims$2({ inputs: { input: inputs[0] }, backend, attrs: { dim: axis } });
     }
     const shape = inputs[0].shape;
     const dtype = inputs[0].dtype;
@@ -37561,18 +38244,18 @@ function pack(args) {
     });
     const intermediateTensorInfos = [];
     const expandedTensors = inputs.map(t => {
-        const expandedT = expandDims$1({ inputs: { input: t }, backend, attrs: { dim: axis } });
+        const expandedT = expandDims$2({ inputs: { input: t }, backend, attrs: { dim: axis } });
         intermediateTensorInfos.push(expandedT);
         return expandedT;
     });
-    const result = concat({ inputs: expandedTensors, backend, attrs: { axis } });
+    const result = concat$1({ inputs: expandedTensors, backend, attrs: { axis } });
     intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return result;
 }
-const packConfig = {
+const packConfig$1 = {
     kernelName: Pack,
     backendName: 'webgl',
-    kernelFunc: pack
+    kernelFunc: pack$1
 };
 
 /**
@@ -37722,7 +38405,7 @@ class PadPackedProgram {
  * limitations under the License.
  * =============================================================================
  */
-const padV2 = (args) => {
+const padV2$1 = (args) => {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { paddings, constantValue } = attrs;
@@ -37730,7 +38413,7 @@ const padV2 = (args) => {
         // Short-circuit the computation, since x doesn't have value, only
         // the shape is used to compute output shape to pad.
         const outputShape = paddings.map((p, i) => p[0] /* beforePad */ + x.shape[i] + p[1] /* afterPad */);
-        return fill({
+        return fill$1({
             backend,
             attrs: { shape: outputShape, value: constantValue, dtype: x.dtype }
         });
@@ -37741,10 +38424,10 @@ const padV2 = (args) => {
     const customValues = [[constantValue]];
     return backend.runWebGLProgram(program, [x], x.dtype, customValues);
 };
-const padV2Config = {
+const padV2Config$1 = {
     kernelName: PadV2,
     backendName: 'webgl',
-    kernelFunc: padV2
+    kernelFunc: padV2$1
 };
 
 /**
@@ -37793,11 +38476,11 @@ const POW_PACKED = `
     CHECK_NAN_SNIPPET_PACKED + `
   return result;
 `;
-const pow = binaryKernelFunc({ opSnippet: POW, packedOpSnippet: POW_PACKED });
-const powConfig = {
+const pow$1 = binaryKernelFunc({ opSnippet: POW, packedOpSnippet: POW_PACKED });
+const powConfig$1 = {
     kernelName: Pow,
     backendName: 'webgl',
-    kernelFunc: pow
+    kernelFunc: pow$1
 };
 
 /**
@@ -37841,17 +38524,17 @@ function prod(args) {
     else {
         const [outShape, reduceShape] = computeOutAndReduceShapes(permutedX.shape, axes);
         const inSize = sizeFromShape(reduceShape);
-        const a2D = reshape({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
+        const a2D = reshape$1({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
         const outputDType = sumOutType(x.dtype);
         const reduced = reduce(a2D, outputDType, 'prod', backend);
-        res = reshape({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
+        res = reshape$1({ inputs: { x: reduced }, backend, attrs: { shape: outShape } });
         toDispose.push(a2D);
         toDispose.push(reduced);
     }
     if (keepDims) {
         toDispose.push(res);
         const newShape = expandShapeToKeepDim(res.shape, origAxes);
-        res = reshape({ inputs: { x: res }, backend, attrs: { shape: newShape } });
+        res = reshape$1({ inputs: { x: res }, backend, attrs: { shape: newShape } });
     }
     toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return res;
@@ -37878,7 +38561,7 @@ const prodConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function raggedGather(args) {
+function raggedGather$1(args) {
     const { inputs, backend, attrs } = args;
     const { paramsNestedSplits, paramsDenseValues, indices } = inputs;
     const { outputRaggedRank } = attrs;
@@ -37891,10 +38574,10 @@ function raggedGather(args) {
     const outputDenseValuesTensor = backend.makeTensorInfo(outputDenseValuesShape, paramsDenseValues.dtype, outputDenseValues);
     return outputNestedSplitsTensors.concat([outputDenseValuesTensor]);
 }
-const raggedGatherConfig = {
+const raggedGatherConfig$1 = {
     kernelName: RaggedGather,
     backendName: 'webgl',
-    kernelFunc: raggedGather,
+    kernelFunc: raggedGather$1,
 };
 
 /**
@@ -37913,7 +38596,7 @@ const raggedGatherConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function raggedRange(args) {
+function raggedRange$1(args) {
     const { inputs, backend } = args;
     const { starts, limits, deltas } = inputs;
     const $starts = backend.readSync(starts.dataId);
@@ -37924,10 +38607,10 @@ function raggedRange(args) {
     const rtDenseValues = backend.makeTensorInfo([rtDenseValuesData.length], starts.dtype, rtDenseValuesData);
     return [rtNestedSplits, rtDenseValues];
 }
-const raggedRangeConfig = {
+const raggedRangeConfig$1 = {
     kernelName: RaggedRange,
     backendName: 'webgl',
-    kernelFunc: raggedRange,
+    kernelFunc: raggedRange$1,
 };
 
 /**
@@ -37946,7 +38629,7 @@ const raggedRangeConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function raggedTensorToTensor(args) {
+function raggedTensorToTensor$1(args) {
     const { inputs, backend, attrs } = args;
     const { shape, values, defaultValue, rowPartitionTensors } = inputs;
     const { rowPartitionTypes } = attrs;
@@ -37958,10 +38641,10 @@ function raggedTensorToTensor(args) {
     const [outputShape, output] = raggedTensorToTensorImplCPU($shape, shape.shape, $values, values.shape, values.dtype, $defaultValue, defaultValue.shape, $rowPartitionValues, rowPartitionValuesShapes, rowPartitionTypes);
     return backend.makeTensorInfo(outputShape, values.dtype, output);
 }
-const raggedTensorToTensorConfig = {
+const raggedTensorToTensorConfig$1 = {
     kernelName: RaggedTensorToTensor,
     backendName: 'webgl',
-    kernelFunc: raggedTensorToTensor,
+    kernelFunc: raggedTensorToTensor$1,
 };
 
 /**
@@ -37980,16 +38663,16 @@ const raggedTensorToTensorConfig = {
  * limitations under the License.
  * =============================================================================
  */
-const range$1 = (args) => {
+const range$2 = (args) => {
     const { backend, attrs } = args;
     const { start, stop, step, dtype } = attrs;
     const values = rangeImplCPU(start, stop, step, dtype);
     return backend.makeTensorInfo([values.length], dtype, values);
 };
-const rangeConfig = {
+const rangeConfig$1 = {
     kernelName: Range,
     backendName: 'webgl',
-    kernelFunc: range$1
+    kernelFunc: range$2
 };
 
 /**
@@ -38009,11 +38692,11 @@ const rangeConfig = {
  * =============================================================================
  */
 const RECIPROCAL = `return 1.0 / x;`;
-const reciprocal = unaryKernelFunc({ opSnippet: RECIPROCAL });
-const reciprocalConfig = {
+const reciprocal$1 = unaryKernelFunc({ opSnippet: RECIPROCAL });
+const reciprocalConfig$1 = {
     kernelName: Reciprocal,
     backendName: 'webgl',
-    kernelFunc: reciprocal,
+    kernelFunc: reciprocal$1,
 };
 
 /**
@@ -38046,11 +38729,11 @@ const RELU_PACKED = `
 
   return result;
 `;
-const relu = unaryKernelFunc({ opSnippet: RELU, packedOpSnippet: RELU_PACKED });
-const reluConfig = {
+const relu$1 = unaryKernelFunc({ opSnippet: RELU, packedOpSnippet: RELU_PACKED });
+const reluConfig$1 = {
     kernelName: Relu$1,
     backendName: 'webgl',
-    kernelFunc: relu
+    kernelFunc: relu$1
 };
 
 /**
@@ -38083,11 +38766,11 @@ const RELU6_PACKED = `
 
   return result;
 `;
-const relu6 = unaryKernelFunc({ opSnippet: RELU6, packedOpSnippet: RELU6_PACKED });
-const relu6Config = {
+const relu6$1 = unaryKernelFunc({ opSnippet: RELU6, packedOpSnippet: RELU6_PACKED });
+const relu6Config$1 = {
     kernelName: Relu6$1,
     backendName: 'webgl',
-    kernelFunc: relu6
+    kernelFunc: relu6$1
 };
 
 /**
@@ -38303,7 +38986,7 @@ class ResizeBilinearPackedProgram {
  * limitations under the License.
  * =============================================================================
  */
-function resizeBilinear(args) {
+function resizeBilinear$1(args) {
     const { inputs, backend, attrs } = args;
     const { images } = inputs;
     const { alignCorners, halfPixelCenters, size } = attrs;
@@ -38313,10 +38996,10 @@ function resizeBilinear(args) {
         new ResizeBilinearProgram(images.shape, newHeight, newWidth, alignCorners, halfPixelCenters);
     return backend.runWebGLProgram(program, [images], 'float32');
 }
-const resizeBilinearConfig = {
+const resizeBilinearConfig$1 = {
     kernelName: ResizeBilinear,
     backendName: 'webgl',
-    kernelFunc: resizeBilinear
+    kernelFunc: resizeBilinear$1
 };
 
 /**
@@ -38462,17 +39145,17 @@ class ResizeBilinearBackpropProgram {
  * limitations under the License.
  * =============================================================================
  */
-function resizeBilinearGrad(args) {
+function resizeBilinearGrad$1(args) {
     const { inputs, backend, attrs } = args;
     const { images, dy } = inputs;
     const { alignCorners } = attrs;
     const program = new ResizeBilinearBackpropProgram(dy.shape, images.shape, alignCorners);
     return backend.runWebGLProgram(program, [dy], dy.dtype);
 }
-const resizeBilinearGradConfig$1 = {
+const resizeBilinearGradConfig$2 = {
     kernelName: ResizeBilinearGrad,
     backendName: 'webgl',
-    kernelFunc: resizeBilinearGrad
+    kernelFunc: resizeBilinearGrad$1
 };
 
 /**
@@ -38645,7 +39328,7 @@ class ResizeNearestNeighborPackedProgram {
  * limitations under the License.
  * =============================================================================
  */
-function resizeNearestNeighbor(args) {
+function resizeNearestNeighbor$1(args) {
     const { inputs, backend, attrs } = args;
     const { images } = inputs;
     const { alignCorners, halfPixelCenters, size } = attrs;
@@ -38655,10 +39338,10 @@ function resizeNearestNeighbor(args) {
         new ResizeNearestNeighborProgram(images.shape, newHeight, newWidth, alignCorners, halfPixelCenters);
     return backend.runWebGLProgram(program, [images], images.dtype);
 }
-const resizeNearestNeighborConfig = {
+const resizeNearestNeighborConfig$1 = {
     kernelName: ResizeNearestNeighbor,
     backendName: 'webgl',
-    kernelFunc: resizeNearestNeighbor
+    kernelFunc: resizeNearestNeighbor$1
 };
 
 /**
@@ -38793,17 +39476,17 @@ class ResizeNearestNeigborBackpropProgram {
  * limitations under the License.
  * =============================================================================
  */
-function resizeNearestNeighborGrad(args) {
+function resizeNearestNeighborGrad$1(args) {
     const { inputs, backend, attrs } = args;
     const { images, dy } = inputs;
     const { alignCorners } = attrs;
     const program = new ResizeNearestNeigborBackpropProgram(dy.shape, images.shape, alignCorners);
     return backend.runWebGLProgram(program, [dy], dy.dtype);
 }
-const resizeNearestNeighborGradConfig$1 = {
+const resizeNearestNeighborGradConfig$2 = {
     kernelName: ResizeNearestNeighborGrad,
     backendName: 'webgl',
-    kernelFunc: resizeNearestNeighborGrad
+    kernelFunc: resizeNearestNeighborGrad$1
 };
 
 /**
@@ -38969,7 +39652,7 @@ class ReversePackedProgram {
  * limitations under the License.
  * =============================================================================
  */
-function reverse(args) {
+function reverse$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { dims } = attrs;
@@ -38983,10 +39666,10 @@ function reverse(args) {
         new ReverseProgram(x.shape, $dims);
     return backend.runWebGLProgram(program, [x], x.dtype);
 }
-const reverseConfig = {
+const reverseConfig$1 = {
     kernelName: Reverse,
     backendName: 'webgl',
-    kernelFunc: reverse
+    kernelFunc: reverse$1
 };
 
 /**
@@ -39059,7 +39742,7 @@ class RotateProgram {
  * limitations under the License.
  * =============================================================================
  */
-const rotateWithOffsetConfig = {
+const rotateWithOffsetConfig$1 = {
     kernelName: RotateWithOffset,
     backendName: 'webgl',
     kernelFunc: ({ inputs, attrs, backend }) => {
@@ -39106,11 +39789,11 @@ const ROUND = `
     }
   }
 `;
-const round = unaryKernelFunc({ opSnippet: ROUND });
-const roundConfig = {
+const round$1 = unaryKernelFunc({ opSnippet: ROUND });
+const roundConfig$1 = {
     kernelName: Round,
     backendName: 'webgl',
-    kernelFunc: round,
+    kernelFunc: round$1,
 };
 
 /**
@@ -39309,7 +39992,7 @@ class ScatterPackedProgram {
  * limitations under the License.
  * =============================================================================
  */
-function scatterNd(args) {
+function scatterNd$1(args) {
     const { inputs, backend, attrs } = args;
     const { indices, updates } = inputs;
     const { shape } = attrs;
@@ -39318,8 +40001,8 @@ function scatterNd(args) {
     if (outputSize === 0) {
         return backend.makeTensorInfo(shape, indices.dtype);
     }
-    const flattenIndices = reshape({ inputs: { x: indices }, backend, attrs: { shape: [numUpdates, sliceRank] } });
-    const flattenX = reshape({ inputs: { x: updates }, backend, attrs: { shape: [numUpdates, sliceSize] } });
+    const flattenIndices = reshape$1({ inputs: { x: indices }, backend, attrs: { shape: [numUpdates, sliceRank] } });
+    const flattenX = reshape$1({ inputs: { x: updates }, backend, attrs: { shape: [numUpdates, sliceSize] } });
     const defaultValue = backend.makeTensorInfo([], 'float32', new Float32Array([0])); // scalar(0)
     let program;
     if (env().getBool('WEBGL_PACK')) {
@@ -39329,17 +40012,17 @@ function scatterNd(args) {
         program = new ScatterProgram(numUpdates, sliceRank, flattenIndices.shape.length, flattenX.shape.length, strides, flattenShape);
     }
     const res = backend.runWebGLProgram(program, [flattenX, flattenIndices, defaultValue], flattenX.dtype);
-    const reshaped = reshape({ inputs: { x: res }, backend, attrs: { shape } });
+    const reshaped = reshape$1({ inputs: { x: res }, backend, attrs: { shape } });
     backend.disposeIntermediateTensorInfo(flattenIndices);
     backend.disposeIntermediateTensorInfo(flattenX);
     backend.disposeIntermediateTensorInfo(res);
     backend.disposeIntermediateTensorInfo(defaultValue);
     return reshaped;
 }
-const scatterNdConfig = {
+const scatterNdConfig$1 = {
     kernelName: ScatterNd,
     backendName: 'webgl',
-    kernelFunc: scatterNd
+    kernelFunc: scatterNd$1
 };
 
 /**
@@ -39416,7 +40099,7 @@ class SearchSortedProgram {
  * limitations under the License.
  * =============================================================================
  */
-function searchSorted(args) {
+function searchSorted$1(args) {
     const { inputs, backend, attrs } = args;
     const { sortedSequence, values } = inputs;
     const { side } = attrs;
@@ -39424,10 +40107,10 @@ function searchSorted(args) {
     const customValues = [[sortedSequence.shape[1]]];
     return backend.runWebGLProgram(program, [sortedSequence, values], 'int32', customValues);
 }
-const searchSortedConfig = {
+const searchSortedConfig$1 = {
     kernelName: SearchSorted,
     backendName: 'webgl',
-    kernelFunc: searchSorted,
+    kernelFunc: searchSorted$1,
 };
 
 /**
@@ -39503,16 +40186,16 @@ class SelectProgram {
  * limitations under the License.
  * =============================================================================
  */
-function select(args) {
+function select$1(args) {
     const { inputs, backend } = args;
     const { condition, t, e } = inputs;
     const program = new SelectProgram(condition.shape.length, t.shape, t.shape.length);
     return backend.runWebGLProgram(program, [condition, t, e], upcastType(t.dtype, e.dtype));
 }
-const selectConfig = {
+const selectConfig$1 = {
     kernelName: Select,
     backendName: 'webgl',
-    kernelFunc: select
+    kernelFunc: select$1
 };
 
 /**
@@ -39538,11 +40221,11 @@ const SELU = `
   float scale = ${SELU_SCALE};
   return (x >= 0.0) ? scale * x : scaleAlpha * (exp(x) - 1.0);
 `;
-const selu = unaryKernelFunc({ opSnippet: SELU });
-const seluConfig = {
+const selu$1 = unaryKernelFunc({ opSnippet: SELU });
+const seluConfig$1 = {
     kernelName: Selu$1,
     backendName: 'webgl',
-    kernelFunc: selu,
+    kernelFunc: selu$1,
 };
 
 /**
@@ -39607,11 +40290,11 @@ const SIGN = `
   if (isnan(x)) { return 0.0; }
   return sign(x);
 `;
-const sign = unaryKernelFunc({ opSnippet: SIGN });
-const signConfig = {
+const sign$1 = unaryKernelFunc({ opSnippet: SIGN });
+const signConfig$1 = {
     kernelName: Sign,
     backendName: 'webgl',
-    kernelFunc: sign,
+    kernelFunc: sign$1,
 };
 
 /**
@@ -39639,11 +40322,11 @@ const SIN_PACKED = `
   ${CHECK_NAN_SNIPPET_PACKED}
   return result;
 `;
-const sin = unaryKernelFunc({ opSnippet: SIN, packedOpSnippet: SIN_PACKED });
-const sinConfig = {
+const sin$1 = unaryKernelFunc({ opSnippet: SIN, packedOpSnippet: SIN_PACKED });
+const sinConfig$1 = {
     kernelName: Sin,
     backendName: 'webgl',
-    kernelFunc: sin,
+    kernelFunc: sin$1,
 };
 
 /**
@@ -39666,11 +40349,11 @@ const SINH = `
   float e2x = exp(x);
   return (e2x - 1.0 / e2x) / 2.0;
 `;
-const sinh = unaryKernelFunc({ opSnippet: SINH });
-const sinhConfig = {
+const sinh$1 = unaryKernelFunc({ opSnippet: SINH });
+const sinhConfig$1 = {
     kernelName: Sinh,
     backendName: 'webgl',
-    kernelFunc: sinh,
+    kernelFunc: sinh$1,
 };
 
 /**
@@ -39710,11 +40393,11 @@ const SOFTPLUS = `
   }
   return result;
 `;
-const softplus = unaryKernelFunc({ opSnippet: SOFTPLUS });
-const softplusConfig = {
+const softplus$1 = unaryKernelFunc({ opSnippet: SOFTPLUS });
+const softplusConfig$1 = {
     kernelName: Softplus$1,
     backendName: 'webgl',
-    kernelFunc: softplus,
+    kernelFunc: softplus$1,
 };
 
 /**
@@ -39733,7 +40416,7 @@ const softplusConfig = {
  * limitations under the License.
  * =============================================================================
  */
-const spaceToBatchND = (args) => {
+const spaceToBatchND$1 = (args) => {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { blockShape, paddings } = attrs;
@@ -39746,7 +40429,7 @@ const spaceToBatchND = (args) => {
         completePaddings.push([0, 0]);
     }
     const toDispose = [];
-    const paddedX = padV2({
+    const paddedX = padV2$1({
         inputs: { x },
         backend,
         attrs: { paddings: completePaddings, constantValue: 0 }
@@ -39754,23 +40437,23 @@ const spaceToBatchND = (args) => {
     const reshapedPaddedShape = getReshaped(paddedX.shape, blockShape, prod, false);
     const permutedReshapedPaddedPermutation = getPermuted(reshapedPaddedShape.length, blockShape.length, false);
     const flattenShape = getReshapedPermuted(paddedX.shape, blockShape, prod, false);
-    const reshapedPaddedX = reshape({ inputs: { x: paddedX }, backend, attrs: { shape: reshapedPaddedShape } });
+    const reshapedPaddedX = reshape$1({ inputs: { x: paddedX }, backend, attrs: { shape: reshapedPaddedShape } });
     const paddedXT = transpose({
         inputs: { x: reshapedPaddedX },
         backend,
         attrs: { perm: permutedReshapedPaddedPermutation }
     });
-    const result = reshape({ inputs: { x: paddedXT }, backend, attrs: { shape: flattenShape } });
+    const result = reshape$1({ inputs: { x: paddedXT }, backend, attrs: { shape: flattenShape } });
     toDispose.push(paddedX);
     toDispose.push(reshapedPaddedX);
     toDispose.push(paddedXT);
     toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return result;
 };
-const spaceToBatchNDConfig = {
+const spaceToBatchNDConfig$1 = {
     kernelName: SpaceToBatchND,
     backendName: 'webgl',
-    kernelFunc: spaceToBatchND
+    kernelFunc: spaceToBatchND$1
 };
 
 /**
@@ -39789,7 +40472,7 @@ const spaceToBatchNDConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function sparseFillEmptyRows(args) {
+function sparseFillEmptyRows$1(args) {
     const { inputs, backend } = args;
     const { indices, values, denseShape, defaultValue } = inputs;
     if (denseShape.shape.length !== 1) {
@@ -39820,10 +40503,10 @@ function sparseFillEmptyRows(args) {
         backend.makeTensorInfo([reverseIndexMap.length], indices.dtype, new Int32Array(reverseIndexMap)),
     ];
 }
-const sparseFillEmptyRowsConfig = {
+const sparseFillEmptyRowsConfig$1 = {
     kernelName: SparseFillEmptyRows,
     backendName: 'webgl',
-    kernelFunc: sparseFillEmptyRows,
+    kernelFunc: sparseFillEmptyRows$1,
 };
 
 /**
@@ -39842,7 +40525,7 @@ const sparseFillEmptyRowsConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function sparseReshape(args) {
+function sparseReshape$1(args) {
     const { inputs, backend } = args;
     const { inputIndices, inputShape, newShape } = inputs;
     if (inputIndices.shape.length !== 2) {
@@ -39863,10 +40546,10 @@ function sparseReshape(args) {
         backend.makeTensorInfo([outputShape.length], newShape.dtype, new Int32Array(outputShape)),
     ];
 }
-const sparseReshapeConfig = {
+const sparseReshapeConfig$1 = {
     kernelName: SparseReshape,
     backendName: 'webgl',
-    kernelFunc: sparseReshape,
+    kernelFunc: sparseReshape$1,
 };
 
 /**
@@ -39885,7 +40568,7 @@ const sparseReshapeConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function sparseSegmentMean(args) {
+function sparseSegmentMean$1(args) {
     const { inputs, backend } = args;
     const { data, indices, segmentIds } = inputs;
     if (data.shape.length < 1) {
@@ -39905,10 +40588,10 @@ function sparseSegmentMean(args) {
     const [outputData, outputDataShape] = sparseSegmentReductionImplCPU($data, data.shape, data.dtype, $indices, $segmentIds, true);
     return backend.makeTensorInfo(outputDataShape, data.dtype, outputData);
 }
-const sparseSegmentMeanConfig = {
+const sparseSegmentMeanConfig$1 = {
     kernelName: SparseSegmentMean,
     backendName: 'webgl',
-    kernelFunc: sparseSegmentMean,
+    kernelFunc: sparseSegmentMean$1,
 };
 
 /**
@@ -39927,7 +40610,7 @@ const sparseSegmentMeanConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function sparseSegmentSum(args) {
+function sparseSegmentSum$1(args) {
     const { inputs, backend } = args;
     const { data, indices, segmentIds } = inputs;
     if (data.shape.length < 1) {
@@ -39947,10 +40630,10 @@ function sparseSegmentSum(args) {
     const [outputData, outputDataShape] = sparseSegmentReductionImplCPU($data, data.shape, data.dtype, $indices, $segmentIds);
     return backend.makeTensorInfo(outputDataShape, data.dtype, outputData);
 }
-const sparseSegmentSumConfig = {
+const sparseSegmentSumConfig$1 = {
     kernelName: SparseSegmentSum,
     backendName: 'webgl',
-    kernelFunc: sparseSegmentSum,
+    kernelFunc: sparseSegmentSum$1,
 };
 
 /**
@@ -39969,7 +40652,7 @@ const sparseSegmentSumConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function sparseToDense(args) {
+function sparseToDense$1(args) {
     const { inputs, backend, attrs } = args;
     const { sparseIndices, sparseValues, defaultValue } = inputs;
     const { outputShape } = attrs;
@@ -39984,14 +40667,14 @@ function sparseToDense(args) {
     }
     const program = new ScatterProgram(numUpdates, sliceRank, sparseIndices.shape.length, sparseValues.shape.length, strides, [outputSize, 1], sumDupeIndices);
     const res = backend.runWebGLProgram(program, [sparseValues, sparseIndices, defaultValue], sparseValues.dtype);
-    const reshaped = reshape({ inputs: { x: res }, backend, attrs: { shape: outputShape } });
+    const reshaped = reshape$1({ inputs: { x: res }, backend, attrs: { shape: outputShape } });
     backend.disposeIntermediateTensorInfo(res);
     return reshaped;
 }
-const sparseToDenseConfig = {
+const sparseToDenseConfig$1 = {
     kernelName: SparseToDense,
     backendName: 'webgl',
-    kernelFunc: sparseToDense
+    kernelFunc: sparseToDense$1
 };
 
 /**
@@ -40010,7 +40693,7 @@ const sparseToDenseConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function splitV(args) {
+function splitV$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { numOrSizeSplits, axis } = attrs;
@@ -40027,10 +40710,10 @@ function splitV(args) {
         return sliceT;
     });
 }
-const splitVConfig = {
+const splitVConfig$1 = {
     kernelName: SplitV,
     backendName: 'webgl',
-    kernelFunc: splitV
+    kernelFunc: splitV$1
 };
 
 /**
@@ -40075,7 +40758,7 @@ const sqrtConfig = {
  */
 const SQUARE = `return x * x;`;
 const square$1 = unaryKernelFunc({ opSnippet: SQUARE });
-const squareConfig = {
+const squareConfig$1 = {
     kernelName: Square,
     backendName: 'webgl',
     kernelFunc: square$1,
@@ -40154,7 +40837,7 @@ const staticRegexReplaceConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function step({ inputs, attrs, backend }) {
+function step$1({ inputs, attrs, backend }) {
     const { x } = inputs;
     const opSnippet = CHECK_NAN_SNIPPET$1 + `
     return x > 0.0 ? 1.0 : float(${attrs.alpha});
@@ -40162,10 +40845,10 @@ function step({ inputs, attrs, backend }) {
     const program = new UnaryOpProgram(x.shape, opSnippet);
     return backend.runWebGLProgram(program, [x], x.dtype);
 }
-const stepConfig = {
+const stepConfig$1 = {
     kernelName: Step,
     backendName: 'webgl',
-    kernelFunc: step,
+    kernelFunc: step$1,
 };
 
 /**
@@ -40234,7 +40917,7 @@ class StridedSliceProgram {
  * limitations under the License.
  * =============================================================================
  */
-function stridedSlice(args) {
+function stridedSlice$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { begin, end, strides, beginMask, endMask, ellipsisMask, newAxisMask, shrinkAxisMask } = attrs;
@@ -40242,7 +40925,7 @@ function stridedSlice(args) {
     let result;
     if (isIdentity) {
         // Optimization #1, slice is a no-op plus reshape
-        result = reshape({ inputs: { x }, backend, attrs: { shape: finalShape } });
+        result = reshape$1({ inputs: { x }, backend, attrs: { shape: finalShape } });
     }
     else if (sliceDim0 || isSimpleSlice) {
         // Optimization #2, slice is memory contiguous (only occurs in dim 0)
@@ -40251,7 +40934,7 @@ function stridedSlice(args) {
         // To tolerate begin[0] > end[0] (a 0-output slice), we min(begin, end).
         const sliced = slice({ inputs: { x }, backend, attrs: { begin: $begin, size } });
         result =
-            reshape({ inputs: { x: sliced }, backend, attrs: { shape: finalShape } });
+            reshape$1({ inputs: { x: sliced }, backend, attrs: { shape: finalShape } });
         backend.disposeIntermediateTensorInfo(sliced);
     }
     else {
@@ -40269,14 +40952,14 @@ function stridedSlice(args) {
             result = backend.runWebGLProgram(program, [x], x.dtype);
         }
     }
-    const resultReshaped = reshape({ inputs: { x: result }, backend, attrs: { shape: finalShape } });
+    const resultReshaped = reshape$1({ inputs: { x: result }, backend, attrs: { shape: finalShape } });
     backend.disposeIntermediateTensorInfo(result);
     return resultReshaped;
 }
-const stridedSliceConfig = {
+const stridedSliceConfig$1 = {
     kernelName: StridedSlice,
     backendName: 'webgl',
-    kernelFunc: stridedSlice
+    kernelFunc: stridedSlice$1
 };
 
 /**
@@ -40295,7 +40978,7 @@ const stridedSliceConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function stringNGrams(args) {
+function stringNGrams$1(args) {
     const { inputs, backend, attrs } = args;
     const { separator, nGramWidths, leftPad, rightPad, padWidth, preserveShortSequences } = attrs;
     const { data, dataSplits } = inputs;
@@ -40307,10 +40990,10 @@ function stringNGrams(args) {
         backend.makeTensorInfo(dataSplits.shape, 'int32', nGramsSplits),
     ];
 }
-const stringNGramsConfig = {
+const stringNGramsConfig$1 = {
     kernelName: StringNGrams,
     backendName: 'webgl',
-    kernelFunc: stringNGrams,
+    kernelFunc: stringNGrams$1,
 };
 
 /**
@@ -40329,7 +41012,7 @@ const stringNGramsConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function stringSplit(args) {
+function stringSplit$1(args) {
     const { inputs, backend, attrs } = args;
     const { skipEmpty } = attrs;
     const { input, delimiter } = inputs;
@@ -40352,10 +41035,10 @@ function stringSplit(args) {
         backend.makeTensorInfo([2], 'int32', new Int32Array(shape))
     ];
 }
-const stringSplitConfig = {
+const stringSplitConfig$1 = {
     kernelName: StringSplit,
     backendName: 'webgl',
-    kernelFunc: stringSplit,
+    kernelFunc: stringSplit$1,
 };
 
 /**
@@ -40374,7 +41057,7 @@ const stringSplitConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function stringToHashBucketFast(args) {
+function stringToHashBucketFast$1(args) {
     const { inputs, backend, attrs } = args;
     const { numBuckets } = attrs;
     const { input } = inputs;
@@ -40388,10 +41071,10 @@ function stringToHashBucketFast(args) {
     const output = stringToHashBucketFastImplCPU($input, numBuckets);
     return backend.makeTensorInfo(input.shape, 'int32', output);
 }
-const stringToHashBucketFastConfig = {
+const stringToHashBucketFastConfig$1 = {
     kernelName: StringToHashBucketFast,
     backendName: 'webgl',
-    kernelFunc: stringToHashBucketFast,
+    kernelFunc: stringToHashBucketFast$1,
 };
 
 /**
@@ -40411,11 +41094,11 @@ const stringToHashBucketFastConfig = {
  * =============================================================================
  */
 const TAN = `return tan(x);`;
-const tan = unaryKernelFunc({ opSnippet: TAN });
-const tanConfig = {
+const tan$1 = unaryKernelFunc({ opSnippet: TAN });
+const tanConfig$1 = {
     kernelName: Tan,
     backendName: 'webgl',
-    kernelFunc: tan,
+    kernelFunc: tan$1,
 };
 
 /**
@@ -40438,11 +41121,11 @@ const TANH = `
   float e2x = exp(-2.0 * abs(x));
   return sign(x) * (1.0 - e2x) / (1.0 + e2x);
 `;
-const tanh = unaryKernelFunc({ opSnippet: TANH });
-const tanhConfig = {
+const tanh$1 = unaryKernelFunc({ opSnippet: TANH });
+const tanhConfig$1 = {
     kernelName: Tanh$1,
     backendName: 'webgl',
-    kernelFunc: tanh,
+    kernelFunc: tanh$1,
 };
 
 /**
@@ -40461,7 +41144,7 @@ const tanhConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function tensorScatterUpdate(args) {
+function tensorScatterUpdate$1(args) {
     const { inputs, backend} = args;
     const { tensor, indices, updates } = inputs;
     const { sliceRank, numUpdates, sliceSize, strides, outputSize } = calculateShapes(updates, indices, tensor.shape);
@@ -40469,22 +41152,22 @@ function tensorScatterUpdate(args) {
     if (outputSize === 0) {
         return backend.makeTensorInfo(tensor.shape, indices.dtype);
     }
-    const flattenIndices = reshape({ inputs: { x: indices }, backend, attrs: { shape: [numUpdates, sliceRank] } });
-    const flattenX = reshape({ inputs: { x: updates }, backend, attrs: { shape: [numUpdates, sliceSize] } });
-    const flattenTensor = reshape({ inputs: { x: tensor }, backend, attrs: { shape: flattenShape } });
+    const flattenIndices = reshape$1({ inputs: { x: indices }, backend, attrs: { shape: [numUpdates, sliceRank] } });
+    const flattenX = reshape$1({ inputs: { x: updates }, backend, attrs: { shape: [numUpdates, sliceSize] } });
+    const flattenTensor = reshape$1({ inputs: { x: tensor }, backend, attrs: { shape: flattenShape } });
     const program = new ScatterProgram(numUpdates, sliceRank, flattenIndices.shape.length, flattenX.shape.length, strides, flattenShape, false, true);
     const res = backend.runWebGLProgram(program, [flattenX, flattenIndices, flattenTensor], flattenTensor.dtype);
-    const reshaped = reshape({ inputs: { x: res }, backend, attrs: { shape: tensor.shape } });
+    const reshaped = reshape$1({ inputs: { x: res }, backend, attrs: { shape: tensor.shape } });
     backend.disposeIntermediateTensorInfo(flattenIndices);
     backend.disposeIntermediateTensorInfo(flattenX);
     backend.disposeIntermediateTensorInfo(flattenTensor);
     backend.disposeIntermediateTensorInfo(res);
     return reshaped;
 }
-const tensorScatterUpdateConfig = {
+const tensorScatterUpdateConfig$1 = {
     kernelName: TensorScatterUpdate,
     backendName: 'webgl',
-    kernelFunc: tensorScatterUpdate
+    kernelFunc: tensorScatterUpdate$1
 };
 
 /**
@@ -40554,7 +41237,7 @@ function getSourceCoords(aShape) {
  * limitations under the License.
  * =============================================================================
  */
-function tile$1(params) {
+function tile$2(params) {
     const { inputs, backend, attrs } = params;
     const { x } = inputs;
     const { reps } = attrs;
@@ -40574,10 +41257,10 @@ function tile$1(params) {
     const output = backend.runWebGLProgram(program, [x], x.dtype);
     return output;
 }
-const tileConfig = {
+const tileConfig$1 = {
     kernelName: Tile,
     backendName: 'webgl',
-    kernelFunc: tile$1,
+    kernelFunc: tile$2,
 };
 
 // Based on Algorithm 2 of Bitonic Top K, ref:
@@ -40735,7 +41418,7 @@ function roundUpToPow2(num) {
 }
 // Based on Algorithm 2 of Bitonic Top K, ref:
 // https://anilshanbhag.in/static/papers/gputopk_sigmod18.pdf
-function topK(args) {
+function topK$1(args) {
     const { inputs, backend, attrs } = args;
     const { x } = inputs;
     const { k, sorted } = attrs;
@@ -40766,7 +41449,7 @@ function topK(args) {
     }
     if (lastDim === 1 /* firstPass */) {
         return [
-            x, fill({ attrs: { shape: xShape, dtype: 'int32', value: 0 }, backend })
+            x, fill$1({ attrs: { shape: xShape, dtype: 'int32', value: 0 }, backend })
         ];
     }
     // Eagerly unpack x input since it is passed in to all the shaders which
@@ -40777,7 +41460,7 @@ function topK(args) {
     // Reshape into a 2d tensor [batch, lastDim] and compute topk along lastDim.
     const xSize = sizeFromShape(xShape);
     const batch = xSize / lastDim;
-    const x2D = reshape({ inputs: { x: xUnPacked }, attrs: { shape: [batch, lastDim] }, backend });
+    const x2D = reshape$1({ inputs: { x: xUnPacked }, attrs: { shape: [batch, lastDim] }, backend });
     if (xIsPacked) {
         disposeIntermediateTensorInfoOrNull(backend, xUnPacked);
     }
@@ -40830,24 +41513,24 @@ function topK(args) {
     indices = slice({ inputs: { x: indices }, backend, attrs: { begin: 0, size: [batch, k] } });
     disposeIntermediateTensorInfoOrNull(backend, prevIndices);
     // Gather values on last dimension
-    let values = gatherV2({ inputs: { x: x2D, indices }, backend, attrs: { axis: 1, batchDims: 1 } });
+    let values = gatherV2$1({ inputs: { x: x2D, indices }, backend, attrs: { axis: 1, batchDims: 1 } });
     disposeIntermediateTensorInfoOrNull(backend, x2D);
     // Reshape back to the original input shape, except that the last
     // dimension is k.
     const newShape = xShape.slice(0, -1);
     newShape.push(k);
     prevIndices = indices;
-    indices = reshape({ inputs: { x: indices }, attrs: { shape: newShape }, backend });
+    indices = reshape$1({ inputs: { x: indices }, attrs: { shape: newShape }, backend });
     disposeIntermediateTensorInfoOrNull(backend, prevIndices);
     const prevValues = values;
-    values = reshape({ inputs: { x: values }, attrs: { shape: newShape }, backend });
+    values = reshape$1({ inputs: { x: values }, attrs: { shape: newShape }, backend });
     disposeIntermediateTensorInfoOrNull(backend, prevValues);
     return [values, indices];
 }
-const topKConfig = {
+const topKConfig$1 = {
     kernelName: TopK,
     backendName: 'webgl',
-    kernelFunc: topK
+    kernelFunc: topK$1
 };
 
 /**
@@ -41021,7 +41704,7 @@ class TransformProgram {
  * limitations under the License.
  * =============================================================================
  */
-function transform(args) {
+function transform$1(args) {
     const { inputs, backend, attrs } = args;
     const { image, transforms } = inputs;
     const { interpolation, fillMode, fillValue, outputShape } = attrs;
@@ -41032,10 +41715,10 @@ function transform(args) {
     const program = new TransformProgram(imageHeight, imageWidth, interpolation, fillMode, fillValue, outShape);
     return backend.runWebGLProgram(program, [image, transforms], 'float32');
 }
-const transformConfig = {
+const transformConfig$1 = {
     kernelName: Transform,
     backendName: 'webgl',
-    kernelFunc: transform
+    kernelFunc: transform$1
 };
 
 /**
@@ -41054,11 +41737,11 @@ const transformConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function unique$1(args) {
+function unique$2(args) {
     const { inputs, attrs, backend } = args;
     const { axis } = attrs;
     const { x } = inputs;
-    assertNotComplex(x, 'unique');
+    assertNotComplex$1(x, 'unique');
     // For now, always forward calculation to the CPU backend.
     console.warn('WARNING: ', 'UI might be locked temporarily as data is being downloaded');
     const values = backend.readSync(x.dataId);
@@ -41068,10 +41751,10 @@ function unique$1(args) {
         backend.makeTensorInfo([indices.length], 'int32', indices),
     ];
 }
-const uniqueConfig = {
+const uniqueConfig$1 = {
     kernelName: Unique,
     backendName: 'webgl',
-    kernelFunc: unique$1,
+    kernelFunc: unique$2,
 };
 
 /**
@@ -41090,7 +41773,7 @@ const uniqueConfig = {
  * limitations under the License.
  * =============================================================================
  */
-function unpack(args) {
+function unpack$1(args) {
     const { inputs, backend, attrs } = args;
     const { value } = inputs;
     let { axis } = attrs;
@@ -41115,17 +41798,17 @@ function unpack(args) {
     for (let i = 0; i < res.length; i++) {
         begin[axis] = i;
         const sliced = slice({ inputs: { x }, backend, attrs: { begin, size } });
-        const reshaped = reshape({ inputs: { x: sliced }, backend, attrs: { shape: outShape } });
+        const reshaped = reshape$1({ inputs: { x: sliced }, backend, attrs: { shape: outShape } });
         res[i] = reshaped;
         toDispose.push(sliced);
     }
     toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return res;
 }
-const unpackConfig = {
+const unpackConfig$1 = {
     kernelName: Unpack,
     backendName: 'webgl',
-    kernelFunc: unpack
+    kernelFunc: unpack$1
 };
 
 /**
@@ -41292,7 +41975,7 @@ class SegmentOpProgram {
  * limitations under the License.
  * =============================================================================
  */
-function unsortedSegmentSum(args) {
+function unsortedSegmentSum$1(args) {
     const { inputs, backend, attrs } = args;
     const { x, segmentIds } = inputs;
     const { numSegments } = attrs;
@@ -41308,7 +41991,7 @@ function unsortedSegmentSum(args) {
     }
     const outShape = computeOutShape(permutedX.shape, axis, numSegments);
     const inSize = sizeFromShape([permutedX.shape[axis]]);
-    const a2D = reshape({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
+    const a2D = reshape$1({ inputs: { x: permutedX }, backend, attrs: { shape: [-1, inSize] } });
     toDispose.push(a2D);
     const outputDType = sumOutType(x.dtype);
     const segOpCompute = (x, segOpType, segmentIds, dtype, numSegments) => {
@@ -41323,11 +42006,11 @@ function unsortedSegmentSum(args) {
         if (output.shape[1] === numSegments) {
             return output;
         }
-        const rangeInfo = range$1({
+        const rangeInfo = range$2({
             backend,
             attrs: { start: 0, stop: numSegments, step: 1, dtype: 'float32' }
         });
-        const tileInfo = tile$1({
+        const tileInfo = tile$2({
             inputs: { x: rangeInfo },
             backend,
             attrs: { reps: [inSize / windowSize] }
@@ -41338,7 +42021,7 @@ function unsortedSegmentSum(args) {
         return result;
     };
     const segOpResult = segOpCompute(a2D, 'unsortedSegmentSum', segmentIds, outputDType, numSegments);
-    const reshaped = reshape({ inputs: { x: segOpResult }, backend, attrs: { shape: outShape } });
+    const reshaped = reshape$1({ inputs: { x: segOpResult }, backend, attrs: { shape: outShape } });
     let result = reshaped;
     if (permutation != null) {
         toDispose.push(reshaped);
@@ -41348,10 +42031,10 @@ function unsortedSegmentSum(args) {
     toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
     return result;
 }
-const unsortedSegmentSumConfig = {
+const unsortedSegmentSumConfig$1 = {
     kernelName: UnsortedSegmentSum,
     backendName: 'webgl',
-    kernelFunc: unsortedSegmentSum
+    kernelFunc: unsortedSegmentSum$1
 };
 
 /**
@@ -41371,12 +42054,7819 @@ const unsortedSegmentSumConfig = {
  * =============================================================================
  */
 // List all kernel configs here
+const kernelConfigs$1 = [
+    _fusedMatMulConfig$1,
+    absConfig,
+    acosConfig$1,
+    acoshConfig$1,
+    addConfig,
+    addNConfig$1,
+    allConfig$1,
+    anyConfig$1,
+    argMaxConfig$1,
+    argMinConfig$1,
+    asinConfig$1,
+    asinhConfig$1,
+    atanConfig$1,
+    atan2Config$1,
+    atanhConfig$1,
+    avgPoolConfig$1,
+    avgPool3DConfig$1,
+    avgPool3DGradConfig$2,
+    avgPoolGradConfig$2,
+    batchMatMulConfig$1,
+    batchNormConfig$1,
+    batchToSpaceNDConfig$1,
+    bincountConfig$1,
+    bitwiseAndConfig,
+    broadcastArgsConfig$1,
+    castConfig,
+    ceilConfig,
+    clipByValueConfig$1,
+    complexConfig,
+    complexAbsConfig$1,
+    concatConfig$1,
+    conv2DConfig$1,
+    conv2DBackpropFilterConfig$1,
+    conv2DBackpropInputConfig$1,
+    conv3DConfig$1,
+    conv3DBackpropFilterV2Config$1,
+    conv3DBackpropInputConfig,
+    cosConfig$1,
+    coshConfig$1,
+    cropAndResizeConfig$1,
+    cumprodConfig$1,
+    cumsumConfig$1,
+    denseBincountConfig$1,
+    depthToSpaceConfig$1,
+    depthwiseConv2dNativeConfig$1,
+    depthwiseConv2dNativeBackpropFilterConfig$1,
+    depthwiseConv2dNativeBackpropInputConfig$1,
+    diagConfig$1,
+    dilation2DConfig$1,
+    einsumConfig$1,
+    eluConfig$1,
+    eluGradConfig$2,
+    equalConfig,
+    erfConfig$1,
+    expConfig,
+    expandDimsConfig$1,
+    expm1Config,
+    fftConfig$1,
+    fillConfig$1,
+    flipLeftRightConfig$1,
+    floorConfig,
+    floorDivConfig,
+    fromPixelsConfig,
+    fusedConv2DConfig$1,
+    fusedDepthwiseConv2DConfig$1,
+    gatherNdConfig$1,
+    gatherV2Config$1,
+    greaterConfig,
+    greaterEqualConfig,
+    identityConfig,
+    ifftConfig$1,
+    imagConfig$1,
+    isFiniteConfig$1,
+    isInfConfig$1,
+    isNaNConfig$1,
+    leakyReluConfig$1,
+    lessConfig,
+    lessEqualConfig,
+    linSpaceConfig$1,
+    logConfig,
+    log1pConfig$1,
+    logicalAndConfig$1,
+    logicalNotConfig$1,
+    logicalOrConfig$1,
+    LRNConfig$1,
+    LRNGradConfig$1,
+    maxConfig$1,
+    maximumConfig,
+    maxPoolConfig$1,
+    maxPool3DConfig$1,
+    maxPool3DGradConfig$2,
+    maxPoolGradConfig$2,
+    maxPoolWithArgmaxConfig$1,
+    meanConfig$1,
+    minConfig$1,
+    minimumConfig,
+    mirrorPadConfig$1,
+    modConfig$1,
+    multinomialConfig$1,
+    multiplyConfig,
+    negConfig,
+    nonMaxSuppressionV3Config$1,
+    nonMaxSuppressionV4Config$1,
+    nonMaxSuppressionV5Config$1,
+    notEqualConfig,
+    oneHotConfig$1,
+    onesLikeConfig$1,
+    packConfig$1,
+    padV2Config$1,
+    powConfig$1,
+    preluConfig$1,
+    prodConfig,
+    raggedGatherConfig$1,
+    raggedRangeConfig$1,
+    raggedTensorToTensorConfig$1,
+    rangeConfig$1,
+    realConfig,
+    realDivConfig$1,
+    reciprocalConfig$1,
+    reluConfig$1,
+    relu6Config$1,
+    reshapeConfig$1,
+    resizeBilinearConfig$1,
+    resizeBilinearGradConfig$2,
+    resizeNearestNeighborConfig$1,
+    resizeNearestNeighborGradConfig$2,
+    reverseConfig$1,
+    rotateWithOffsetConfig$1,
+    roundConfig$1,
+    rsqrtConfig,
+    scatterNdConfig$1,
+    searchSortedConfig$1,
+    selectConfig$1,
+    seluConfig$1,
+    sigmoidConfig,
+    signConfig$1,
+    sinConfig$1,
+    sinhConfig$1,
+    sliceConfig,
+    softmaxConfig$1,
+    softplusConfig$1,
+    spaceToBatchNDConfig$1,
+    sparseFillEmptyRowsConfig$1,
+    sparseReshapeConfig$1,
+    sparseSegmentMeanConfig$1,
+    sparseSegmentSumConfig$1,
+    sparseToDenseConfig$1,
+    splitVConfig$1,
+    sqrtConfig,
+    squareConfig$1,
+    squaredDifferenceConfig,
+    staticRegexReplaceConfig,
+    stepConfig$1,
+    stridedSliceConfig$1,
+    stringNGramsConfig$1,
+    stringSplitConfig$1,
+    stringToHashBucketFastConfig$1,
+    subConfig,
+    sumConfig$1,
+    tanConfig$1,
+    tanhConfig$1,
+    tensorScatterUpdateConfig$1,
+    tileConfig$1,
+    topKConfig$1,
+    transformConfig$1,
+    transposeConfig,
+    uniqueConfig$1,
+    unpackConfig$1,
+    unsortedSegmentSumConfig$1,
+    zerosLikeConfig$1
+];
+for (const kernelConfig of kernelConfigs$1) {
+    registerKernel(kernelConfig);
+}
+
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const whereImpl = whereImpl$2;
+class MathBackendCPU extends KernelBackend {
+    nextDataId() {
+        return MathBackendCPU.nextDataId++;
+    }
+    constructor() {
+        super();
+        this.blockSize = 48;
+        this.firstUse = true;
+        this.data = new DataStorage(this, engine());
+    }
+    write(values, shape, dtype) {
+        if (this.firstUse) {
+            this.firstUse = false;
+            if (env().get('IS_NODE')) {
+                warn('\n============================\n' +
+                    'Hi, looks like you are running TensorFlow.js in ' +
+                    'Node.js. To speed things up dramatically, install our node ' +
+                    'backend, visit https://github.com/tensorflow/tfjs-node for more details. ' +
+                    '\n============================');
+            }
+        }
+        const dataId = { id: this.nextDataId() };
+        this.data.set(dataId, { values, dtype, refCount: 1 });
+        return dataId;
+    }
+    /**
+     * Create a data bucket in cpu backend.
+     * @param shape Shape of the `TensorInfo`.
+     * @param dtype DType of the `TensorInfo`.
+     * @param values The value of the `TensorInfo` stored as a flattened array.
+     */
+    makeTensorInfo(shape, dtype, values) {
+        let outId;
+        if (dtype === 'string' && values != null && values.length > 0 &&
+            isString(values[0])) {
+            const encodedValues = values.map(d => encodeString(d));
+            outId = this.write(encodedValues, shape, dtype);
+        }
+        else {
+            outId = this.write(values, shape, dtype);
+        }
+        return { dataId: outId, shape, dtype };
+    }
+    /** Return refCount of a `TensorData`. */
+    refCount(dataId) {
+        if (this.data.has(dataId)) {
+            const tensorData = this.data.get(dataId);
+            return tensorData.refCount;
+        }
+        return 0;
+    }
+    /** Increase refCount of a `TensorData`. */
+    incRef(dataId) {
+        const tensorData = this.data.get(dataId);
+        tensorData.refCount++;
+    }
+    /** Decrease refCount of a `TensorData`. */
+    decRef(dataId) {
+        if (this.data.has(dataId)) {
+            const tensorData = this.data.get(dataId);
+            tensorData.refCount--;
+        }
+    }
+    move(dataId, values, shape, dtype, refCount) {
+        this.data.set(dataId, { values, dtype, refCount });
+    }
+    numDataIds() {
+        return this.data.numDataIds();
+    }
+    async read(dataId) {
+        return this.readSync(dataId);
+    }
+    readSync(dataId) {
+        const { dtype, complexTensorInfos } = this.data.get(dataId);
+        if (dtype === 'complex64') {
+            const realValues = this.readSync(complexTensorInfos.real.dataId);
+            const imagValues = this.readSync(complexTensorInfos.imag.dataId);
+            return mergeRealAndImagArrays(realValues, imagValues);
+        }
+        return convertBackendValuesAndArrayBuffer(this.data.get(dataId).values, dtype);
+    }
+    bufferSync(t) {
+        const data = this.readSync(t.dataId);
+        if (t.dtype === 'string') {
+            try {
+                // Decode the bytes into string.
+                const strings = data.map(d => decodeString(d));
+                return buffer(t.shape, t.dtype, strings);
+            }
+            catch (_a) {
+                throw new Error('Failed to decode encoded string bytes into utf-8');
+            }
+        }
+        return buffer(t.shape, t.dtype, data);
+    }
+    makeOutput(values, shape, dtype) {
+        return engine().makeTensorFromTensorInfo(this.makeTensorInfo(shape, dtype, values), this);
+    }
+    /**
+     * Dispose the memory if the dataId has 0 refCount. Return true if the memory
+     * is released or memory is not managed in this backend, false if memory is
+     * not cleared.
+     * @param dataId
+     * @oaram force Optional, remove the data regardless of refCount
+     */
+    disposeData(dataId, force = false) {
+        if (this.data.has(dataId)) {
+            this.data.get(dataId).refCount--;
+            if (!force && this.data.get(dataId).refCount > 0) {
+                return false;
+            }
+            const { complexTensorInfos } = this.data.get(dataId);
+            if (complexTensorInfos != null) {
+                this.disposeData(complexTensorInfos.real.dataId, true);
+                this.disposeData(complexTensorInfos.imag.dataId, true);
+            }
+            this.data.delete(dataId);
+        }
+        return true;
+    }
+    disposeIntermediateTensorInfo(tensorInfo) {
+        this.disposeData(tensorInfo.dataId);
+    }
+    async time(f) {
+        const start = now();
+        f();
+        const kernelMs = now() - start;
+        return { kernelMs };
+    }
+    memory() {
+        return {
+            // Unreliable due to automatic gc. The numbers above are cumulative.
+            unreliable: true,
+            reasons: ['The reported memory is an upper bound. Due to automatic garbage ' +
+                    'collection, the true allocated memory may be less.']
+        };
+    }
+    where(condition) {
+        assertNotComplex([condition], 'where');
+        const condVals = this.readSync(condition.dataId);
+        return whereImpl(condition.shape, condVals);
+    }
+    dispose() { }
+    floatPrecision() {
+        return 32;
+    }
+    /** Returns the smallest representable number.  */
+    epsilon() {
+        return super.epsilon();
+    }
+}
+MathBackendCPU.nextDataId = 0;
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/*
+ * base.ts contains all the exports from tfjs-backend-cpu
+ * without auto-kernel registration
+ */
+// Side effects for default initialization of MathBackendCPU
+registerBackend('cpu', () => new MathBackendCPU(), 1 /* priority */);
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const elu$1 = unaryKernelFunc$1(Elu$1, (xi) => xi >= 0 ? xi : (Math.exp(xi) - 1));
+const eluConfig = {
+    kernelName: Elu$1,
+    backendName: 'cpu',
+    kernelFunc: elu$1,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function leakyRelu(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { alpha } = attrs;
+    assertNotComplex([x], 'leakyRelu');
+    const xSize = sizeFromShape(x.shape);
+    const xVals = backend.data.get(x.dataId).values;
+    const outVals = getTypedArrayFromDType('float32', xSize);
+    for (let i = 0; i < xVals.length; i++) {
+        outVals[i] = xVals[i] < 0 ? alpha * xVals[i] : xVals[i];
+    }
+    return backend.makeTensorInfo(x.shape, 'float32', outVals);
+}
+const leakyReluConfig = {
+    kernelName: LeakyRelu,
+    backendName: 'cpu',
+    kernelFunc: leakyRelu
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const preluImpl = createSimpleBinaryKernelImpl((xValue, aValue) => xValue < 0 ? aValue * xValue : xValue);
+function prelu(args) {
+    const { inputs, backend } = args;
+    const { x, alpha } = inputs;
+    assertNotComplex([x, alpha], 'prelu');
+    const aVals = backend.data.get(x.dataId).values;
+    const bVals = backend.data.get(alpha.dataId).values;
+    const [resultData, resultShape] = preluImpl(x.shape, alpha.shape, aVals, bVals, 'float32');
+    return backend.makeTensorInfo(resultShape, 'float32', resultData);
+}
+const preluConfig = {
+    kernelName: Prelu,
+    backendName: 'cpu',
+    kernelFunc: prelu,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const relu = unaryKernelFunc$1(Relu$1, (xi) => Math.max(0, xi));
+const reluConfig = {
+    kernelName: Relu$1,
+    backendName: 'cpu',
+    kernelFunc: relu,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const relu6 = unaryKernelFunc$1(Relu6$1, (xi) => Math.min(Math.max(0, xi), 6));
+const relu6Config = {
+    kernelName: Relu6$1,
+    backendName: 'cpu',
+    kernelFunc: relu6,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function applyActivation(backend, x, activation, preluActivationWeights, leakyreluAlpha) {
+    if (activation === 'linear') {
+        return identity$1({ inputs: { x }, backend });
+    }
+    else if (activation === 'relu') {
+        return relu({ inputs: { x }, backend });
+    }
+    else if (activation === 'elu') {
+        return elu$1({ inputs: { x }, backend });
+    }
+    else if (activation === 'relu6') {
+        return relu6({ inputs: { x }, backend });
+    }
+    else if (activation === 'prelu') {
+        return prelu({ inputs: { x, alpha: preluActivationWeights }, backend });
+    }
+    else if (activation === 'leakyrelu') {
+        return leakyRelu({ inputs: { x }, backend, attrs: { alpha: leakyreluAlpha } });
+    }
+    else if (activation === 'sigmoid') {
+        return sigmoid$1({ inputs: { x }, backend });
+    }
+    throw new Error(`Activation ${activation} has not been implemented for the CPU backend.`);
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function reshape(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { shape } = attrs;
+    const xSize = sizeFromShape(x.shape);
+    const $shape = inferFromImplicitShape(shape, xSize);
+    const $xSize = sizeFromShape($shape);
+    assert$1(xSize === $xSize, () => `The new shape (${$shape}) has ${$xSize} elements and the old ` +
+        `shape (${x.shape}) has ${xSize} elements. The new shape and old ` +
+        `shape must have the same number of elements.`);
+    backend.incRef(x.dataId);
+    const xData = backend.data.get(x.dataId);
+    if (xData.complexTensorInfos != null) {
+        const real = xData.complexTensorInfos.real;
+        const imag = xData.complexTensorInfos.imag;
+        real.shape = $shape;
+        imag.shape = $shape;
+    }
+    return { dataId: x.dataId, shape: $shape, dtype: x.dtype };
+}
+const reshapeConfig = {
+    kernelName: Reshape$1,
+    backendName: 'cpu',
+    kernelFunc: reshape
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function batchMatMul(args) {
+    const { inputs, backend, attrs } = args;
+    const { a, b } = inputs;
+    const { transposeA, transposeB } = attrs;
+    assertNotComplex([a, b], 'matMul');
+    const aRank = a.shape.length;
+    const bRank = b.shape.length;
+    const innerShapeA = transposeA ? a.shape[aRank - 2] : a.shape[aRank - 1];
+    const innerShapeB = transposeB ? b.shape[bRank - 1] : b.shape[bRank - 2];
+    const outerShapeA = transposeA ? a.shape[aRank - 1] : a.shape[aRank - 2];
+    const outerShapeB = transposeB ? b.shape[bRank - 2] : b.shape[bRank - 1];
+    const outerDimsA = a.shape.slice(0, -2);
+    const outerDimsB = b.shape.slice(0, -2);
+    const batchDimA = sizeFromShape(outerDimsA);
+    const batchDimB = sizeFromShape(outerDimsB);
+    const outShapeOuterDims = assertAndGetBroadcastShape(a.shape.slice(0, -2), b.shape.slice(0, -2));
+    const outShape = outShapeOuterDims.concat([outerShapeA, outerShapeB]);
+    assert$1(innerShapeA === innerShapeB, () => `Error in matMul: inner shapes (${innerShapeA}) and (` +
+        `${innerShapeB}) of Tensors with shapes ${a.shape} and ` +
+        `${b.shape} and transposeA=${transposeA}` +
+        ` and transposeB=${transposeB} must match.`);
+    const a3dShape = transposeA ? [batchDimA, innerShapeA, outerShapeA] :
+        [batchDimA, outerShapeA, innerShapeA];
+    const b3dShape = transposeB ? [batchDimB, outerShapeB, innerShapeB] :
+        [batchDimB, innerShapeB, outerShapeB];
+    // The rest of the implementation is designed to operate on rank-3 tensors
+    const a3d = reshape({ inputs: { x: a }, backend, attrs: { shape: a3dShape } });
+    const b3d = reshape({ inputs: { x: b }, backend, attrs: { shape: b3dShape } });
+    const sharedDim = transposeA ? a3d.shape[1] : a3d.shape[2];
+    const leftDim = transposeA ? a3d.shape[2] : a3d.shape[1];
+    const rightDim = transposeB ? b3d.shape[1] : b3d.shape[2];
+    const batchDim = Math.max(batchDimA, batchDimB);
+    const a3dValues = backend.data.get(a3d.dataId).values;
+    const b3dValues = backend.data.get(b3d.dataId).values;
+    const a3dStrides = computeStrides(a3d.shape);
+    const b3dStrides = computeStrides(b3d.shape);
+    const [aBatch, aOuterStep, aInnerStep] = transposeA ?
+        [a3dStrides[0], 1, a3dStrides[1]] :
+        [a3dStrides[0], a3dStrides[1], 1];
+    const [bInnerStep, bOuterStep, bBatch] = transposeB ?
+        [1, b3dStrides[1], b3dStrides[0]] :
+        [b3dStrides[1], 1, b3dStrides[0]];
+    const size = leftDim * rightDim;
+    const result = buffer([batchDim, leftDim, rightDim], a3d.dtype);
+    const resVals = result.values;
+    const blockSize = backend.blockSize;
+    for (let bi = 0; bi < batchDim; bi++) {
+        const batchIndexA = bi % batchDimA;
+        const batchIndexB = bi % batchDimB;
+        for (let i0 = 0; i0 < leftDim; i0 += blockSize) {
+            // for when blockSize doesn't evenly divide the input
+            const iBlock = Math.min(i0 + blockSize, leftDim);
+            for (let j0 = 0; j0 < rightDim; j0 += blockSize) {
+                const jBlock = Math.min(j0 + blockSize, rightDim);
+                for (let k0 = 0; k0 < sharedDim; k0 += blockSize) {
+                    const kBlock = Math.min(k0 + blockSize, sharedDim);
+                    for (let i = i0; i < iBlock; i++) {
+                        for (let j = j0; j < jBlock; j++) {
+                            let sum = 0.0;
+                            for (let k = k0; k < kBlock; k++) {
+                                const aVal = 
+                                // tslint:disable-next-line: max-line-length
+                                a3dValues[batchIndexA * aBatch + i * aOuterStep + k * aInnerStep];
+                                const bVal = 
+                                // tslint:disable-next-line: max-line-length
+                                b3dValues[k * bInnerStep + j * bOuterStep + batchIndexB * bBatch];
+                                sum += aVal * bVal;
+                            }
+                            resVals[bi * size + (i * rightDim + j)] += sum;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    backend.disposeIntermediateTensorInfo(a3d);
+    backend.disposeIntermediateTensorInfo(b3d);
+    // set correct shape on output.
+    return backend.makeTensorInfo(outShape, result.dtype, result.values);
+}
+const batchMatMulConfig = {
+    kernelName: BatchMatMul,
+    backendName: 'cpu',
+    kernelFunc: batchMatMul,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function _fusedMatMul(args) {
+    const { inputs, backend, attrs } = args;
+    const { a, b, bias, preluActivationWeights } = inputs;
+    const { transposeA, transposeB, activation, leakyreluAlpha } = attrs;
+    let current;
+    let addRes;
+    let activationRes;
+    const intermediates = [];
+    const matMulRes = batchMatMul({ inputs: { a, b }, attrs: { transposeA, transposeB }, backend });
+    current = matMulRes;
+    if (bias) {
+        addRes = add({ inputs: { a: current, b: bias }, backend });
+        intermediates.push(current);
+        current = addRes;
+    }
+    if (activation) {
+        activationRes = applyActivation(backend, current, activation, preluActivationWeights, leakyreluAlpha);
+        intermediates.push(current);
+        current = activationRes;
+    }
+    for (const i of intermediates) {
+        backend.disposeIntermediateTensorInfo(i);
+    }
+    return current;
+}
+const _fusedMatMulConfig = {
+    kernelName: _FusedMatMul,
+    backendName: 'cpu',
+    kernelFunc: _fusedMatMul,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const acos = unaryKernelFunc$1(Acos, (xi) => Math.acos(xi));
+const acosConfig = {
+    kernelName: Acos,
+    backendName: 'cpu',
+    kernelFunc: acos,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const acosh = unaryKernelFunc$1(Acosh, (xi) => Math.acosh(xi));
+const acoshConfig = {
+    kernelName: Acosh,
+    backendName: 'cpu',
+    kernelFunc: acosh,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function addN(args) {
+    const { inputs, backend } = args;
+    const tensors = inputs;
+    assertNotComplex(inputs, 'addN');
+    const vals = tensors.map(t => backend.data.get(t.dataId).values);
+    const outBuf = buffer(tensors[0].shape, tensors[0].dtype);
+    const outVals = outBuf.values;
+    for (let i = 0; i < tensors.length; i++) {
+        const currVals = vals[i];
+        for (let j = 0; j < outVals.length; j++) {
+            outVals[j] += currVals[j];
+        }
+    }
+    return backend.makeTensorInfo(outBuf.shape, outBuf.dtype, outBuf.values);
+}
+const addNConfig = {
+    kernelName: AddN,
+    backendName: 'cpu',
+    kernelFunc: addN
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function all(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, keepDims } = attrs;
+    assertNotComplex(x, 'all');
+    const origAxes = parseAxisParam(axis, x.shape);
+    let axes = origAxes;
+    const permutedAxes = getAxesPermutation(axes, x.shape.length);
+    let $x = x;
+    if (permutedAxes != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutedAxes } });
+        axes = getInnerMostAxes(axes.length, x.shape.length);
+    }
+    assertAxesAreInnerMostDims('all', axes, $x.shape.length);
+    const [outShape, reduceShape] = computeOutAndReduceShapes($x.shape, axes);
+    const reduceSize = sizeFromShape(reduceShape);
+    const vals = makeZerosTypedArray(sizeFromShape(outShape), $x.dtype);
+    const aVals = backend.data.get($x.dataId).values;
+    for (let i = 0; i < vals.length; ++i) {
+        const offset = i * reduceSize;
+        let all = aVals[offset];
+        for (let j = 0; j < reduceSize; ++j) {
+            const value = aVals[offset + j];
+            all = all && value;
+        }
+        vals[i] = all;
+    }
+    if (permutedAxes != null) {
+        backend.disposeIntermediateTensorInfo($x);
+    }
+    const result = backend.makeTensorInfo(outShape, $x.dtype, vals);
+    if (keepDims) {
+        const expandedShape = expandShapeToKeepDim(outShape, origAxes);
+        const reshapedResult = reshape({ inputs: { x: result }, backend, attrs: { shape: expandedShape } });
+        backend.disposeIntermediateTensorInfo(result);
+        return reshapedResult;
+    }
+    return result;
+}
+const allConfig = {
+    kernelName: All,
+    backendName: 'cpu',
+    kernelFunc: all
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function any(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, keepDims } = attrs;
+    assertNotComplex(x, 'any');
+    const origAxes = parseAxisParam(axis, x.shape);
+    let axes = origAxes;
+    const permutedAxes = getAxesPermutation(axes, x.shape.length);
+    let $x = x;
+    if (permutedAxes != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutedAxes } });
+        axes = getInnerMostAxes(axes.length, x.shape.length);
+    }
+    assertAxesAreInnerMostDims('any', axes, $x.shape.length);
+    const [outShape, reduceShape] = computeOutAndReduceShapes($x.shape, axes);
+    const reduceSize = sizeFromShape(reduceShape);
+    const vals = makeZerosTypedArray(sizeFromShape(outShape), $x.dtype);
+    const aVals = backend.data.get($x.dataId).values;
+    for (let i = 0; i < vals.length; ++i) {
+        const offset = i * reduceSize;
+        let anyVal = aVals[offset];
+        for (let j = 0; j < reduceSize; ++j) {
+            const value = aVals[offset + j];
+            anyVal = anyVal || value;
+        }
+        vals[i] = anyVal;
+    }
+    if (permutedAxes != null) {
+        backend.disposeIntermediateTensorInfo($x);
+    }
+    const result = backend.makeTensorInfo(outShape, $x.dtype, vals);
+    if (keepDims) {
+        const expandedShape = expandShapeToKeepDim(outShape, origAxes);
+        const reshapedResult = reshape({ inputs: { x: result }, backend, attrs: { shape: expandedShape } });
+        backend.disposeIntermediateTensorInfo(result);
+        return reshapedResult;
+    }
+    return result;
+}
+const anyConfig = {
+    kernelName: Any,
+    backendName: 'cpu',
+    kernelFunc: any
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function argMax(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis } = attrs;
+    assertNotComplex(x, 'argMax');
+    let axes = parseAxisParam(axis, x.shape);
+    const permutedAxes = getAxesPermutation(axes, x.shape.length);
+    let $x = x;
+    const intermediateTensorInfos = [];
+    if (permutedAxes != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutedAxes } });
+        intermediateTensorInfos.push($x);
+        axes = getInnerMostAxes(axes.length, $x.shape.length);
+    }
+    axes = [axes[0]];
+    assertAxesAreInnerMostDims('argMax', axes, $x.shape.length);
+    const [outShape, reduceShape] = computeOutAndReduceShapes($x.shape, axes);
+    const outSize = sizeFromShape(outShape);
+    const vals = makeZerosTypedArray(outSize, 'int32');
+    const reduceSize = sizeFromShape(reduceShape);
+    const aVals = backend.data.get($x.dataId).values;
+    for (let i = 0; i < vals.length; ++i) {
+        const offset = i * reduceSize;
+        let max = aVals[offset];
+        let maxIndex = 0;
+        for (let j = 0; j < reduceSize; ++j) {
+            const value = aVals[offset + j];
+            if (value > max) {
+                max = value;
+                maxIndex = j;
+            }
+        }
+        vals[i] = maxIndex;
+    }
+    intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return backend.makeTensorInfo(outShape, 'int32', vals);
+}
+const argMaxConfig = {
+    kernelName: ArgMax,
+    backendName: 'cpu',
+    kernelFunc: argMax
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function argMin(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis } = attrs;
+    assertNotComplex(x, 'argMin');
+    let axes = parseAxisParam(axis, x.shape);
+    const permutedAxes = getAxesPermutation(axes, x.shape.length);
+    let $x = x;
+    const intermediateTensorInfos = [];
+    if (permutedAxes != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutedAxes } });
+        intermediateTensorInfos.push($x);
+        axes = getInnerMostAxes(axes.length, $x.shape.length);
+    }
+    axes = [axes[0]];
+    assertAxesAreInnerMostDims('argMin', axes, $x.shape.length);
+    const [outShape, reduceShape] = computeOutAndReduceShapes($x.shape, axes);
+    const outSize = sizeFromShape(outShape);
+    const vals = makeZerosTypedArray(outSize, 'int32');
+    const reduceSize = sizeFromShape(reduceShape);
+    const aVals = backend.data.get($x.dataId).values;
+    for (let i = 0; i < vals.length; ++i) {
+        const offset = i * reduceSize;
+        let min = aVals[offset];
+        let minIndex = 0;
+        for (let j = 0; j < reduceSize; ++j) {
+            const value = aVals[offset + j];
+            if (value < min) {
+                min = value;
+                minIndex = j;
+            }
+        }
+        vals[i] = minIndex;
+    }
+    intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return backend.makeTensorInfo(outShape, 'int32', vals);
+}
+const argMinConfig = {
+    kernelName: ArgMin,
+    backendName: 'cpu',
+    kernelFunc: argMin
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const asin = unaryKernelFunc$1(Asin, (xi) => Math.asin(xi));
+const asinConfig = {
+    kernelName: Asin,
+    backendName: 'cpu',
+    kernelFunc: asin,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const asinh = unaryKernelFunc$1(Asinh, (xi) => Math.asinh(xi));
+const asinhConfig = {
+    kernelName: Asinh,
+    backendName: 'cpu',
+    kernelFunc: asinh,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const atan = unaryKernelFunc$1(Atan, (xi) => Math.atan(xi));
+const atanConfig = {
+    kernelName: Atan,
+    backendName: 'cpu',
+    kernelFunc: atan,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const atan2Impl = createSimpleBinaryKernelImpl((aValue, bValue) => Math.atan2(aValue, bValue));
+const atan2 = binaryKernelFunc$1(Atan2, atan2Impl);
+const atan2Config = {
+    kernelName: Atan2,
+    backendName: 'cpu',
+    kernelFunc: atan2,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const atanh = unaryKernelFunc$1(Atanh, (xi) => Math.atanh(xi));
+const atanhConfig = {
+    kernelName: Atanh,
+    backendName: 'cpu',
+    kernelFunc: atanh,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function pool(xValues, xShape, dtype, strides, convInfo, poolType) {
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padTop = convInfo.padInfo.top;
+    const padLeft = convInfo.padInfo.left;
+    const initialValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY :
+        Number.POSITIVE_INFINITY);
+    const output = buffer(convInfo.outShape, dtype);
+    const outputVals = output.values;
+    const outputBatchStrides = convInfo.outShape[1] * convInfo.outShape[2] * convInfo.outShape[3];
+    const outputRowStrides = convInfo.outShape[2] * convInfo.outShape[3];
+    const outputColStrides = convInfo.outShape[3];
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        const outputBatchOffset = b * outputBatchStrides;
+        const inputBatchOffset = b * strides[0];
+        for (let d = 0; d < convInfo.inChannels; ++d) {
+            for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+                const xRCorner = yR * strideHeight - padTop;
+                const xRMin = Math.max(0, xRCorner);
+                const xRMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRCorner);
+                const outputRowOffset = outputBatchOffset + yR * outputRowStrides;
+                for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+                    const xCCorner = yC * strideWidth - padLeft;
+                    const xCMin = Math.max(0, xCCorner);
+                    const xCMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xCCorner);
+                    let minMaxValue = initialValue;
+                    let avgValue = 0;
+                    let count = 0;
+                    for (let xR = xRMin; xR < xRMax; xR += dilationHeight) {
+                        const xROffset = inputBatchOffset + xR * strides[1];
+                        for (let xC = xCMin; xC < xCMax; xC += dilationWidth) {
+                            const xCOffset = xROffset + xC * strides[2];
+                            const pixel = xValues[xCOffset + d];
+                            if ((poolType === 'max' && pixel > minMaxValue)) {
+                                minMaxValue = pixel;
+                            }
+                            else if (poolType === 'avg') {
+                                avgValue += pixel;
+                                count++;
+                            }
+                        }
+                        if (isNaN(minMaxValue)) {
+                            break;
+                        }
+                    }
+                    const outputOffset = outputRowOffset + yC * outputColStrides + d;
+                    outputVals[outputOffset] =
+                        poolType === 'avg' ? avgValue / count : minMaxValue;
+                }
+            }
+        }
+    }
+    return output;
+}
+function maxPoolPositions(xValues, xShape, dtype, convInfo, flattenPositions = false, includeBatchInIndex = false) {
+    const maxPositions = buffer(convInfo.outShape, 'int32');
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padTop = convInfo.padInfo.top;
+    const padLeft = convInfo.padInfo.left;
+    const xBuf = buffer(xShape, dtype, xValues);
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        for (let d = 0; d < convInfo.inChannels; ++d) {
+            for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+                const xRCorner = yR * strideHeight - padTop;
+                let xRMin = xRCorner;
+                while (xRMin < 0) {
+                    xRMin += dilationHeight;
+                }
+                // const xRMin = Math.max(0, xRCorner);
+                const xRMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRCorner);
+                for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+                    const xCCorner = yC * strideWidth - padLeft;
+                    let xCMin = xCCorner;
+                    while (xCMin < 0) {
+                        xCMin += dilationWidth;
+                    }
+                    const xCMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xCCorner);
+                    let maxValue = Number.NEGATIVE_INFINITY;
+                    let maxPosition = -1;
+                    for (let xR = xRMin; xR < xRMax; xR += dilationHeight) {
+                        const wR = xR - xRCorner;
+                        for (let xC = xCMin; xC < xCMax; xC += dilationWidth) {
+                            const wC = xC - xCCorner;
+                            // For some reason, disable-next-line is not working
+                            // TODO(mattsoulanille): Remove this when switching to TS5.
+                            /* tslint:disable: no-unnecessary-type-assertion */
+                            const pixel = xBuf.get(b, xR, xC, d);
+                            if (pixel > maxValue) {
+                                maxValue = pixel;
+                                if (flattenPositions) {
+                                    maxPosition = includeBatchInIndex ?
+                                        ((b * convInfo.inHeight + xR) * convInfo.inWidth + xC) *
+                                            convInfo.inChannels +
+                                            d :
+                                        (xR * convInfo.inWidth + xC) * convInfo.inChannels + d;
+                                }
+                                else {
+                                    maxPosition = wR * effectiveFilterWidth + wC;
+                                }
+                            }
+                        }
+                    }
+                    maxPositions.set(maxPosition, b, yR, yC, d);
+                }
+            }
+        }
+    }
+    return maxPositions;
+}
+function pool3d(xValues, xShape, dtype, strides, convInfo, poolType) {
+    const strideDepth = convInfo.strideDepth;
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const dilationDepth = convInfo.dilationDepth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterDepth = convInfo.effectiveFilterDepth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padFront = convInfo.padInfo.front;
+    const padTop = convInfo.padInfo.top;
+    const padLeft = convInfo.padInfo.left;
+    const initialValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY :
+        Number.POSITIVE_INFINITY);
+    const output = buffer(convInfo.outShape, dtype);
+    const outputVals = output.values;
+    const outputBatchStrides = convInfo.outShape[1] * convInfo.outShape[2] *
+        convInfo.outShape[3] * convInfo.outShape[4];
+    const outputDepthStrides = convInfo.outShape[2] * convInfo.outShape[3] * convInfo.outShape[4];
+    const outputRowStrides = convInfo.outShape[3] * convInfo.outShape[4];
+    const outputColStrides = convInfo.outShape[4];
+    for (let batch = 0; batch < convInfo.batchSize; ++batch) {
+        const outputBatchOffset = batch * outputBatchStrides;
+        const inputBatchOffset = batch * strides[0];
+        for (let channel = 0; channel < convInfo.inChannels; ++channel) {
+            for (let yDepth = 0; yDepth < convInfo.outDepth; ++yDepth) {
+                const xDepthCorner = yDepth * strideDepth - padFront;
+                let xDepthMin = xDepthCorner;
+                while (xDepthMin < 0) {
+                    xDepthMin += dilationDepth;
+                }
+                const xDepthMax = Math.min(convInfo.inDepth, effectiveFilterDepth + xDepthCorner);
+                const outputDepthOffset = outputBatchOffset + yDepth * outputDepthStrides;
+                for (let yRow = 0; yRow < convInfo.outHeight; ++yRow) {
+                    const xRowCorner = yRow * strideHeight - padTop;
+                    let xRowMin = xRowCorner;
+                    while (xRowMin < 0) {
+                        xRowMin += dilationHeight;
+                    }
+                    const xRowMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRowCorner);
+                    const outputRowOffset = outputDepthOffset + yRow * outputRowStrides;
+                    for (let yCol = 0; yCol < convInfo.outWidth; ++yCol) {
+                        const xColCorner = yCol * strideWidth - padLeft;
+                        let xColMin = xColCorner;
+                        while (xColMin < 0) {
+                            xColMin += dilationWidth;
+                        }
+                        const xColMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xColCorner);
+                        // Shader code begins
+                        const outputColOffset = outputRowOffset + yCol * outputColStrides;
+                        let minMaxValue = initialValue;
+                        let avgValue = 0;
+                        let count = 0;
+                        for (let xDepth = xDepthMin; xDepth < xDepthMax; xDepth += dilationDepth) {
+                            const xDepthOffset = inputBatchOffset + xDepth * strides[1];
+                            for (let xRow = xRowMin; xRow < xRowMax; xRow += dilationHeight) {
+                                const xRowOffset = xDepthOffset + xRow * strides[2];
+                                for (let xCol = xColMin; xCol < xColMax; xCol += dilationWidth) {
+                                    const xColOffset = xRowOffset + xCol * strides[3];
+                                    const pixel = xValues[xColOffset + channel];
+                                    if ((poolType === 'max' && pixel > minMaxValue)) {
+                                        minMaxValue = pixel;
+                                    }
+                                    else if (poolType === 'avg') {
+                                        avgValue += pixel;
+                                        count++;
+                                    }
+                                    if (isNaN(minMaxValue)) {
+                                        break;
+                                    }
+                                }
+                                if (isNaN(minMaxValue)) {
+                                    break;
+                                }
+                            }
+                            if (isNaN(minMaxValue)) {
+                                break;
+                            }
+                        }
+                        const outputOffset = outputColOffset + channel;
+                        outputVals[outputOffset] = poolType === 'avg' ?
+                            avgValue / Math.max(count, 1) :
+                            minMaxValue;
+                    }
+                }
+            }
+        }
+    }
+    return output;
+}
+function maxPool3dPositions(xBuf, convInfo) {
+    const maxPositions = buffer(convInfo.outShape, 'int32');
+    const strideDepth = convInfo.strideDepth;
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const dilationDepth = convInfo.dilationDepth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterDepth = convInfo.effectiveFilterDepth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padFront = convInfo.padInfo.front;
+    const padTop = convInfo.padInfo.top;
+    const padLeft = convInfo.padInfo.left;
+    for (let batch = 0; batch < convInfo.batchSize; ++batch) {
+        for (let channel = 0; channel < convInfo.inChannels; ++channel) {
+            for (let yDepth = 0; yDepth < convInfo.outDepth; ++yDepth) {
+                const xDepthCorner = yDepth * strideDepth - padFront;
+                let xDepthMin = xDepthCorner;
+                while (xDepthMin < 0) {
+                    xDepthMin += dilationDepth;
+                }
+                const xDepthMax = Math.min(convInfo.inDepth, effectiveFilterDepth + xDepthCorner);
+                for (let yRow = 0; yRow < convInfo.outHeight; ++yRow) {
+                    const xRowCorner = yRow * strideHeight - padTop;
+                    let xRowMin = xRowCorner;
+                    while (xRowMin < 0) {
+                        xRowMin += dilationHeight;
+                    }
+                    const xRowMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRowCorner);
+                    for (let yCol = 0; yCol < convInfo.outWidth; ++yCol) {
+                        const xColCorner = yCol * strideWidth - padLeft;
+                        let xColMin = xColCorner;
+                        while (xColMin < 0) {
+                            xColMin += dilationWidth;
+                        }
+                        const xColMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xColCorner);
+                        // Shader code begins
+                        let maxValue = Number.NEGATIVE_INFINITY;
+                        let maxPosition = -1;
+                        for (let xDepth = xDepthMin; xDepth < xDepthMax; xDepth += dilationDepth) {
+                            const wDepth = xDepth - xDepthCorner;
+                            for (let xRow = xRowMin; xRow < xRowMax; xRow += dilationHeight) {
+                                const wRow = xRow - xRowCorner;
+                                for (let xCol = xColMin; xCol < xColMax; xCol += dilationWidth) {
+                                    const wCol = xCol - xColCorner;
+                                    const pixel = xBuf.get(batch, xDepth, xRow, xCol, channel);
+                                    if (pixel >= maxValue) {
+                                        maxValue = pixel;
+                                        maxPosition =
+                                            wDepth * effectiveFilterHeight * effectiveFilterWidth +
+                                                wRow * effectiveFilterHeight + wCol;
+                                    }
+                                }
+                            }
+                        }
+                        maxPositions.set(maxPosition, batch, yDepth, yRow, yCol, channel);
+                    }
+                }
+            }
+        }
+    }
+    return maxPositions;
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function avgPool(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    assertNotComplex(x, 'avgPool');
+    const { filterSize, strides, pad, dimRoundingMode } = attrs;
+    const dilations = 1;
+    assert$1(eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in avgPool: Either strides or dilations must be 1. ' +
+        `Got strides ${strides} and dilations '${dilations}'`);
+    const convInfo = computePool2DInfo(x.shape, filterSize, strides, dilations, pad, dimRoundingMode);
+    let res;
+    if (convInfo.filterWidth === 1 && convInfo.filterHeight === 1 &&
+        arraysEqual(convInfo.inShape, convInfo.outShape)) {
+        res = identity$1({ inputs: { x }, backend });
+    }
+    else {
+        const xValues = backend.data.get(x.dataId).values;
+        const strides = computeStrides(x.shape);
+        const buffer = pool(xValues, x.shape, x.dtype, strides, convInfo, 'avg');
+        res = backend.makeTensorInfo(convInfo.outShape, x.dtype, buffer.values);
+    }
+    return res;
+}
+const avgPoolConfig = {
+    kernelName: AvgPool,
+    backendName: 'cpu',
+    kernelFunc: avgPool
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function avgPool3D(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { filterSize, strides, pad, dimRoundingMode, dataFormat } = attrs;
+    assertNotComplex(x, 'avgPool3d');
+    const convInfo = computePool3DInfo(x.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode, dataFormat);
+    const xValues = backend.data.get(x.dataId).values;
+    const outBuf = pool3d(xValues, x.shape, x.dtype, computeStrides(x.shape), convInfo, 'avg');
+    return backend.makeTensorInfo(outBuf.shape, 'float32', outBuf.values);
+}
+const avgPool3DConfig = {
+    kernelName: AvgPool3D,
+    backendName: 'cpu',
+    kernelFunc: avgPool3D
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function avgPool3DGrad(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, input } = inputs;
+    const { filterSize, strides, pad, dimRoundingMode } = attrs;
+    assertNotComplex([dy, input], 'avgPool3DGrad');
+    const convInfo = computePool3DInfo(input.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode);
+    const strideDepth = convInfo.strideDepth;
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const filterDepth = convInfo.filterDepth;
+    const filterHeight = convInfo.filterHeight;
+    const filterWidth = convInfo.filterWidth;
+    const dilationDepth = convInfo.dilationDepth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterDepth = convInfo.effectiveFilterDepth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padFront = effectiveFilterDepth - 1 - convInfo.padInfo.front;
+    const padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
+    const padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
+    const dx = buffer(input.shape, 'float32');
+    const avgMultiplier = 1 / (filterDepth * filterHeight * filterWidth);
+    const dyBuf = backend.bufferSync(dy);
+    for (let batch = 0; batch < convInfo.batchSize; ++batch) {
+        for (let channel = 0; channel < convInfo.inChannels; ++channel) {
+            for (let dxDepth = 0; dxDepth < convInfo.inDepth; ++dxDepth) {
+                for (let dxRow = 0; dxRow < convInfo.inHeight; ++dxRow) {
+                    for (let dxCol = 0; dxCol < convInfo.inWidth; ++dxCol) {
+                        // Shader code begins.
+                        const dyDepthCorner = dxDepth - padFront;
+                        const dyRowCorner = dxRow - padTop;
+                        const dyColCorner = dxCol - padLeft;
+                        let dotProd = 0;
+                        for (let wDepth = 0; wDepth < effectiveFilterDepth; wDepth += dilationDepth) {
+                            const dyDepth = (dyDepthCorner + wDepth) / strideDepth;
+                            if (dyDepth < 0 || dyDepth >= convInfo.outDepth ||
+                                Math.floor(dyDepth) !== dyDepth) {
+                                continue;
+                            }
+                            for (let wRow = 0; wRow < effectiveFilterHeight; wRow += dilationHeight) {
+                                const dyRow = (dyRowCorner + wRow) / strideHeight;
+                                if (dyRow < 0 || dyRow >= convInfo.outHeight ||
+                                    Math.floor(dyRow) !== dyRow) {
+                                    continue;
+                                }
+                                for (let wCol = 0; wCol < effectiveFilterWidth; wCol += dilationWidth) {
+                                    const dyCol = (dyColCorner + wCol) / strideWidth;
+                                    if (dyCol < 0 || dyCol >= convInfo.outWidth ||
+                                        Math.floor(dyCol) !== dyCol) {
+                                        continue;
+                                    }
+                                    const pixel = dyBuf.get(batch, dyDepth, dyRow, dyCol, channel);
+                                    dotProd += pixel;
+                                }
+                            }
+                        }
+                        dx.set(dotProd * avgMultiplier, batch, dxDepth, dxRow, dxCol, channel);
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const avgPool3DGradConfig$1 = {
+    kernelName: AvgPool3DGrad,
+    backendName: 'cpu',
+    kernelFunc: avgPool3DGrad
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function avgPoolGrad$1(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, input } = inputs;
+    const x = input;
+    assertNotComplex([dy, input], 'avgPoolGrad');
+    const { filterSize, strides, pad } = attrs;
+    const convInfo = computePool2DInfo(x.shape, filterSize, strides, 1 /* dilations */, pad);
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const filterHeight = convInfo.filterHeight;
+    const filterWidth = convInfo.filterWidth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
+    const padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
+    const dx = buffer(x.shape, 'float32');
+    const avgMultiplier = 1 / (filterHeight * filterWidth);
+    const dyData = backend.data.get(dy.dataId).values;
+    const dyBuf = buffer(dy.shape, 'float32', dyData);
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        for (let d = 0; d < convInfo.inChannels; ++d) {
+            for (let dxR = 0; dxR < convInfo.inHeight; ++dxR) {
+                for (let dxC = 0; dxC < convInfo.inWidth; ++dxC) {
+                    // Shader code begins.
+                    const dyRCorner = dxR - padTop;
+                    const dyCCorner = dxC - padLeft;
+                    let dotProd = 0;
+                    for (let wR = 0; wR < effectiveFilterHeight; wR += dilationHeight) {
+                        const dyR = (dyRCorner + wR) / strideHeight;
+                        if (dyR < 0 || dyR >= convInfo.outHeight ||
+                            Math.floor(dyR) !== dyR) {
+                            continue;
+                        }
+                        for (let wC = 0; wC < effectiveFilterWidth; wC += dilationWidth) {
+                            const dyC = (dyCCorner + wC) / strideWidth;
+                            if (dyC < 0 || dyC >= convInfo.outWidth ||
+                                Math.floor(dyC) !== dyC) {
+                                continue;
+                            }
+                            const pixel = dyBuf.get(b, dyR, dyC, d);
+                            dotProd += pixel;
+                        }
+                    }
+                    dx.set(dotProd * avgMultiplier, b, dxR, dxC, d);
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const avgPoolGradConfig$1 = {
+    kernelName: AvgPoolGrad,
+    backendName: 'cpu',
+    kernelFunc: avgPoolGrad$1
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function batchNorm(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, scale, offset, mean, variance } = inputs;
+    assert$1(mean.shape.length === variance.shape.length, () => 'Batch normalization gradient requires mean and variance to have ' +
+        'equal ranks.');
+    assert$1(offset == null || mean.shape.length === offset.shape.length, () => 'Batch normalization gradient requires mean and offset to have ' +
+        'equal ranks.');
+    assert$1(scale == null || mean.shape.length === scale.shape.length, () => 'Batch normalization gradient requires mean and scale to have ' +
+        'equal ranks.');
+    assertNotComplex([x, mean, variance, scale, offset], 'batchNorm');
+    let { varianceEpsilon } = attrs;
+    if (varianceEpsilon == null) {
+        varianceEpsilon = 0.001;
+    }
+    const xVals = backend.data.get(x.dataId).values;
+    const mVals = backend.data.get(mean.dataId).values;
+    const varVals = backend.data.get(variance.dataId).values;
+    const sVals = scale ? backend.data.get(scale.dataId).values :
+        new Float32Array([1]);
+    const offVals = offset ?
+        backend.data.get(offset.dataId).values :
+        new Float32Array([0]);
+    const outVals = new Float32Array(xVals.length);
+    const offValsLength = offVals.length;
+    const sValsLength = sVals.length;
+    const varValsLength = varVals.length;
+    const mValsLength = mVals.length;
+    let offi = 0;
+    let mi = 0;
+    let si = 0;
+    let vi = 0;
+    for (let i = 0; i < xVals.length; ++i) {
+        outVals[i] = offVals[offi++] +
+            (xVals[i] - mVals[mi++]) * sVals[si++] /
+                Math.sqrt(varVals[vi++] + varianceEpsilon);
+        if (offi >= offValsLength) {
+            offi = 0;
+        }
+        if (mi >= mValsLength) {
+            mi = 0;
+        }
+        if (si >= sValsLength) {
+            si = 0;
+        }
+        if (vi >= varValsLength) {
+            vi = 0;
+        }
+    }
+    return backend.makeTensorInfo(x.shape, x.dtype, outVals);
+}
+const batchNormConfig = {
+    kernelName: FusedBatchNorm,
+    backendName: 'cpu',
+    kernelFunc: batchNorm,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function batchToSpaceND(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { blockShape, crops } = attrs;
+    assertNotComplex([x], 'batchToSpaceND');
+    const prod = blockShape.reduce((a, b) => a * b);
+    const reshaped = getReshaped(x.shape, blockShape, prod);
+    const permuted = getPermuted(reshaped.length, blockShape.length);
+    const reshapedPermuted = getReshapedPermuted(x.shape, blockShape, prod);
+    const sliceBeginCoords = getSliceBeginCoords(crops, blockShape.length);
+    const sliceSize = getSliceSize(reshapedPermuted, crops, blockShape.length);
+    const xReshaped = reshape({ inputs: { x }, backend, attrs: { shape: reshaped } });
+    const xTransposed = transpose$1({ inputs: { x: xReshaped }, backend, attrs: { perm: permuted } });
+    const xTransposedReshaped = reshape({ inputs: { x: xTransposed }, backend, attrs: { shape: reshapedPermuted } });
+    const result = slice$1({
+        inputs: { x: xTransposedReshaped },
+        backend,
+        attrs: { begin: sliceBeginCoords, size: sliceSize }
+    });
+    backend.disposeIntermediateTensorInfo(xReshaped);
+    backend.disposeIntermediateTensorInfo(xTransposed);
+    backend.disposeIntermediateTensorInfo(xTransposedReshaped);
+    return result;
+}
+const batchToSpaceNDConfig = {
+    kernelName: BatchToSpaceND,
+    backendName: 'cpu',
+    kernelFunc: batchToSpaceND
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function bincount(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, weights } = inputs;
+    const { size } = attrs;
+    const xVals = backend.data.get(x.dataId).values;
+    const weightsVals = backend.data.get(weights.dataId).values;
+    const outVals = bincountImpl(xVals, weightsVals, weights.dtype, weights.shape, size);
+    return backend.makeTensorInfo([size], weights.dtype, outVals);
+}
+const bincountConfig = {
+    kernelName: Bincount,
+    backendName: 'cpu',
+    kernelFunc: bincount
+};
+
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function broadcastArgs(args) {
+    const { inputs, backend } = args;
+    const { s0, s1 } = inputs;
+    const s0Vals = backend.data.get(s0.dataId).values;
+    const s1Vals = backend.data.get(s1.dataId).values;
+    const broadcastShape = assertAndGetBroadcastShape(Array.from(s0Vals), Array.from(s1Vals));
+    return backend.makeTensorInfo([broadcastShape.length], 'int32', Int32Array.from(broadcastShape));
+}
+const broadcastArgsConfig = {
+    kernelName: BroadcastArgs,
+    backendName: 'cpu',
+    kernelFunc: broadcastArgs
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const clipByValue = unaryKernelFunc$1(ClipByValue, (xi, attrs) => {
+    const clipAttrs = attrs;
+    if (xi > clipAttrs.clipValueMax) {
+        return clipAttrs.clipValueMax;
+    }
+    return xi < clipAttrs.clipValueMin ? clipAttrs.clipValueMin : xi;
+});
+const clipByValueConfig = {
+    kernelName: ClipByValue,
+    backendName: 'cpu',
+    kernelFunc: clipByValue,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const complexAbs = (args) => {
+    const { x } = args.inputs;
+    const cpuBackend = args.backend;
+    const resultValues = new Float32Array(sizeFromShape(x.shape));
+    const complexVals = cpuBackend.data.get(x.dataId);
+    const real = complexVals.complexTensorInfos.real;
+    const imag = complexVals.complexTensorInfos.imag;
+    const realVals = cpuBackend.data.get(real.dataId).values;
+    const imagVals = cpuBackend.data.get(imag.dataId).values;
+    for (let i = 0; i < realVals.length; i++) {
+        const real = realVals[i];
+        const imag = imagVals[i];
+        resultValues[i] = Math.hypot(real, imag);
+    }
+    return cpuBackend.makeOutput(resultValues, x.shape, 'float32');
+};
+const complexAbsConfig = {
+    kernelName: ComplexAbs,
+    backendName: 'cpu',
+    kernelFunc: complexAbs,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function imag(args) {
+    const { inputs, backend } = args;
+    const { input } = inputs;
+    const imag = backend.data.get(input.dataId).complexTensorInfos.imag;
+    const imagVal = backend.data.get(imag.dataId).values;
+    // When complex tensor is disposed, its underlying parts will be disposed too.
+    // Make new tensor out of the imag value of the complex. This makes sure the
+    // value is still accessible even if complex tensor is disposed.
+    return backend.makeTensorInfo(imag.shape, imag.dtype, imagVal);
+}
+const imagConfig = {
+    kernelName: Imag,
+    backendName: 'cpu',
+    kernelFunc: imag
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function concat(args) {
+    const { inputs, backend, attrs } = args;
+    const { axis } = attrs;
+    const $axis = parseAxisParam(axis, inputs[0].shape)[0];
+    const shapes = inputs.map(t => t.shape);
+    assertParamsConsistent(shapes, $axis);
+    let outShape = computeOutShape$1(inputs.map(t => t.shape), $axis);
+    if (sizeFromShape(outShape) === 0) {
+        return backend.makeTensorInfo(outShape, inputs[0].dtype, []);
+    }
+    // Keep only non-empty tensors (ignore tensors with 0 in their shape).
+    const $inputs = inputs.filter(t => sizeFromShape(t.shape) > 0);
+    if ($inputs.length === 1) {
+        return identity$1({ inputs: { x: $inputs[0] }, backend });
+    }
+    if ($inputs[0].dtype === 'complex64') {
+        const reals = $inputs.map((t) => real$1({ inputs: { input: t }, backend }));
+        const imags = $inputs.map((t) => imag({ inputs: { input: t }, backend }));
+        const realConcated = concat({ inputs: reals, backend, attrs: { axis: $axis } });
+        const imagConcated = concat({ inputs: imags, backend, attrs: { axis: $axis } });
+        const result = complex$1({ inputs: { real: realConcated, imag: imagConcated }, backend });
+        reals.forEach(r => backend.disposeIntermediateTensorInfo(r));
+        imags.forEach(i => backend.disposeIntermediateTensorInfo(i));
+        backend.disposeIntermediateTensorInfo(realConcated);
+        backend.disposeIntermediateTensorInfo(imagConcated);
+        return result;
+    }
+    // Any concat of n-dimensional tensors across any axis can be reduced to
+    // a concatenation of two-dimensional tensors across the axis 1 by first
+    // partitioning the axes of the original tensors into those less than the
+    // axis to be concatenated and the rest. Then reshape the tensors
+    // into a two-dimensional tensor by collapsing these two sets of axes and
+    // concatenate the resulting matrices across the axis 1, finally reshaping
+    // the result to have the proper shape.
+    const inputs2D = $inputs.map(t => {
+        const innerSize = sizeFromShape(t.shape.slice($axis));
+        const shape = [-1, innerSize];
+        return reshape({ inputs: { x: t }, backend, attrs: { shape } });
+    });
+    const inputsValShapes = inputs2D.map(t => {
+        return { vals: backend.data.get(t.dataId).values, shape: t.shape };
+    });
+    // Concats 2d tensors along axis=1.
+    outShape =
+        computeOutShape$1(inputs2D.map(t => t.shape), 1 /* axis */);
+    const simplyConcat = inputs2D[0].shape[0] === 1;
+    const outVals = concatImpl$1(inputsValShapes, outShape, inputs[0].dtype, simplyConcat);
+    const finalOutShape = computeOutShape$1($inputs.map(t => t.shape), $axis);
+    const outInfo = backend.makeTensorInfo(finalOutShape, inputs[0].dtype, outVals);
+    inputs2D.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return outInfo;
+}
+const concatConfig = {
+    kernelName: Concat,
+    backendName: 'cpu',
+    kernelFunc: concat
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function conv2D(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, filter } = inputs;
+    const { strides, pad, dataFormat, dilations, dimRoundingMode } = attrs;
+    assertNotComplex([x, filter], 'conv2d');
+    const $dataFormat = convertConv2DDataFormat(dataFormat);
+    const convInfo = computeConv2DInfo(x.shape, filter.shape, strides, dilations, pad, dimRoundingMode, false /* depthwise */, $dataFormat);
+    const filterHeight = convInfo.filterHeight;
+    const filterWidth = convInfo.filterWidth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const padLeft = convInfo.padInfo.left;
+    const padTop = convInfo.padInfo.top;
+    const isChannelsLast = convInfo.dataFormat === 'channelsLast';
+    const y = new TensorBuffer(convInfo.outShape, x.dtype);
+    const xStrides = computeStrides(x.shape);
+    const filterStrides = computeStrides(filter.shape);
+    const xBatchStride = xStrides[0];
+    const xRowStride = isChannelsLast ? xStrides[1] : xStrides[2];
+    const xColStride = isChannelsLast ? xStrides[2] : 1;
+    const xChannelStride = isChannelsLast ? 1 : xStrides[1];
+    const yBatchStride = y.strides[0];
+    const yRowStride = isChannelsLast ? y.strides[1] : y.strides[2];
+    const yColStride = isChannelsLast ? y.strides[2] : 1;
+    const yChannelStride = isChannelsLast ? 1 : y.strides[1];
+    const xVals = backend.data.get(x.dataId).values;
+    const wVals = backend.data.get(filter.dataId).values;
+    const yVals = y.values;
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        const xOffset1 = b * xBatchStride;
+        const yOffset1 = b * yBatchStride;
+        for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+            const yOffset2 = yOffset1 + yR * yRowStride;
+            const xRCorner = yR * convInfo.strideHeight - padTop;
+            for (let wR = 0; wR < filterHeight; ++wR) {
+                const xR = xRCorner + wR * dilationHeight;
+                if (xR < 0 || xR >= convInfo.inHeight) {
+                    continue;
+                }
+                const wOffset1 = wR * filterStrides[0];
+                const xOffset2 = xOffset1 + xR * xRowStride;
+                for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+                    const yOffset3 = yOffset2 + yC * yColStride;
+                    const xCCorner = yC * convInfo.strideWidth - padLeft;
+                    for (let wC = 0; wC < filterWidth; ++wC) {
+                        const xC = xCCorner + wC * dilationWidth;
+                        if (xC < 0 || xC >= convInfo.inWidth) {
+                            continue;
+                        }
+                        const wOffset2 = wOffset1 + wC * filterStrides[1];
+                        const xOffset3 = xOffset2 + xC * xColStride;
+                        let wOffset3 = wOffset2;
+                        for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+                            const xVal = xVals[xOffset3 + d1 * xChannelStride];
+                            for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+                                yVals[yOffset3 + d2 * yChannelStride] +=
+                                    xVal * wVals[wOffset3 + d2];
+                            }
+                            wOffset3 += convInfo.outChannels;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(y.shape, y.dtype, yVals);
+}
+const conv2DConfig = {
+    kernelName: Conv2D,
+    backendName: 'cpu',
+    kernelFunc: conv2D
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function conv2DBackpropFilter(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, dy } = inputs;
+    const { strides, pad, dataFormat, dimRoundingMode, filterShape } = attrs;
+    assertNotComplex([x, dy], 'conv2dBackpropFilter');
+    const $dataFormat = convertConv2DDataFormat(dataFormat);
+    const convInfo = computeConv2DInfo(x.shape, filterShape, strides, 1 /* dilations */, pad, dimRoundingMode, false /* depthwise */, $dataFormat);
+    const { strideHeight, strideWidth, filterHeight, filterWidth } = convInfo;
+    const isChannelsLast = convInfo.dataFormat === 'channelsLast';
+    const dW = new TensorBuffer(convInfo.filterShape, 'float32');
+    const leftPad = convInfo.padInfo.left;
+    const topPad = convInfo.padInfo.top;
+    const xVals = backend.data.get(x.dataId).values;
+    const dyVals = backend.data.get(dy.dataId).values;
+    const xBuf = new TensorBuffer(x.shape, x.dtype, xVals);
+    const dyBuf = new TensorBuffer(dy.shape, dy.dtype, dyVals);
+    for (let wR = 0; wR < filterHeight; ++wR) {
+        const yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));
+        const yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);
+        for (let wC = 0; wC < filterWidth; ++wC) {
+            const yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));
+            const yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);
+            for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+                for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+                    let dotProd = 0;
+                    for (let b = 0; b < convInfo.batchSize; ++b) {
+                        for (let yR = yRMin; yR < yRMax; ++yR) {
+                            const xR = wR + yR * strideHeight - topPad;
+                            for (let yC = yCMin; yC < yCMax; ++yC) {
+                                const xC = wC + yC * strideWidth - leftPad;
+                                if (isChannelsLast) {
+                                    dotProd += xBuf.get(b, xR, xC, d1) *
+                                        dyBuf.get(b, yR, yC, d2);
+                                }
+                                else {
+                                    dotProd += xBuf.get(b, d1, xR, xC) *
+                                        dyBuf.get(b, d2, yR, yC);
+                                }
+                            }
+                        }
+                    }
+                    dW.set(dotProd, wR, wC, d1, d2);
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dW.shape, dW.dtype, dW.values);
+}
+const conv2DBackpropFilterConfig = {
+    kernelName: Conv2DBackpropFilter,
+    backendName: 'cpu',
+    kernelFunc: conv2DBackpropFilter
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function conv2DBackpropInput(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, filter } = inputs;
+    const { inputShape, strides, pad, dataFormat, dimRoundingMode } = attrs;
+    assertNotComplex([dy, filter], 'conv2dBackpropInput');
+    const filterStrides = computeStrides(filter.shape);
+    const dyStrides = computeStrides(dy.shape);
+    let $dataFormat = convertConv2DDataFormat(dataFormat);
+    const convInfo = computeConv2DInfo(inputShape, filter.shape, strides, 1 /* dilations */, pad, dimRoundingMode, false, $dataFormat);
+    const dx = new TensorBuffer(convInfo.inShape, 'float32');
+    const dxValues = dx.values;
+    const dyValues = backend.data.get(dy.dataId).values;
+    const fltValues = backend.data.get(filter.dataId).values;
+    const [fltS0, fltS1, fltS2] = filterStrides;
+    const { batchSize, filterHeight, filterWidth, inChannels, inHeight, inWidth, outChannels, outHeight, outWidth, strideHeight, strideWidth } = convInfo;
+    $dataFormat = convInfo.dataFormat;
+    const topPad = filterHeight - 1 - convInfo.padInfo.top;
+    const leftPad = filterWidth - 1 - convInfo.padInfo.left;
+    const isChannelsLast = $dataFormat === 'channelsLast';
+    const xBatchStride = dx.strides[0];
+    const xRowStride = isChannelsLast ? dx.strides[1] : dx.strides[2];
+    const xColStride = isChannelsLast ? dx.strides[2] : 1;
+    const xChannelStride = isChannelsLast ? 1 : dx.strides[1];
+    const yBatchStride = dyStrides[0];
+    const yRowStride = isChannelsLast ? dyStrides[1] : dyStrides[2];
+    const yColStride = isChannelsLast ? dyStrides[2] : 1;
+    const yChannelStride = isChannelsLast ? 1 : dyStrides[1];
+    for (let b = 0; b < batchSize; ++b) {
+        for (let d1 = 0; d1 < inChannels; ++d1) {
+            for (let xR = 0; xR < inHeight; ++xR) {
+                const xRCorner = xR - topPad;
+                const xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));
+                const yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);
+                for (let xC = 0; xC < inWidth; ++xC) {
+                    const xCCorner = xC - leftPad;
+                    const xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));
+                    const yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);
+                    let dotProd = 0;
+                    for (let yR = xRMin; yR < yRMax; ++yR) {
+                        const wR = yR * strideHeight - xRCorner;
+                        for (let yC = xCMin; yC < yCMax; ++yC) {
+                            const wC = yC * strideWidth - xCCorner;
+                            const dyOffset = yBatchStride * b + yRowStride * yR + yColStride * yC;
+                            const fltOffset = fltS0 * (filterHeight - 1 - wR) +
+                                fltS1 * (filterWidth - 1 - wC) + fltS2 * d1;
+                            for (let d2 = 0; d2 < outChannels; ++d2) {
+                                const pixel = dyValues[dyOffset + yChannelStride * d2];
+                                const weight = fltValues[fltOffset + d2];
+                                dotProd += pixel * weight;
+                            }
+                        }
+                    }
+                    const dxOffset = xBatchStride * b + xRowStride * xR +
+                        xColStride * xC + xChannelStride * d1;
+                    dxValues[dxOffset] = dotProd;
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const conv2DBackpropInputConfig = {
+    kernelName: Conv2DBackpropInput,
+    backendName: 'cpu',
+    kernelFunc: conv2DBackpropInput
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function conv3D(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, filter } = inputs;
+    const { strides, pad, dilations } = attrs;
+    assertNotComplex([x, filter], 'conv3d');
+    const convInfo = computeConv3DInfo(x.shape, filter.shape, strides, dilations, pad);
+    const { filterDepth, filterHeight, filterWidth, dilationDepth, dilationHeight, dilationWidth, padInfo } = convInfo;
+    const padFront = padInfo.front;
+    const padLeft = padInfo.left;
+    const padTop = padInfo.top;
+    const y = new TensorBuffer(convInfo.outShape, x.dtype);
+    const xVals = backend.data.get(x.dataId).values;
+    const wVals = backend.data.get(filter.dataId).values;
+    const yVals = y.values;
+    const xStrides = computeStrides(x.shape);
+    const filterStrides = computeStrides(filter.shape);
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        const xOffset1 = b * xStrides[0];
+        const yOffset1 = b * y.strides[0];
+        for (let yF = 0; yF < convInfo.outDepth; ++yF) {
+            const yOffset2 = yOffset1 + yF * y.strides[1];
+            const xFCorner = yF * convInfo.strideDepth - padFront;
+            for (let wF = 0; wF < filterDepth; ++wF) {
+                const xF = xFCorner + wF * dilationDepth;
+                if (xF < 0 || xF >= convInfo.inDepth) {
+                    continue;
+                }
+                const wOffset1 = wF * filterStrides[0];
+                const xOffset2 = xOffset1 + xF * xStrides[1];
+                for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+                    const yOffset3 = yOffset2 + yR * y.strides[2];
+                    const xRCorner = yR * convInfo.strideHeight - padTop;
+                    for (let wR = 0; wR < filterHeight; ++wR) {
+                        const xR = xRCorner + wR * dilationHeight;
+                        if (xR < 0 || xR >= convInfo.inHeight) {
+                            continue;
+                        }
+                        const wOffset2 = wOffset1 + wR * filterStrides[1];
+                        const xOffset3 = xOffset2 + xR * xStrides[2];
+                        for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+                            const yOffset4 = yOffset3 + yC * convInfo.outChannels;
+                            const xCCorner = yC * convInfo.strideWidth - padLeft;
+                            for (let wC = 0; wC < filterWidth; ++wC) {
+                                const xC = xCCorner + wC * dilationWidth;
+                                if (xC < 0 || xC >= convInfo.inWidth) {
+                                    continue;
+                                }
+                                const wOffset3 = wOffset2 + wC * filterStrides[2];
+                                const xOffset4 = xOffset3 + xC * convInfo.inChannels;
+                                let wOffset4 = wOffset3;
+                                for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+                                    const xVal = xVals[xOffset4 + d1];
+                                    for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+                                        yVals[yOffset4 + d2] += xVal * wVals[wOffset4 + d2];
+                                    }
+                                    wOffset4 += convInfo.outChannels;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(y.shape, y.dtype, y.values);
+}
+const conv3DConfig = {
+    kernelName: Conv3D,
+    backendName: 'cpu',
+    kernelFunc: conv3D
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function conv3DBackpropFilterV2(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, dy } = inputs;
+    const { strides, pad, filterShape } = attrs;
+    assertNotComplex([x, dy], 'conv3dBackpropFilterV2');
+    const xStrides = computeStrides(x.shape);
+    const dyStrides = computeStrides(dy.shape);
+    const convInfo = computeConv3DInfo(x.shape, filterShape, strides, 1 /* dilations */, pad);
+    const strideDepth = convInfo.strideDepth;
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const filterDepth = convInfo.filterDepth;
+    const filterHeight = convInfo.filterHeight;
+    const filterWidth = convInfo.filterWidth;
+    const dw = new TensorBuffer(convInfo.filterShape, 'float32');
+    const dwValues = dw.values;
+    const [dwS0, dwS1, dwS2, dwS3] = dw.strides;
+    const dyValues = backend.data.get(dy.dataId).values;
+    const [dyS0, dyS1, dyS2, dyS3] = dyStrides;
+    const xValues = backend.data.get(x.dataId).values;
+    const [xS0, xS1, xS2, xS3] = xStrides;
+    const frontPad = convInfo.padInfo.front;
+    const leftPad = convInfo.padInfo.left;
+    const topPad = convInfo.padInfo.top;
+    for (let wF = 0; wF < filterDepth; ++wF) {
+        const yFMin = Math.max(0, Math.ceil((frontPad - wF) / strideDepth));
+        const yFMax = Math.min(convInfo.outDepth, (convInfo.inDepth + frontPad - wF) / strideDepth);
+        const wOffset1 = wF * dwS0;
+        for (let wR = 0; wR < filterHeight; ++wR) {
+            const yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));
+            const yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);
+            const wOffset2 = wR * dwS1 + wOffset1;
+            for (let wC = 0; wC < filterWidth; ++wC) {
+                const yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));
+                const yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);
+                const wOffset3 = wC * dwS2 + wOffset2;
+                for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+                    const wOffset4 = d1 * dwS3 + wOffset3;
+                    for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+                        let dotProd = 0;
+                        for (let b = 0; b < convInfo.batchSize; ++b) {
+                            const xOffset1 = b * xS0;
+                            const yOffset1 = b * dyS0;
+                            for (let yF = yFMin; yF < yFMax; ++yF) {
+                                const xF = wF + yF * strideDepth - frontPad;
+                                const xOffset2 = xF * xS1 + xOffset1;
+                                const yOffset2 = yF * dyS1 + yOffset1;
+                                for (let yR = yRMin; yR < yRMax; ++yR) {
+                                    const xR = wR + yR * strideHeight - topPad;
+                                    const xOffset3 = xR * xS2 + xOffset2;
+                                    const yOffset3 = yR * dyS2 + yOffset2;
+                                    for (let yC = yCMin; yC < yCMax; ++yC) {
+                                        const xC = wC + yC * strideWidth - leftPad;
+                                        const xOffset4 = xC * xS3 + xOffset3;
+                                        const yOffset4 = yC * dyS3 + yOffset3;
+                                        dotProd += xValues[xOffset4 + d1] * dyValues[yOffset4 + d2];
+                                    }
+                                }
+                            }
+                        }
+                        dwValues[wOffset4 + d2] = dotProd;
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dw.shape, dw.dtype, dw.values);
+}
+const conv3DBackpropFilterV2Config = {
+    kernelName: Conv3DBackpropFilterV2,
+    backendName: 'cpu',
+    kernelFunc: conv3DBackpropFilterV2
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function conv3DBackpropInputV2(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, filter } = inputs;
+    const { pad, strides, inputShape } = attrs;
+    assertNotComplex([dy], 'conv3dBackpropInputV2');
+    const dyStrides = computeStrides(dy.shape);
+    const filterStrides = computeStrides(filter.shape);
+    const convInfo = computeConv3DInfo(inputShape, filter.shape, strides, 1 /* dilations */, pad);
+    const dx = new TensorBuffer(convInfo.inShape, 'float32');
+    const dxValues = dx.values;
+    const [dxS0, dxS1, dxS2, dxS3] = dx.strides;
+    const dyValues = backend.data.get(dy.dataId).values;
+    const [dyS0, dyS1, dyS2, dyS3] = dyStrides;
+    const fltValues = backend.data.get(filter.dataId).values;
+    const [fltS0, fltS1, fltS2, fltS3] = filterStrides;
+    const { batchSize, filterDepth, filterHeight, filterWidth, inChannels, inDepth, inHeight, inWidth, outChannels, outDepth, outHeight, outWidth, strideDepth, strideHeight, strideWidth } = convInfo;
+    const frontPad = filterDepth - 1 - convInfo.padInfo.front;
+    const topPad = filterHeight - 1 - convInfo.padInfo.top;
+    const leftPad = filterWidth - 1 - convInfo.padInfo.left;
+    for (let b = 0; b < batchSize; ++b) {
+        for (let d1 = 0; d1 < inChannels; ++d1) {
+            // Frames of depth
+            for (let xF = 0; xF < inDepth; ++xF) {
+                const xFCorner = xF - frontPad;
+                const xFMin = Math.max(0, Math.ceil(xFCorner / strideDepth));
+                const yFMax = Math.min(outDepth, (filterDepth + xFCorner) / strideDepth);
+                // Rows as per standard 2d matrix notation
+                for (let xR = 0; xR < inHeight; ++xR) {
+                    const xRCorner = xR - topPad;
+                    const xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));
+                    const yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);
+                    // Columns as per standard 2d matrix notation
+                    for (let xC = 0; xC < inWidth; ++xC) {
+                        const xCCorner = xC - leftPad;
+                        const xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));
+                        const yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);
+                        let dotProd = 0;
+                        for (let yF = xFMin; yF < yFMax; ++yF) {
+                            const wF = yF * strideDepth - xFCorner;
+                            for (let yR = xRMin; yR < yRMax; ++yR) {
+                                const wR = yR * strideHeight - xRCorner;
+                                for (let yC = xCMin; yC < yCMax; ++yC) {
+                                    const wC = yC * strideWidth - xCCorner;
+                                    const dyOffset = dyS0 * b + dyS1 * yF + dyS2 * yR + dyS3 * yC;
+                                    const fltOffset = fltS0 * (filterDepth - 1 - wF) +
+                                        fltS1 * (filterHeight - 1 - wR) +
+                                        fltS2 * (filterWidth - 1 - wC) + fltS3 * d1;
+                                    for (let d2 = 0; d2 < outChannels; ++d2) {
+                                        const pixel = dyValues[dyOffset + d2];
+                                        const weight = fltValues[fltOffset + d2];
+                                        dotProd += pixel * weight;
+                                    }
+                                }
+                            }
+                        }
+                        dxValues[dxS0 * b + dxS1 * xF + dxS2 * xR + dxS3 * xC + d1] =
+                            dotProd;
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const conv3DBackpropInputV2Config = {
+    kernelName: Conv3DBackpropInputV2,
+    backendName: 'cpu',
+    kernelFunc: conv3DBackpropInputV2
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const cos = unaryKernelFunc$1(Cos, (xi) => Math.cos(xi));
+const cosConfig = {
+    kernelName: Cos,
+    backendName: 'cpu',
+    kernelFunc: cos,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const cosh = unaryKernelFunc$1(Cosh, (xi) => Math.cosh(xi));
+const coshConfig = {
+    kernelName: Cosh,
+    backendName: 'cpu',
+    kernelFunc: cosh,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function cropAndResize(args) {
+    const { inputs, backend, attrs } = args;
+    const { image, boxes, boxInd } = inputs;
+    const { cropSize, method, extrapolationValue } = attrs;
+    const [batch, imageHeight, imageWidth, numChannels] = image.shape;
+    const numBoxes = boxes.shape[0];
+    const [cropHeight, cropWidth] = cropSize;
+    const output = buffer([numBoxes, cropHeight, cropWidth, numChannels], 'float32');
+    const boxVals = backend.data.get(boxes.dataId).values;
+    const boxIndVals = backend.data.get(boxInd.dataId).values;
+    const imageVals = backend.data.get(image.dataId).values;
+    const inStride = computeStrides(image.shape); // to calculate flat indexes into image
+    const outStride = computeStrides(output.shape); // to calculate flat indexes into output
+    // Reference implementation
+    // tslint:disable-next-line:max-line-length
+    // https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/crop_and_resize_op.cc
+    for (let b = 0; b < numBoxes; b++) {
+        const startInd = b * 4;
+        const y1 = boxVals[startInd];
+        const x1 = boxVals[startInd + 1];
+        const y2 = boxVals[startInd + 2];
+        const x2 = boxVals[startInd + 3];
+        const bInd = boxIndVals[b];
+        if (bInd >= batch) {
+            continue;
+        }
+        const heightScale = (cropHeight > 1) ? (y2 - y1) * (imageHeight - 1) / (cropHeight - 1) : 0;
+        const widthScale = (cropWidth > 1) ? (x2 - x1) * (imageWidth - 1) / (cropWidth - 1) : 0;
+        for (let y = 0; y < cropHeight; y++) {
+            const yInd = (cropHeight > 1) ?
+                y1 * (imageHeight - 1) + y * (heightScale) :
+                0.5 * (y1 + y2) * (imageHeight - 1);
+            if (yInd < 0 || yInd > imageHeight - 1) {
+                for (let x = 0; x < cropWidth; x++) {
+                    for (let c = 0; c < numChannels; c++) {
+                        const ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+                        output.values[ind] = extrapolationValue;
+                    }
+                }
+                continue;
+            }
+            if (method === 'bilinear') {
+                const topInd = Math.floor(yInd);
+                const bottomInd = Math.ceil(yInd);
+                const yLerp = yInd - topInd;
+                for (let x = 0; x < cropWidth; x++) {
+                    const xInd = (cropWidth > 1) ?
+                        x1 * (imageWidth - 1) + x * widthScale :
+                        0.5 * (x1 + x2) * (imageWidth - 1);
+                    if (xInd < 0 || xInd > imageWidth - 1) {
+                        for (let c = 0; c < numChannels; c++) {
+                            const ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+                            output.values[ind] = extrapolationValue;
+                        }
+                        continue;
+                    }
+                    const leftInd = Math.floor(xInd);
+                    const rightInd = Math.ceil(xInd);
+                    const xLerp = xInd - leftInd;
+                    for (let c = 0; c < numChannels; c++) {
+                        let ind = c + leftInd * inStride[2] + topInd * inStride[1] +
+                            bInd * inStride[0];
+                        const topLeft = imageVals[ind];
+                        ind = c + rightInd * inStride[2] + topInd * inStride[1] +
+                            bInd * inStride[0];
+                        const topRight = imageVals[ind];
+                        ind = c + leftInd * inStride[2] + bottomInd * inStride[1] +
+                            bInd * inStride[0];
+                        const bottomLeft = imageVals[ind];
+                        ind = c + rightInd * inStride[2] + bottomInd * inStride[1] +
+                            bInd * inStride[0];
+                        const bottomRight = imageVals[ind];
+                        const top = topLeft + (topRight - topLeft) * xLerp;
+                        const bottom = bottomLeft + (bottomRight - bottomLeft) * xLerp;
+                        ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+                        output.values[ind] = top + ((bottom - top) * yLerp);
+                    }
+                }
+            }
+            else { // method == "nearest"
+                for (let x = 0; x < cropWidth; ++x) {
+                    const xInd = (cropWidth > 1) ?
+                        x1 * (imageWidth - 1) + x * widthScale :
+                        0.5 * (x1 + x2) * (imageWidth - 1);
+                    if (xInd < 0 || xInd > imageWidth - 1) {
+                        for (let c = 0; c < numChannels; c++) {
+                            const ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+                            output.values[ind] = extrapolationValue;
+                        }
+                        continue;
+                    }
+                    const closestX = Math.round(xInd);
+                    const closestY = Math.round(yInd);
+                    for (let c = 0; c < numChannels; c++) {
+                        const inInd = c + closestX * inStride[2] + closestY * inStride[1] +
+                            bInd * inStride[0];
+                        const outInd = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
+                        output.values[outInd] = imageVals[inInd];
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(output.shape, output.dtype, output.values);
+}
+const cropAndResizeConfig = {
+    kernelName: CropAndResize,
+    backendName: 'cpu',
+    kernelFunc: cropAndResize
+};
+
+/**
+ * @license
+ * Copyright 2022 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function cumprod(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, exclusive, reverse } = attrs;
+    assertNotComplex(x, 'cumprod');
+    const permutation = getAxesPermutation([axis], x.shape.length);
+    let $x = x;
+    if (permutation != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutation } });
+    }
+    const permutedAxis = getInnerMostAxes(1, x.shape.length)[0];
+    if (permutedAxis !== $x.shape.length - 1) {
+        throw new Error(`backend.cumprod in CPU expects an inner-most ` +
+            `axis=${$x.shape.length - 1} but got axis=${permutedAxis}`);
+    }
+    const resultDtype = upcastType($x.dtype, 'int32');
+    const vals = makeOnesTypedArray(sizeFromShape($x.shape), resultDtype);
+    const aVals = backend.data.get($x.dataId).values;
+    const finalDim = $x.shape[$x.shape.length - 1];
+    const indexAdjuster = reverse ?
+        (i, j) => i + finalDim - j - 1 :
+        (i, j) => i + j;
+    for (let i = 0; i < aVals.length; i += finalDim) {
+        for (let j = 0; j < finalDim; j++) {
+            const idx = indexAdjuster(i, j);
+            if (j === 0) {
+                vals[idx] = exclusive ? 1 : aVals[idx];
+            }
+            else {
+                const prevIdx = indexAdjuster(i, j - 1);
+                vals[idx] = exclusive ? aVals[prevIdx] * vals[prevIdx] :
+                    aVals[idx] * vals[prevIdx];
+            }
+        }
+    }
+    const result = backend.makeTensorInfo($x.shape, resultDtype, vals);
+    if (permutation != null) {
+        const reversePermutation = getUndoAxesPermutation(permutation);
+        const reverseTransposedResult = transpose$1({ inputs: { x: result }, backend, attrs: { perm: reversePermutation } });
+        backend.disposeIntermediateTensorInfo(result);
+        backend.disposeIntermediateTensorInfo($x);
+        return reverseTransposedResult;
+    }
+    return result;
+}
+const cumprodConfig = {
+    kernelName: Cumprod,
+    backendName: 'cpu',
+    kernelFunc: cumprod
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function cumsum(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, exclusive, reverse } = attrs;
+    assertNotComplex(x, 'cumsum');
+    const permutation = getAxesPermutation([axis], x.shape.length);
+    let $x = x;
+    if (permutation != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutation } });
+    }
+    const permutedAxis = getInnerMostAxes(1, x.shape.length)[0];
+    if (permutedAxis !== $x.shape.length - 1) {
+        throw new Error(`backend.cumsum in CPU expects an inner-most ` +
+            `axis=${$x.shape.length - 1} but got axis=${permutedAxis}`);
+    }
+    const resultDtype = upcastType($x.dtype, 'int32');
+    const vals = makeZerosTypedArray(sizeFromShape($x.shape), resultDtype);
+    const aVals = backend.data.get($x.dataId).values;
+    const finalDim = $x.shape[$x.shape.length - 1];
+    const indexAdjuster = reverse ?
+        (i, j) => i + finalDim - j - 1 :
+        (i, j) => i + j;
+    for (let i = 0; i < aVals.length; i += finalDim) {
+        for (let j = 0; j < finalDim; j++) {
+            const idx = indexAdjuster(i, j);
+            if (j === 0) {
+                vals[idx] = exclusive ? 0 : aVals[idx];
+            }
+            else {
+                const prevIdx = indexAdjuster(i, j - 1);
+                vals[idx] = exclusive ? aVals[prevIdx] + vals[prevIdx] :
+                    aVals[idx] + vals[prevIdx];
+            }
+        }
+    }
+    const result = backend.makeTensorInfo($x.shape, resultDtype, vals);
+    if (permutation != null) {
+        const reversePermutation = getUndoAxesPermutation(permutation);
+        const reverseTransposedResult = transpose$1({ inputs: { x: result }, backend, attrs: { perm: reversePermutation } });
+        backend.disposeIntermediateTensorInfo(result);
+        backend.disposeIntermediateTensorInfo($x);
+        return reverseTransposedResult;
+    }
+    return result;
+}
+const cumsumConfig = {
+    kernelName: Cumsum,
+    backendName: 'cpu',
+    kernelFunc: cumsum
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function denseBincount(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, weights } = inputs;
+    const { size, binaryOutput } = attrs;
+    if (x.shape.length === 1) {
+        const xVals = backend.data.get(x.dataId).values;
+        const weightsVals = backend.data.get(weights.dataId).values;
+        const outVals = bincountImpl(xVals, weightsVals, weights.dtype, weights.shape, size);
+        return backend.makeTensorInfo([size], weights.dtype, outVals);
+    }
+    else if (x.shape.length === 2) {
+        const xBuf = backend.bufferSync(x);
+        const weightsBuf = backend.bufferSync(weights);
+        const outBuf = bincountReduceImpl(xBuf, weightsBuf, size, binaryOutput);
+        return backend.makeTensorInfo(outBuf.shape, weights.dtype, outBuf.values);
+    }
+    throw new Error(`Error in denseBincount: input must be at most rank 2, but got rank` +
+        `${x.shape.length}.`);
+}
+const denseBincountConfig = {
+    kernelName: DenseBincount,
+    backendName: 'cpu',
+    kernelFunc: denseBincount
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function depthToSpace(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { blockSize, dataFormat } = attrs;
+    assert$1(dataFormat === 'NHWC', () => `Only NHWC dataFormat supported on CPU for depthToSpace. Got ${dataFormat}`);
+    const batchSize = x.shape[0];
+    const inputHeight = x.shape[1];
+    const inputWidth = x.shape[2];
+    const inputDepth = x.shape[3];
+    const outputHeight = inputHeight * blockSize;
+    const outputWidth = inputWidth * blockSize;
+    const outputDepth = inputDepth / (blockSize * blockSize);
+    const xValues = backend.data.get(x.dataId).values;
+    const result = new Float32Array(batchSize * outputHeight * outputWidth * outputDepth);
+    let outputIdx = 0;
+    for (let b = 0; b < batchSize; ++b) {
+        for (let h = 0; h < outputHeight; ++h) {
+            const inH = Math.floor(h / blockSize);
+            const offsetH = (h % blockSize);
+            for (let w = 0; w < outputWidth; ++w) {
+                const inW = Math.floor(w / blockSize);
+                const offsetW = (w % blockSize);
+                const offsetD = (offsetH * blockSize + offsetW) * outputDepth;
+                for (let d = 0; d < outputDepth; ++d) {
+                    const inD = d + offsetD;
+                    const inputIdx = inD + inputDepth * (inW + inputWidth * (inH + inputHeight * b));
+                    result[outputIdx++] = xValues[inputIdx];
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo([batchSize, outputHeight, outputWidth, outputDepth], x.dtype, result);
+}
+const depthToSpaceConfig = {
+    kernelName: DepthToSpace,
+    backendName: 'cpu',
+    kernelFunc: depthToSpace
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function depthwiseConv2dNative(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, filter } = inputs;
+    const { strides, pad, dilations, dimRoundingMode } = attrs;
+    assertNotComplex([x, filter], 'depthwiseConv2DNative');
+    const xStrides = computeStrides(x.shape);
+    const filterStrides = computeStrides(filter.shape);
+    let $dilations = dilations;
+    if ($dilations == null) {
+        $dilations = [1, 1];
+    }
+    assert$1(eitherStridesOrDilationsAreOne(strides, $dilations), () => 'Error in depthwiseConv2d: Either strides or dilations must be ' +
+        `1. Got strides ${strides} and dilations '${$dilations}'`);
+    const convInfo = computeConv2DInfo(x.shape, filter.shape, strides, $dilations, pad, dimRoundingMode, true /* depthwise */);
+    const { filterHeight, filterWidth, dilationHeight, dilationWidth, padInfo } = convInfo;
+    const padLeft = padInfo.left;
+    const padTop = padInfo.top;
+    const chMul = convInfo.outChannels / convInfo.inChannels;
+    const y = new TensorBuffer(convInfo.outShape, x.dtype);
+    const xVals = backend.data.get(x.dataId).values;
+    const wVals = backend.data.get(filter.dataId).values;
+    const yVals = y.values;
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        const xOffset1 = b * xStrides[0];
+        const yOffset1 = b * y.strides[0];
+        for (let yR = 0; yR < convInfo.outHeight; ++yR) {
+            const yOffset2 = yOffset1 + yR * y.strides[1];
+            const xRCorner = yR * convInfo.strideHeight - padTop;
+            for (let wR = 0; wR < filterHeight; ++wR) {
+                const xR = xRCorner + wR * dilationHeight;
+                if (xR < 0 || xR >= convInfo.inHeight) {
+                    continue;
+                }
+                const wOffset1 = wR * filterStrides[0];
+                const xOffset2 = xOffset1 + xR * xStrides[1];
+                for (let yC = 0; yC < convInfo.outWidth; ++yC) {
+                    const yOffset3 = yOffset2 + yC * y.strides[2];
+                    const xCCorner = yC * convInfo.strideWidth - padLeft;
+                    for (let wC = 0; wC < filterWidth; ++wC) {
+                        const xC = xCCorner + wC * dilationWidth;
+                        if (xC < 0 || xC >= convInfo.inWidth) {
+                            continue;
+                        }
+                        const wOffset2 = wOffset1 + wC * filterStrides[1];
+                        const xOffset3 = xOffset2 + xC * convInfo.inChannels;
+                        let yOffset4 = yOffset3;
+                        let wOffset3 = wOffset2;
+                        for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {
+                            const xVal = xVals[xOffset3 + d1];
+                            for (let q = 0; q < chMul; ++q) {
+                                yVals[yOffset4 + q] += xVal * wVals[wOffset3 + q];
+                            }
+                            yOffset4 += chMul;
+                            wOffset3 += chMul;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(y.shape, y.dtype, y.values);
+}
+const depthwiseConv2dNativeConfig = {
+    kernelName: DepthwiseConv2dNative,
+    backendName: 'cpu',
+    kernelFunc: depthwiseConv2dNative
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function depthwiseConv2dNativeBackpropFilter(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, dy } = inputs;
+    const { strides, dilations, pad, dimRoundingMode, filterShape } = attrs;
+    assertNotComplex([x, dy], 'depthwiseConv2dNativeBackpropFilter');
+    const convInfo = computeConv2DInfo(x.shape, filterShape, strides, dilations, pad, dimRoundingMode, true /* depthwise */);
+    const { strideHeight, strideWidth, filterHeight, filterWidth } = convInfo;
+    const dW = new TensorBuffer(convInfo.filterShape, 'float32');
+    const leftPad = convInfo.padInfo.left;
+    const topPad = convInfo.padInfo.top;
+    const chMul = convInfo.outChannels / convInfo.inChannels;
+    const xVals = backend.data.get(x.dataId).values;
+    const xBuf = new TensorBuffer(x.shape, x.dtype, xVals);
+    const dyVals = backend.data.get(dy.dataId).values;
+    const dyBuf = new TensorBuffer(dy.shape, dy.dtype, dyVals);
+    for (let wR = 0; wR < filterHeight; ++wR) {
+        const yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));
+        const yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);
+        for (let wC = 0; wC < filterWidth; ++wC) {
+            const yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));
+            const yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);
+            for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {
+                const d1 = Math.trunc(d2 / chMul);
+                const dm = d2 % chMul;
+                let dotProd = 0;
+                for (let b = 0; b < convInfo.batchSize; ++b) {
+                    for (let yR = yRMin; yR < yRMax; ++yR) {
+                        const xR = wR + yR * strideHeight - topPad;
+                        for (let yC = yCMin; yC < yCMax; ++yC) {
+                            const xC = wC + yC * strideWidth - leftPad;
+                            dotProd += xBuf.get(b, xR, xC, d1) *
+                                dyBuf.get(b, yR, yC, d2);
+                        }
+                    }
+                }
+                dW.set(dotProd, wR, wC, d1, dm);
+            }
+        }
+    }
+    return backend.makeTensorInfo(dW.shape, dW.dtype, dW.values);
+}
+const depthwiseConv2dNativeBackpropFilterConfig = {
+    kernelName: DepthwiseConv2dNativeBackpropFilter,
+    backendName: 'cpu',
+    kernelFunc: depthwiseConv2dNativeBackpropFilter
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function depthwiseConv2dNativeBackpropInput(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, filter } = inputs;
+    const { strides, dilations, pad, dimRoundingMode, inputShape } = attrs;
+    assertNotComplex([dy, filter], 'depthwiseConv2DNativeBackpropInput');
+    const dyStrides = computeStrides(dy.shape);
+    const filterStrides = computeStrides(filter.shape);
+    const convInfo = computeConv2DInfo(inputShape, filter.shape, strides, dilations, pad, dimRoundingMode, true /* depthwise */);
+    const dx = new TensorBuffer(convInfo.inShape, 'float32');
+    const dxValues = dx.values;
+    const [dxS0, dxS1, dxS2] = dx.strides;
+    const dyValues = backend.data.get(dy.dataId).values;
+    const [dyS0, dyS1, dyS2] = dyStrides;
+    const fltValues = backend.data.get(filter.dataId).values;
+    const [fltS0, fltS1, fltS2] = filterStrides;
+    const { batchSize, filterHeight, filterWidth, inChannels, inHeight, inWidth, outChannels, outHeight, outWidth, strideHeight, strideWidth } = convInfo;
+    const topPad = filterHeight - 1 - convInfo.padInfo.top;
+    const leftPad = filterWidth - 1 - convInfo.padInfo.left;
+    const chMul = outChannels / inChannels;
+    for (let b = 0; b < batchSize; ++b) {
+        for (let d1 = 0; d1 < inChannels; ++d1) {
+            for (let xR = 0; xR < inHeight; ++xR) {
+                const xRCorner = xR - topPad;
+                const xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));
+                const yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);
+                for (let xC = 0; xC < inWidth; ++xC) {
+                    const xCCorner = xC - leftPad;
+                    const xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));
+                    const yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);
+                    let dotProd = 0;
+                    for (let yR = xRMin; yR < yRMax; ++yR) {
+                        const wR = yR * strideHeight - xRCorner;
+                        for (let yC = xCMin; yC < yCMax; ++yC) {
+                            const wC = yC * strideWidth - xCCorner;
+                            const dyOffset = dyS0 * b + dyS1 * yR + dyS2 * yC;
+                            const fltOffset = fltS0 * (filterHeight - 1 - wR) +
+                                fltS1 * (filterWidth - 1 - wC) + fltS2 * d1;
+                            for (let dm = 0; dm < chMul; ++dm) {
+                                const d2 = d1 * chMul + dm;
+                                const pixel = dyValues[dyOffset + d2];
+                                const weight = fltValues[fltOffset + dm];
+                                dotProd += pixel * weight;
+                            }
+                        }
+                    }
+                    dxValues[dxS0 * b + dxS1 * xR + dxS2 * xC + d1] = dotProd;
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const depthwiseConv2dNativeBackpropInputConfig = {
+    kernelName: DepthwiseConv2dNativeBackpropInput,
+    backendName: 'cpu',
+    kernelFunc: depthwiseConv2dNativeBackpropInput
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function diag(args) {
+    const { inputs, backend } = args;
+    const { x } = inputs;
+    const xSize = sizeFromShape(x.shape);
+    const xVals = backend.data.get(x.dataId).values;
+    const outBuf = buffer([xSize, xSize], x.dtype);
+    const vals = outBuf.values;
+    for (let i = 0; i < xVals.length; i++) {
+        vals[i * xSize + i] = xVals[i];
+    }
+    const outShape = [...x.shape, ...x.shape];
+    return backend.makeTensorInfo(outShape, outBuf.dtype, outBuf.values);
+}
+const diagConfig = {
+    kernelName: Diag,
+    backendName: 'cpu',
+    kernelFunc: diag
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const dilation2DConfig = {
+    kernelName: Dilation2D,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, backend, attrs }) => {
+        const { x, filter } = inputs;
+        const { strides, pad, dilations } = attrs;
+        const cpuBackend = backend;
+        const xVals = cpuBackend.data.get(x.dataId).values;
+        const xRank = x.shape.length;
+        const filterVals = cpuBackend.data.get(filter.dataId).values;
+        const filterRank = filter.shape.length;
+        const { batchSize, inHeight, inWidth, inChannels, outHeight, outWidth, padInfo, strideHeight, strideWidth, filterHeight, filterWidth, dilationHeight, dilationWidth, outShape } = computeDilation2DInfo(x.shape, filter.shape, strides, pad, 'NHWC' /* dataFormat */, dilations);
+        const outSize = sizeFromShape(outShape);
+        const outRank = outShape.length;
+        const outputVals = getArrayFromDType(x.dtype, outSize);
+        // Upsampling the input by fill in `dilation size - 1` values between each
+        // input value.
+        // This implementation follows the TF c++ implementation:
+        // https://github.com/tensorflow/tensorflow/blob/d9a3a849edc198e90172bc58eb293de457f9d986/tensorflow/core/kernels/dilation_ops.cc
+        for (let b = 0; b < batchSize; ++b) {
+            for (let hOut = 0; hOut < outHeight; ++hOut) {
+                const hBeg = hOut * strideHeight - padInfo.top;
+                for (let wOut = 0; wOut < outWidth; ++wOut) {
+                    const wBeg = wOut * strideWidth - padInfo.left;
+                    for (let d = 0; d < inChannels; ++d) {
+                        let curVal = Number.MIN_SAFE_INTEGER;
+                        for (let h = 0; h < filterHeight; ++h) {
+                            const hIn = hBeg + h * dilationHeight;
+                            if (hIn >= 0 && hIn < inHeight) {
+                                for (let w = 0; w < filterWidth; ++w) {
+                                    const wIn = wBeg + w * dilationWidth;
+                                    if (wIn >= 0 && wIn < inWidth) {
+                                        const xIndex = locToIndex([b, hIn, wIn, d], xRank, computeStrides(x.shape));
+                                        const filterIndex = locToIndex([h, w, d], filterRank, computeStrides(filter.shape));
+                                        const val = xVals[xIndex] + filterVals[filterIndex];
+                                        if (val > curVal) {
+                                            curVal = val;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        const outputIndex = locToIndex([b, hOut, wOut, d], outRank, computeStrides(outShape));
+                        outputVals[outputIndex] = curVal;
+                    }
+                }
+            }
+        }
+        const dataId = cpuBackend.write(toTypedArray(outputVals, x.dtype), outShape, x.dtype);
+        return { dataId, shape: outShape, dtype: x.dtype };
+    }
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const dilation2DBackpropFilterConfig = {
+    kernelName: Dilation2DBackpropFilter,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, backend, attrs }) => {
+        const { x, filter, dy } = inputs;
+        const { strides, pad, dilations } = attrs;
+        const cpuBackend = backend;
+        const $x = toNestedArray(x.shape, cpuBackend.data.get(x.dataId).values);
+        const $filter = toNestedArray(filter.shape, cpuBackend.data.get(filter.dataId).values);
+        const { batchSize, inHeight, inWidth, inChannels, outHeight, outWidth, padInfo, strideHeight, strideWidth, filterHeight, filterWidth, dilationHeight, dilationWidth, outShape } = computeDilation2DInfo(x.shape, filter.shape, strides, pad, 'NHWC' /* dataFormat */, dilations);
+        assert$1(dy.rank === outShape.length, () => `Error in ${Dilation2DBackpropFilter}, dy ` +
+            `must have the same rank as output ${outShape.length}, but got ` +
+            `${dy.rank}`);
+        const $dy = toNestedArray(outShape, cpuBackend.data.get(dy.dataId).values);
+        // The computed filter gradients has the same dimensions as the filter:
+        // [filterHeight, filterWidth, depth]
+        const gradients = makeZerosNestedTypedArray(filter.shape, filter.dtype);
+        // In the case of multiple argmax branches, we only back-propagate along the
+        // last branch, i.e., the one with largest value of `h * filter_cols + w`,
+        // similarly to the max-pooling backward routines.
+        // This implementation follows the TF c++ implementation:
+        // https://github.com/tensorflow/tensorflow/blob/d9a3a849edc198e90172bc58eb293de457f9d986/tensorflow/core/kernels/dilation_ops.cc
+        for (let b = 0; b < batchSize; ++b) {
+            for (let hOut = 0; hOut < outHeight; ++hOut) {
+                const hBeg = hOut * strideHeight - padInfo.top;
+                for (let wOut = 0; wOut < outWidth; ++wOut) {
+                    const wBeg = wOut * strideWidth - padInfo.left;
+                    for (let d = 0; d < inChannels; ++d) {
+                        let curVal = Number.MIN_SAFE_INTEGER;
+                        let hMax = 0;
+                        let wMax = 0;
+                        for (let h = 0; h < filterHeight; ++h) {
+                            const hIn = hBeg + h * dilationHeight;
+                            if (hIn >= 0 && hIn < inHeight) {
+                                for (let w = 0; w < filterWidth; ++w) {
+                                    const wIn = wBeg + w * dilationWidth;
+                                    if (wIn >= 0 && wIn < inWidth) {
+                                        const val = $x[b][hIn][wIn][d] + $filter[h][w][d];
+                                        if (val > curVal) {
+                                            curVal = val;
+                                            hMax = h;
+                                            wMax = w;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        gradients[hMax][wMax][d] += $dy[b][hOut][wOut][d];
+                    }
+                }
+            }
+        }
+        const dataId = cpuBackend.write(toTypedArray(gradients, x.dtype), filter.shape, filter.dtype);
+        return { dataId, shape: filter.shape, dtype: filter.dtype };
+    }
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const dilation2DBackpropInputConfig = {
+    kernelName: Dilation2DBackpropInput,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, backend, attrs }) => {
+        const { x, filter, dy } = inputs;
+        const { strides, pad, dilations } = attrs;
+        const cpuBackend = backend;
+        const $x = toNestedArray(x.shape, cpuBackend.data.get(x.dataId).values);
+        const $filter = toNestedArray(filter.shape, cpuBackend.data.get(filter.dataId).values);
+        const { batchSize, inHeight, inWidth, inChannels, outHeight, outWidth, padInfo, strideHeight, strideWidth, filterHeight, filterWidth, dilationHeight, dilationWidth, outShape } = computeDilation2DInfo(x.shape, filter.shape, strides, pad, 'NHWC' /* dataFormat */, dilations);
+        assert$1(dy.rank === outShape.length, () => `Error in ${Dilation2DBackpropInput}, dy ` +
+            `must have the same rank as output ${outShape.length}, but got ` +
+            `${dy.rank}`);
+        const $dy = toNestedArray(outShape, cpuBackend.data.get(dy.dataId).values);
+        // The computed gradients has the same dimensions as the input:
+        // [batch, inputHeight, inputCols, inChannel]
+        const gradients = makeZerosNestedTypedArray(x.shape, x.dtype);
+        // In the case of multiple argmax branches, we only back-propagate along the
+        // last branch, i.e., the one with largest value of `h * filter_cols + w`,
+        // similarly to the max-pooling backward routines.
+        // This implementation follows the TF c++ implementation:
+        // https://github.com/tensorflow/tensorflow/blob/d9a3a849edc198e90172bc58eb293de457f9d986/tensorflow/core/kernels/dilation_ops.cc
+        for (let b = 0; b < batchSize; ++b) {
+            for (let hOut = 0; hOut < outHeight; ++hOut) {
+                const hBeg = hOut * strideHeight - padInfo.top;
+                for (let wOut = 0; wOut < outWidth; ++wOut) {
+                    const wBeg = wOut * strideWidth - padInfo.left;
+                    for (let d = 0; d < inChannels; ++d) {
+                        let curVal = Number.MIN_SAFE_INTEGER;
+                        let hInMax = (hBeg < 0) ? 0 : hBeg;
+                        let wInMax = (wBeg < 0) ? 0 : wBeg;
+                        for (let h = 0; h < filterHeight; ++h) {
+                            const hIn = hBeg + h * dilationHeight;
+                            if (hIn >= 0 && hIn < inHeight) {
+                                for (let w = 0; w < filterWidth; ++w) {
+                                    const wIn = wBeg + w * dilationWidth;
+                                    if (wIn >= 0 && wIn < inWidth) {
+                                        const val = $x[b][hIn][wIn][d] + $filter[h][w][d];
+                                        if (val > curVal) {
+                                            curVal = val;
+                                            hInMax = hIn;
+                                            wInMax = wIn;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        gradients[b][hInMax][wInMax][d] += $dy[b][hOut][wOut][d];
+                    }
+                }
+            }
+        }
+        const dataId = cpuBackend.write(toTypedArray(gradients, x.dtype), x.shape, x.dtype);
+        return { dataId, shape: x.shape, dtype: x.dtype };
+    }
+};
+
+/**
+ * @license
+ * Copyright 2023 Google LLC.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function draw(args) {
+    const { inputs, backend, attrs } = args;
+    const { image } = inputs;
+    const { canvas, options } = attrs;
+    const { contextOptions, imageOptions } = options || {};
+    const alpha = (imageOptions === null || imageOptions === void 0 ? void 0 : imageOptions.alpha) || 1;
+    const contextType = (contextOptions === null || contextOptions === void 0 ? void 0 : contextOptions.contextType) || '2d';
+    if (contextType !== '2d') {
+        throw new Error(`Context type ${contextOptions.contextType} is not supported by the CPU backend.`);
+    }
+    const ctx = canvas.getContext(contextType, (contextOptions === null || contextOptions === void 0 ? void 0 : contextOptions.contextAttributes) || {});
+    if (ctx == null) {
+        throw new Error(`Could not get the context with ${contextType} type.`);
+    }
+    const [height, width] = image.shape.slice(0, 2);
+    const depth = image.shape.length === 2 ? 1 : image.shape[2];
+    const data = backend.data.get(image.dataId).values;
+    const multiplier = image.dtype === 'float32' ? 255 : 1;
+    const bytes = new Uint8ClampedArray(width * height * 4);
+    for (let i = 0; i < height * width; ++i) {
+        const rgba = [0, 0, 0, 255 * alpha];
+        for (let d = 0; d < depth; d++) {
+            const value = data[i * depth + d];
+            if (image.dtype === 'float32') {
+                if (value < 0 || value > 1) {
+                    throw new Error(`Tensor values for a float32 Tensor must be in the ` +
+                        `range [0 - 1] but encountered ${value}.`);
+                }
+            }
+            else if (image.dtype === 'int32') {
+                if (value < 0 || value > 255) {
+                    throw new Error(`Tensor values for a int32 Tensor must be in the ` +
+                        `range [0 - 255] but encountered ${value}.`);
+                }
+            }
+            if (depth === 1) {
+                rgba[0] = value * multiplier;
+                rgba[1] = value * multiplier;
+                rgba[2] = value * multiplier;
+            }
+            else {
+                rgba[d] = value * multiplier;
+            }
+        }
+        const j = i * 4;
+        bytes[j + 0] = Math.round(rgba[0]);
+        bytes[j + 1] = Math.round(rgba[1]);
+        bytes[j + 2] = Math.round(rgba[2]);
+        bytes[j + 3] = Math.round(rgba[3]);
+    }
+    canvas.width = width;
+    canvas.height = height;
+    const imageData = new ImageData(bytes, width, height);
+    ctx.putImageData(imageData, 0, 0);
+    return image;
+}
+const drawConfig = {
+    kernelName: Draw,
+    backendName: 'cpu',
+    kernelFunc: draw
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function sum(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, keepDims } = attrs;
+    assertNotComplex(x, 'sum');
+    let $x;
+    if (x.dtype === 'bool') {
+        $x = cast$2({ inputs: { x }, backend, attrs: { dtype: 'int32' } });
+    }
+    else {
+        $x = identity$1({ inputs: { x }, backend });
+    }
+    const xRank = $x.shape.length;
+    const axes = parseAxisParam(axis, $x.shape);
+    const permutation = getAxesPermutation(axes, xRank);
+    let reductionAxes = axes;
+    let permutedX = $x;
+    if (permutation != null) {
+        permutedX =
+            transpose$1({ inputs: { x: $x }, backend, attrs: { perm: permutation } });
+        reductionAxes = getInnerMostAxes(reductionAxes.length, xRank);
+    }
+    assertAxesAreInnerMostDims('sum', reductionAxes, permutedX.shape.length);
+    const [outShape, reduceShape] = computeOutAndReduceShapes(permutedX.shape, reductionAxes);
+    const resultDtype = upcastType(permutedX.dtype, 'int32');
+    let result = zeros(backend, outShape, resultDtype);
+    const reduceSize = sizeFromShape(reduceShape);
+    const vals = backend.data.get(result.dataId).values;
+    const aVals = backend.data.get(permutedX.dataId).values;
+    for (let i = 0; i < vals.length; ++i) {
+        const offset = i * reduceSize;
+        let sum = 0;
+        for (let j = 0; j < reduceSize; ++j) {
+            sum += aVals[offset + j];
+        }
+        vals[i] = sum;
+    }
+    if (keepDims) {
+        const newShape = expandShapeToKeepDim(result.shape, axes);
+        const oldResult = result;
+        result = reshape({ inputs: { x: result }, backend, attrs: { shape: newShape } });
+        backend.disposeIntermediateTensorInfo(oldResult);
+    }
+    backend.disposeIntermediateTensorInfo($x);
+    if (permutation != null) {
+        backend.disposeIntermediateTensorInfo(permutedX);
+    }
+    return result;
+}
+const sumConfig = {
+    kernelName: Sum,
+    backendName: 'cpu',
+    kernelFunc: sum
+};
+
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function einsum(args) {
+    const { inputs, backend, attrs } = args;
+    const { equation } = attrs;
+    const tensors = inputs;
+    const { allDims, summedDims, idDims } = decodeEinsumEquation(equation, tensors.length);
+    checkEinsumDimSizes(allDims.length, idDims, tensors);
+    const { path, steps } = getEinsumComputePath(summedDims, idDims);
+    const nSteps = steps.length;
+    let out = null;
+    let numDimsRemaining = allDims.length;
+    const tensorsToDispose = [];
+    for (let i = 0; i < nSteps; ++i) {
+        for (const idTerm of steps[i]) {
+            const { permutationIndices: perm, expandDims: dimsToExpand } = getEinsumPermutation(numDimsRemaining, idDims[idTerm]);
+            let x;
+            if (isIdentityPermutation(perm)) {
+                x = tensors[idTerm];
+            }
+            else {
+                x = transpose$1({ inputs: { x: tensors[idTerm] }, backend, attrs: { perm } });
+                tensorsToDispose.push(x);
+            }
+            const targetShape = x.shape.slice();
+            for (let k = 0; k < dimsToExpand.length; ++k) {
+                targetShape.splice(dimsToExpand[k], 0, 1);
+            }
+            if (!arraysEqual(x.shape, targetShape)) {
+                x = reshape({ inputs: { x }, backend, attrs: { shape: targetShape } });
+                tensorsToDispose.push(x);
+            }
+            if (out === null) {
+                out = x;
+            }
+            else {
+                // tslint:disable-next-line: no-unnecessary-type-assertion
+                out = multiply$1({ inputs: { a: x, b: out }, backend });
+                tensorsToDispose.push(out);
+            }
+        }
+        if (i < nSteps - 1) {
+            if (path[i] >= 0) {
+                out = sum({
+                    inputs: { x: out },
+                    backend,
+                    attrs: {
+                        axis: path[i] - (allDims.length - numDimsRemaining),
+                        keepDims: false
+                    }
+                });
+                tensorsToDispose.push(out);
+            }
+            numDimsRemaining--;
+        }
+    }
+    // Clean up intermediate tensors.
+    for (const tensorInfo of tensorsToDispose) {
+        if (tensorInfo === out) {
+            continue;
+        }
+        backend.disposeIntermediateTensorInfo(tensorInfo);
+    }
+    return out;
+}
+const einsumConfig = {
+    kernelName: Einsum,
+    backendName: 'cpu',
+    kernelFunc: einsum
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function eluGrad(args) {
+    const { inputs, backend } = args;
+    const { dy, y } = inputs;
+    assertNotComplex([dy, y], 'eluGrad');
+    const resultValues = new Float32Array(sizeFromShape(y.shape));
+    const values = backend.data.get(y.dataId).values;
+    const dyValues = backend.data.get(dy.dataId).values;
+    for (let i = 0; i < values.length; ++i) {
+        const v = values[i];
+        if (v >= 0) {
+            resultValues[i] = dyValues[i];
+        }
+        else {
+            resultValues[i] = dyValues[i] * (v + 1);
+        }
+    }
+    return backend.makeTensorInfo(y.shape, 'float32', resultValues);
+}
+const eluGradConfig$1 = {
+    kernelName: EluGrad,
+    backendName: 'cpu',
+    kernelFunc: eluGrad
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const p = ERF_P;
+const a1 = ERF_A1;
+const a2 = ERF_A2;
+const a3 = ERF_A3;
+const a4 = ERF_A4;
+const a5 = ERF_A5;
+const erf = unaryKernelFunc$1(Erf, (xi) => {
+    const sign = Math.sign(xi);
+    const v = Math.abs(xi);
+    const t = 1.0 / (1.0 + p * v);
+    return sign *
+        (1.0 -
+            (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t *
+                Math.exp(-v * v));
+});
+const erfConfig = {
+    kernelName: Erf,
+    backendName: 'cpu',
+    kernelFunc: erf,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function expandDims$1(args) {
+    const { inputs, backend, attrs } = args;
+    const { input } = inputs;
+    const { dim } = attrs;
+    const inputRank = input.shape.length;
+    const newShape = input.shape.slice();
+    let $dim = dim;
+    if (dim < 0) {
+        // Negative value is counted from the tail of rank.
+        assert$1(-(inputRank + 1) <= dim, () => `Axis must be in the interval [${-(inputRank + 1)}, ${inputRank}]`);
+        $dim = inputRank + dim + 1;
+    }
+    newShape.splice($dim, 0, 1);
+    return reshape({ inputs: { x: input }, backend, attrs: { shape: newShape } });
+}
+const expandDimsConfig = {
+    kernelName: ExpandDims,
+    backendName: 'cpu',
+    kernelFunc: expandDims$1
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const realDivImpl = createSimpleBinaryKernelImpl((a, b) => a / b);
+const div = binaryKernelFunc$1(RealDiv, realDivImpl);
+const realDivConfig = {
+    kernelName: RealDiv,
+    backendName: 'cpu',
+    kernelFunc: div
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+/**
+ * Calculate FFT of inner most elements of batch tensor.
+ */
+function fftBatch(input, inverse, cpuBackend) {
+    const inputShape = input.shape;
+    const batch = inputShape[0];
+    const innerDim = inputShape[1];
+    const inputVals = cpuBackend.data.get(input.dataId);
+    const real2D = inputVals.complexTensorInfos.real;
+    const imag2D = inputVals.complexTensorInfos.imag;
+    // Collects real and imaginary values separately.
+    const resultShape = [batch, innerDim];
+    const resultSize = sizeFromShape(resultShape);
+    const resultReal = getTypedArrayFromDType('float32', resultSize);
+    const resultImag = getTypedArrayFromDType('float32', resultSize);
+    for (let b = 0; b < batch; b++) {
+        // TODO: Support slice ops for complex type.
+        const r = slice$1({
+            inputs: { x: real2D },
+            backend: cpuBackend,
+            attrs: { begin: [b, 0], size: [1, innerDim] }
+        });
+        const i = slice$1({
+            inputs: { x: imag2D },
+            backend: cpuBackend,
+            attrs: { begin: [b, 0], size: [1, innerDim] }
+        });
+        const input = complex$1({ inputs: { real: r, imag: i }, backend: cpuBackend });
+        // Run FFT by batch element.
+        const { real, imag } = fftImpl(input, inverse, cpuBackend);
+        const res = mergeRealAndImagArrays(real, imag);
+        for (let d = 0; d < innerDim; d++) {
+            const c = getComplexWithIndex(res, d);
+            resultReal[b * innerDim + d] = c.real;
+            resultImag[b * innerDim + d] = c.imag;
+        }
+        cpuBackend.disposeIntermediateTensorInfo(r);
+        cpuBackend.disposeIntermediateTensorInfo(i);
+        cpuBackend.disposeIntermediateTensorInfo(input);
+    }
+    const $realInfo = cpuBackend.makeTensorInfo(resultShape, 'float32', resultReal);
+    const $imagInfo = cpuBackend.makeTensorInfo(resultShape, 'float32', resultImag);
+    const result = complex$1({ inputs: { real: $realInfo, imag: $imagInfo }, backend: cpuBackend });
+    cpuBackend.disposeIntermediateTensorInfo($realInfo);
+    cpuBackend.disposeIntermediateTensorInfo($imagInfo);
+    return result;
+}
+function fftImpl(input, inverse, cpuBackend) {
+    const inputSize = sizeFromShape(input.shape);
+    const inputVals = cpuBackend.data.get(input.dataId);
+    const realVals = cpuBackend.data.get(inputVals.complexTensorInfos.real.dataId).values;
+    const imagVals = cpuBackend.data.get(inputVals.complexTensorInfos.imag.dataId).values;
+    if (isExponentOf2(inputSize)) {
+        const result = fftRadix2(realVals, imagVals, inputSize, inverse, cpuBackend);
+        const resultShape = [input.shape[0], input.shape[1]];
+        if (inverse) {
+            const realInfo = cpuBackend.makeTensorInfo(resultShape, 'float32', result.real);
+            const imagInfo = cpuBackend.makeTensorInfo(resultShape, 'float32', result.imag);
+            const sizeInfo = cpuBackend.makeTensorInfo([], 'float32', createScalarValue(inputSize, 'float32'));
+            const sizeInfoCopy = identity$1({ inputs: { x: sizeInfo }, backend: cpuBackend });
+            const divRealInfo = realDivConfig.kernelFunc({ inputs: { a: realInfo, b: sizeInfo }, backend: cpuBackend });
+            const divImagInfo = realDivConfig.kernelFunc({ inputs: { a: imagInfo, b: sizeInfoCopy }, backend: cpuBackend });
+            const divRealVals = cpuBackend.data.get(divRealInfo.dataId).values;
+            const divImagVals = cpuBackend.data.get(divImagInfo.dataId).values;
+            cpuBackend.disposeIntermediateTensorInfo(realInfo);
+            cpuBackend.disposeIntermediateTensorInfo(imagInfo);
+            cpuBackend.disposeIntermediateTensorInfo(sizeInfo);
+            cpuBackend.disposeIntermediateTensorInfo(sizeInfoCopy);
+            cpuBackend.disposeIntermediateTensorInfo(divRealInfo);
+            cpuBackend.disposeIntermediateTensorInfo(divImagInfo);
+            return { real: divRealVals, imag: divImagVals };
+        }
+        return result;
+    }
+    else {
+        const data = mergeRealAndImagArrays(realVals, imagVals);
+        const rawOutput = fourierTransformByMatmul(data, inputSize, inverse);
+        return splitRealAndImagArrays(rawOutput);
+    }
+}
+function isExponentOf2(size) {
+    return (size & size - 1) === 0;
+}
+// FFT using Cooley-Tukey algorithm on radix 2 dimensional input.
+function fftRadix2(realVals, imagVals, size, inverse, cpuBackend) {
+    if (size === 1) {
+        return { real: realVals, imag: imagVals };
+    }
+    const data = mergeRealAndImagArrays(realVals, imagVals);
+    const half = size / 2;
+    const evenComplex = complexWithEvenIndex(data);
+    const evenRealVals = evenComplex.real;
+    const evenImagVals = evenComplex.imag;
+    const evenShape = [evenRealVals.length];
+    const evenRealInfo = cpuBackend.makeTensorInfo(evenShape, 'float32', evenRealVals);
+    const evenImagInfo = cpuBackend.makeTensorInfo(evenShape, 'float32', evenImagVals);
+    const evenTensorInfo = complex$1({ inputs: { real: evenRealInfo, imag: evenImagInfo }, backend: cpuBackend });
+    const oddComplex = complexWithOddIndex(data);
+    const oddRealVals = oddComplex.real;
+    const oddImagVals = oddComplex.imag;
+    const oddShape = [oddRealVals.length];
+    const oddRealInfo = cpuBackend.makeTensorInfo(oddShape, 'float32', oddRealVals);
+    const oddImagInfo = cpuBackend.makeTensorInfo(oddShape, 'float32', oddImagVals);
+    const oddTensorInfo = complex$1({ inputs: { real: oddRealInfo, imag: oddImagInfo }, backend: cpuBackend });
+    // Recursive call for half part of original input.
+    const $evenComplex = fftRadix2(evenRealVals, evenImagVals, half, inverse, cpuBackend);
+    const $evenRealVals = $evenComplex.real;
+    const $evenImagVals = $evenComplex.imag;
+    const $evenShape = [$evenRealVals.length];
+    const $evenRealInfo = cpuBackend.makeTensorInfo($evenShape, 'float32', $evenRealVals);
+    const $evenImagInfo = cpuBackend.makeTensorInfo($evenShape, 'float32', $evenImagVals);
+    const $evenTensorInfo = complex$1({
+        inputs: { real: $evenRealInfo, imag: $evenImagInfo },
+        backend: cpuBackend
+    });
+    const $oddComplex = fftRadix2(oddRealVals, oddImagVals, half, inverse, cpuBackend);
+    const $oddRealVals = $oddComplex.real;
+    const $oddImagVals = $oddComplex.imag;
+    const $oddShape = [$oddRealVals.length];
+    const $oddRealInfo = cpuBackend.makeTensorInfo($oddShape, 'float32', $oddRealVals);
+    const $oddImagInfo = cpuBackend.makeTensorInfo($oddShape, 'float32', $oddImagVals);
+    const $oddTensorInfo = complex$1({ inputs: { real: $oddRealInfo, imag: $oddImagInfo }, backend: cpuBackend });
+    const e = exponents(size, inverse);
+    const eShape = [e.real.length];
+    const eRealInfo = cpuBackend.makeTensorInfo(eShape, 'float32', e.real);
+    const eImagInfo = cpuBackend.makeTensorInfo(eShape, 'float32', e.imag);
+    const complexInfo = complex$1({ inputs: { real: eRealInfo, imag: eImagInfo }, backend: cpuBackend });
+    const exponentInfo = multiply$1({ inputs: { a: complexInfo, b: $oddTensorInfo }, backend: cpuBackend });
+    const addPart = add({
+        inputs: { a: $evenTensorInfo, b: exponentInfo },
+        backend: cpuBackend
+    });
+    const subPart = sub$1({
+        inputs: { a: $evenTensorInfo, b: exponentInfo },
+        backend: cpuBackend
+    });
+    const addPartReal = real$1({ inputs: { input: addPart }, backend: cpuBackend });
+    const subPartReal = real$1({ inputs: { input: subPart }, backend: cpuBackend });
+    const addPartImag = imag({ inputs: { input: addPart }, backend: cpuBackend });
+    const subPartImag = imag({ inputs: { input: subPart }, backend: cpuBackend });
+    const $real = concat({
+        inputs: [addPartReal, subPartReal],
+        backend: cpuBackend,
+        attrs: { axis: 0 }
+    });
+    const $imag = concat({
+        inputs: [addPartImag, subPartImag],
+        backend: cpuBackend,
+        attrs: { axis: 0 }
+    });
+    const $realVals = cpuBackend.data.get($real.dataId).values;
+    const $imagVals = cpuBackend.data.get($imag.dataId).values;
+    cpuBackend.disposeIntermediateTensorInfo(evenRealInfo);
+    cpuBackend.disposeIntermediateTensorInfo(evenImagInfo);
+    cpuBackend.disposeIntermediateTensorInfo(evenTensorInfo);
+    cpuBackend.disposeIntermediateTensorInfo(oddRealInfo);
+    cpuBackend.disposeIntermediateTensorInfo(oddImagInfo);
+    cpuBackend.disposeIntermediateTensorInfo(oddTensorInfo);
+    cpuBackend.disposeIntermediateTensorInfo($evenRealInfo);
+    cpuBackend.disposeIntermediateTensorInfo($evenImagInfo);
+    cpuBackend.disposeIntermediateTensorInfo($evenTensorInfo);
+    cpuBackend.disposeIntermediateTensorInfo($oddRealInfo);
+    cpuBackend.disposeIntermediateTensorInfo($oddImagInfo);
+    cpuBackend.disposeIntermediateTensorInfo($oddTensorInfo);
+    cpuBackend.disposeIntermediateTensorInfo(eRealInfo);
+    cpuBackend.disposeIntermediateTensorInfo(eImagInfo);
+    cpuBackend.disposeIntermediateTensorInfo(complexInfo);
+    cpuBackend.disposeIntermediateTensorInfo(exponentInfo);
+    cpuBackend.disposeIntermediateTensorInfo(addPart);
+    cpuBackend.disposeIntermediateTensorInfo(subPart);
+    cpuBackend.disposeIntermediateTensorInfo(addPartReal);
+    cpuBackend.disposeIntermediateTensorInfo(addPartImag);
+    cpuBackend.disposeIntermediateTensorInfo(subPartReal);
+    cpuBackend.disposeIntermediateTensorInfo(subPartImag);
+    cpuBackend.disposeIntermediateTensorInfo($real);
+    cpuBackend.disposeIntermediateTensorInfo($imag);
+    return { real: $realVals, imag: $imagVals };
+}
+// Calculate fourier transform by multplying sinusoid matrix.
+function fourierTransformByMatmul(data, size, inverse) {
+    const ret = new Float32Array(size * 2);
+    // TODO: Use matmul instead once it supports complex64 type.
+    for (let r = 0; r < size; r++) {
+        let real = 0.0;
+        let imag = 0.0;
+        for (let c = 0; c < size; c++) {
+            const e = exponent(r * c, size, inverse);
+            const term = getComplexWithIndex(data, c);
+            real += term.real * e.real - term.imag * e.imag;
+            imag += term.real * e.imag + term.imag * e.real;
+        }
+        if (inverse) {
+            real /= size;
+            imag /= size;
+        }
+        assignToTypedArray(ret, real, imag, r);
+    }
+    return ret;
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function fft(args) {
+    const { inputs, backend } = args;
+    const { input } = inputs;
+    const inputSize = sizeFromShape(input.shape);
+    // Collapse all outer dimensions to a single batch dimension.
+    const innerDimensionSize = input.shape[input.shape.length - 1];
+    const batch = inputSize / innerDimensionSize;
+    const input2D = reshape({
+        inputs: { x: input },
+        backend,
+        attrs: { shape: [batch, innerDimensionSize] }
+    });
+    const result = fftBatch(input2D, false, backend);
+    const resultReshaped = reshape({ inputs: { x: result }, backend, attrs: { shape: input.shape } });
+    backend.disposeIntermediateTensorInfo(input2D);
+    backend.disposeIntermediateTensorInfo(result);
+    return resultReshaped;
+}
+const fftConfig = {
+    kernelName: FFT,
+    backendName: 'cpu',
+    kernelFunc: fft
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function fill(args) {
+    const { backend, attrs } = args;
+    const { shape, value, dtype } = attrs;
+    const $dtype = dtype || inferDtype(value);
+    const values = getArrayFromDType($dtype, sizeFromShape(shape));
+    fillValues(values, value, $dtype);
+    return backend.makeTensorInfo(shape, $dtype, values);
+}
+const fillConfig = {
+    kernelName: Fill,
+    backendName: 'cpu',
+    kernelFunc: fill
+};
+function fillValues(values, value, dtype) {
+    if (dtype === 'string') {
+        values.fill(value);
+    }
+    else {
+        values.fill(value);
+    }
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const flipLeftRightConfig = {
+    kernelName: FlipLeftRight,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, attrs, backend }) => {
+        const { image } = inputs;
+        const cpuBackend = backend;
+        const output = getTypedArrayFromDType(image.dtype, sizeFromShape(image.shape));
+        const [batch, imageHeight, imageWidth, numChannels] = image.shape;
+        const imageVals = cpuBackend.data.get(image.dataId).values;
+        for (let batchIdx = 0; batchIdx < batch; batchIdx++) {
+            const batchOffset = batchIdx * imageWidth * imageHeight * numChannels;
+            for (let row = 0; row < imageHeight; row++) {
+                const rowOffset = row * (imageWidth * numChannels);
+                for (let col = 0; col < imageWidth; col++) {
+                    const colOffset = col * numChannels;
+                    for (let channel = 0; channel < numChannels; channel++) {
+                        const coordX = Math.round(imageWidth - col - 1);
+                        const outIdx = batchOffset + rowOffset + colOffset + channel;
+                        let outputValue = imageVals[outIdx];
+                        // If the coordinate position falls within the image boundaries...
+                        if (coordX >= 0 && coordX < imageWidth) {
+                            // set the output to the image value at the coordinate position.
+                            const rotatedColOffset = coordX * numChannels;
+                            const imageIdx = batchOffset + rowOffset + rotatedColOffset + channel;
+                            outputValue = imageVals[imageIdx];
+                        }
+                        output[outIdx] = outputValue;
+                    }
+                }
+            }
+        }
+        const dataId = cpuBackend.write(output, image.shape, image.dtype);
+        return { dataId, shape: image.shape, dtype: image.dtype };
+    }
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function fusedConv2D(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, filter, bias, preluActivationWeights } = inputs;
+    const { strides, pad, dataFormat, dilations, dimRoundingMode, activation, leakyreluAlpha } = attrs;
+    let result = conv2D({
+        inputs: { x, filter },
+        backend,
+        attrs: { strides, pad, dataFormat, dilations, dimRoundingMode }
+    });
+    if (bias) {
+        const resultOld = result;
+        // For NCHW format, if bias is a 1-D tensor, it is supposed to be aligned
+        // to the channel of the conv2d's result; if the bias is a scalar, the
+        // bias_add is computed as if the bias was broadcasted to the shape of the
+        // conv2d's result.
+        if (dataFormat === 'NCHW' && bias.shape.length === 1 &&
+            bias.shape[0] !== 1) {
+            const reshapedBias = reshape({ inputs: { x: bias }, backend, attrs: { shape: [bias.shape[0], 1, 1] } });
+            result =
+                add({ inputs: { a: result, b: reshapedBias }, backend });
+            backend.disposeIntermediateTensorInfo(reshapedBias);
+        }
+        else {
+            // This condition handles NHWC and NCHW (scalar case). The only other case
+            // for NCHW (1D case) is handled above.
+            result = add({ inputs: { a: result, b: bias }, backend });
+        }
+        backend.disposeIntermediateTensorInfo(resultOld);
+    }
+    if (activation) {
+        const resultOld = result;
+        // For NCHW format, if PReLu activation weights is a 1-D tensor, it is
+        // supposed to be aligned with the channel of the conv2d's result. For other
+        // cases, whether NCHW or NHWC data format, the conv2d result is
+        // already aligned with the activation weights.
+        if (dataFormat === 'NCHW' && activation === 'prelu' &&
+            preluActivationWeights.shape.length === 1 &&
+            preluActivationWeights.shape[0] !== 1) {
+            const reshapedAlpha = reshape({
+                inputs: { x: preluActivationWeights },
+                backend,
+                attrs: { shape: [preluActivationWeights.shape[0], 1, 1] }
+            });
+            result = applyActivation(backend, result, activation, reshapedAlpha, leakyreluAlpha);
+            backend.disposeIntermediateTensorInfo(reshapedAlpha);
+        }
+        else {
+            result = applyActivation(backend, result, activation, preluActivationWeights, leakyreluAlpha);
+        }
+        backend.disposeIntermediateTensorInfo(resultOld);
+    }
+    return result;
+}
+const fusedConv2DConfig = {
+    kernelName: FusedConv2D,
+    backendName: 'cpu',
+    kernelFunc: fusedConv2D
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function fusedDepthwiseConv2D(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, filter, bias, preluActivationWeights } = inputs;
+    const { strides, pad, dataFormat, dilations, dimRoundingMode, activation, leakyreluAlpha } = attrs;
+    let result = depthwiseConv2dNative({
+        inputs: { x, filter },
+        backend,
+        attrs: { strides, pad, dataFormat, dilations, dimRoundingMode }
+    });
+    if (bias) {
+        const oldResult = result;
+        result = add({ inputs: { a: result, b: bias }, backend });
+        backend.disposeIntermediateTensorInfo(oldResult);
+    }
+    if (activation) {
+        const oldResult = result;
+        result = applyActivation(backend, result, activation, preluActivationWeights, leakyreluAlpha);
+        backend.disposeIntermediateTensorInfo(oldResult);
+    }
+    return result;
+}
+const fusedDepthwiseConv2DConfig = {
+    kernelName: FusedDepthwiseConv2D,
+    backendName: 'cpu',
+    kernelFunc: fusedDepthwiseConv2D
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function gatherNd(args) {
+    const { inputs, backend } = args;
+    const { params, indices } = inputs;
+    const paramsSize = sizeFromShape(params.shape);
+    const indicesShape = indices.shape;
+    const sliceRank = indicesShape[indicesShape.length - 1];
+    const [resultShape, numSlices, sliceSize, strides] = prepareAndValidate(params, indices);
+    if (numSlices === 0) {
+        return backend.makeTensorInfo(resultShape, params.dtype, []);
+    }
+    const indicesData = backend.data.get(indices.dataId).values;
+    const paramsBuf = backend.bufferSync(params);
+    const outBuf = gatherNdImpl(indicesData, paramsBuf, params.dtype, numSlices, sliceRank, sliceSize, strides, params.shape, paramsSize);
+    return backend.makeTensorInfo(resultShape, params.dtype, outBuf.values);
+}
+const gatherNdConfig = {
+    kernelName: GatherNd,
+    backendName: 'cpu',
+    kernelFunc: gatherNd
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function gatherV2(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, indices } = inputs;
+    const { axis, batchDims } = attrs;
+    assertNotComplex([x, indices], 'gatherV2');
+    // Throw error when any index is out of bound.
+    const parsedAxis = parseAxisParam(axis, x.shape)[0];
+    const indicesVals = backend.data.get(indices.dataId).values;
+    const axisDim = x.shape[parsedAxis];
+    for (let i = 0; i < indicesVals.length; ++i) {
+        const index = indicesVals[i];
+        assert$1(index <= axisDim - 1 && index >= 0, () => `GatherV2: the index value ${index} is not in [0, ${axisDim - 1}]`);
+    }
+    let $batchDims = batchDims;
+    if (batchDims == null) {
+        $batchDims = 0;
+    }
+    const indicesSize = sizeFromShape(indices.shape);
+    const shapeInfo = collectGatherOpShapeInfo(x, indices, parsedAxis, $batchDims);
+    const flattenX = reshape({
+        inputs: { x },
+        backend,
+        attrs: {
+            shape: [
+                shapeInfo.batchSize, shapeInfo.outerSize, shapeInfo.dimSize,
+                shapeInfo.sliceSize
+            ]
+        }
+    });
+    const flattenIndex = reshape({
+        inputs: { x: indices },
+        backend,
+        attrs: { shape: [shapeInfo.batchSize, indicesSize / shapeInfo.batchSize] }
+    });
+    const flattenOutputShape = [
+        shapeInfo.batchSize, shapeInfo.outerSize, indicesSize / shapeInfo.batchSize,
+        shapeInfo.sliceSize
+    ];
+    const indicesBuf = backend.bufferSync(flattenIndex);
+    const xBuf = backend.bufferSync(flattenX);
+    const outBuf = gatherV2Impl(xBuf, indicesBuf, flattenOutputShape);
+    backend.disposeIntermediateTensorInfo(flattenX);
+    backend.disposeIntermediateTensorInfo(flattenIndex);
+    return backend.makeTensorInfo(shapeInfo.outputShape, outBuf.dtype, outBuf.values);
+}
+const gatherV2Config = {
+    kernelName: GatherV2,
+    backendName: 'cpu',
+    kernelFunc: gatherV2
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function ifft(args) {
+    const { inputs, backend } = args;
+    const { input } = inputs;
+    const inputSize = sizeFromShape(input.shape);
+    // Collapse all outer dimensions to a single batch dimension.
+    const innerDimensionSize = input.shape[input.shape.length - 1];
+    const batch = inputSize / innerDimensionSize;
+    const input2D = reshape({
+        inputs: { x: input },
+        backend,
+        attrs: { shape: [batch, innerDimensionSize] }
+    });
+    const result = fftBatch(input2D, true, backend);
+    const resultReshaped = reshape({ inputs: { x: result }, backend, attrs: { shape: input.shape } });
+    backend.disposeIntermediateTensorInfo(input2D);
+    backend.disposeIntermediateTensorInfo(result);
+    return resultReshaped;
+}
+const ifftConfig = {
+    kernelName: IFFT,
+    backendName: 'cpu',
+    kernelFunc: ifft
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const isFinite$1 = unaryKernelFunc$1(IsFinite, (xi) => Number.isFinite(xi) ? 1 : 0, 'bool');
+const isFiniteConfig = {
+    kernelName: IsFinite,
+    backendName: 'cpu',
+    kernelFunc: isFinite$1,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const isInf = unaryKernelFunc$1(IsInf, (xi) => Math.abs(xi) === Infinity ? 1 : 0, 'bool');
+const isInfConfig = {
+    kernelName: IsInf,
+    backendName: 'cpu',
+    kernelFunc: isInf,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const isNaN$1 = unaryKernelFunc$1(IsNan, (xi) => Number.isNaN(xi) ? 1 : 0, 'bool');
+const isNaNConfig = {
+    kernelName: IsNan,
+    backendName: 'cpu',
+    kernelFunc: isNaN$1,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function linSpace(args) {
+    const { backend, attrs } = args;
+    const { start, stop, num } = attrs;
+    const outVals = linSpaceImpl(start, stop, num);
+    return backend.makeTensorInfo([outVals.length], 'float32', outVals);
+}
+const linSpaceConfig = {
+    kernelName: LinSpace,
+    backendName: 'cpu',
+    kernelFunc: linSpace
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const log1p = unaryKernelFunc$1(Log1p, (xi) => Math.log1p(xi));
+const log1pConfig = {
+    kernelName: Log1p,
+    backendName: 'cpu',
+    kernelFunc: log1p,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const logicalAndImpl = createSimpleBinaryKernelImpl((a, b) => a && b);
+const logicalAnd = binaryKernelFunc$1(LogicalAnd, logicalAndImpl, null /* complexImpl */, 'bool');
+const logicalAndConfig = {
+    kernelName: LogicalAnd,
+    backendName: 'cpu',
+    kernelFunc: logicalAnd
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const logicalNot = unaryKernelFunc$1(LogicalNot, (xi) => xi ? 0 : 1, 'bool');
+const logicalNotConfig = {
+    kernelName: LogicalNot,
+    backendName: 'cpu',
+    kernelFunc: logicalNot,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const logicalOrImpl = createSimpleBinaryKernelImpl((a, b) => a || b);
+const logicalOr = binaryKernelFunc$1(LogicalOr, logicalOrImpl, null /* complexImpl */, 'bool');
+const logicalOrConfig = {
+    kernelName: LogicalOr,
+    backendName: 'cpu',
+    kernelFunc: logicalOr
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function lRN(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { depthRadius, bias, alpha, beta } = attrs;
+    assertNotComplex(x, 'LRN');
+    const channels = x.shape[3];
+    const maxD = channels - 1;
+    const xValues = backend.data.get(x.dataId).values;
+    const size = sizeFromShape(x.shape);
+    const result = new Float32Array(size);
+    function sumAcrossChannels(offset) {
+        const currentChannel = offset % channels;
+        let beginSumOffset = offset - currentChannel + Math.max(0, currentChannel - depthRadius);
+        const endSumOffset = offset - currentChannel + Math.min(currentChannel + depthRadius, maxD);
+        let sum = 0.0;
+        for (; beginSumOffset <= endSumOffset; beginSumOffset++) {
+            const z = xValues[beginSumOffset];
+            sum += z * z;
+        }
+        return sum;
+    }
+    for (let offset = 0; offset < size; offset++) {
+        const sum = sumAcrossChannels(offset);
+        const val = xValues[offset] * Math.pow(bias + alpha * sum, -beta);
+        result[offset] = val;
+    }
+    return backend.makeTensorInfo(x.shape, x.dtype, result);
+}
+// tslint:disable-next-line: variable-name
+const LRNConfig = {
+    kernelName: LRN,
+    backendName: 'cpu',
+    kernelFunc: lRN
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function lRNGrad(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, y, dy } = inputs;
+    const { depthRadius, bias, alpha, beta } = attrs;
+    assertNotComplex(dy, 'LRNGrad');
+    const dySize = sizeFromShape(dy.shape);
+    const channels = dy.shape[3];
+    const dyValues = backend.data.get(dy.dataId).values;
+    const xValues = backend.data.get(x.dataId).values;
+    const yValues = backend.data.get(y.dataId).values;
+    const result = new Float32Array(dySize);
+    const size = dySize;
+    for (let offset = 0; offset < size; offset++) {
+        const currentChannel = offset % channels;
+        const depthBegin = (offset - currentChannel) + Math.max(0, currentChannel - depthRadius);
+        const depthEnd = (offset - currentChannel) +
+            Math.min(channels, currentChannel + depthRadius + 1);
+        let norm = 0;
+        for (let k = depthBegin; k < depthEnd; k++) {
+            norm += Math.pow(xValues[k], 2);
+        }
+        norm = alpha * norm + bias;
+        for (let k = depthBegin; k < depthEnd; k++) {
+            let dyi = -2 * alpha * beta * xValues[k] * yValues[offset] / norm;
+            if (offset === k) {
+                dyi += Math.pow(norm, -beta);
+            }
+            dyi *= dyValues[offset];
+            result[k] += dyi;
+        }
+    }
+    return backend.makeTensorInfo(dy.shape, x.dtype, result);
+}
+// tslint:disable-next-line: variable-name
+const LRNGradConfig = {
+    kernelName: LRNGrad,
+    backendName: 'cpu',
+    kernelFunc: lRNGrad
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function max(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { reductionIndices, keepDims } = attrs;
+    const cpuBackend = backend;
+    let xShape = x.shape;
+    const xRank = xShape.length;
+    const origAxes = parseAxisParam(reductionIndices, xShape);
+    let axes = origAxes;
+    const permutedAxes = getAxesPermutation(axes, xRank);
+    let xVals = cpuBackend.data.get(x.dataId).values;
+    if (permutedAxes != null) {
+        const newShape = new Array(xRank);
+        for (let i = 0; i < newShape.length; i++) {
+            newShape[i] = xShape[permutedAxes[i]];
+        }
+        xVals = transposeImpl$1(xVals, xShape, x.dtype, permutedAxes, newShape);
+        axes = getInnerMostAxes(axes.length, xRank);
+        xShape = newShape;
+    }
+    assertNotComplex(x, 'max');
+    assertAxesAreInnerMostDims('max', axes, xRank);
+    const [maxOutShape, reduceShape] = computeOutAndReduceShapes(xShape, axes);
+    const reduceSize = sizeFromShape(reduceShape);
+    const result = maxImpl$1(xVals, reduceSize, maxOutShape, x.dtype);
+    const dataId = cpuBackend.write(result, maxOutShape, x.dtype);
+    let outShape = maxOutShape;
+    if (keepDims) {
+        // reshape
+        const newShape = expandShapeToKeepDim(maxOutShape, origAxes);
+        outShape = newShape;
+    }
+    return { dataId, shape: outShape, dtype: x.dtype };
+}
+const maxConfig = {
+    kernelName: Max,
+    backendName: 'cpu',
+    kernelFunc: max
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function maxPool(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    assertNotComplex(x, 'maxPool');
+    const { filterSize, strides, pad, dimRoundingMode } = attrs;
+    const dilations = 1;
+    assert$1(eitherStridesOrDilationsAreOne(strides, dilations), () => 'Error in maxPool: Either strides or dilations must be 1. ' +
+        `Got strides ${strides} and dilations '${dilations}'`);
+    const convInfo = computePool2DInfo(x.shape, filterSize, strides, dilations, pad, dimRoundingMode);
+    let res;
+    if (convInfo.filterWidth === 1 && convInfo.filterHeight === 1 &&
+        arraysEqual(convInfo.inShape, convInfo.outShape)) {
+        res = identity$1({ inputs: { x }, backend });
+    }
+    else {
+        const xValues = backend.data.get(x.dataId).values;
+        const strides = computeStrides(x.shape);
+        const buffer = pool(xValues, x.shape, x.dtype, strides, convInfo, 'max');
+        res = backend.makeTensorInfo(convInfo.outShape, x.dtype, buffer.values);
+    }
+    return res;
+}
+const maxPoolConfig = {
+    kernelName: MaxPool,
+    backendName: 'cpu',
+    kernelFunc: maxPool
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function maxPool3D(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { filterSize, strides, pad, dimRoundingMode, dataFormat } = attrs;
+    assertNotComplex(x, 'maxPool3d');
+    const convInfo = computePool3DInfo(x.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode, dataFormat);
+    const xValues = backend.data.get(x.dataId).values;
+    const outBuf = pool3d(xValues, x.shape, x.dtype, computeStrides(x.shape), convInfo, 'max');
+    return backend.makeTensorInfo(outBuf.shape, 'float32', outBuf.values);
+}
+const maxPool3DConfig = {
+    kernelName: MaxPool3D,
+    backendName: 'cpu',
+    kernelFunc: maxPool3D
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function maxPool3DGrad(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, input } = inputs;
+    const { filterSize, strides, pad, dimRoundingMode } = attrs;
+    assertNotComplex([dy, input], 'maxPool3DGrad');
+    const convInfo = computePool3DInfo(input.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode);
+    const inputBuf = backend.bufferSync(input);
+    const maxPosBuf = maxPool3dPositions(inputBuf, convInfo);
+    const strideDepth = convInfo.strideDepth;
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const dilationDepth = convInfo.dilationDepth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterDepth = convInfo.effectiveFilterDepth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padFront = effectiveFilterDepth - 1 - convInfo.padInfo.front;
+    const padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
+    const padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
+    const dx = buffer(input.shape, 'float32');
+    const dyBuf = backend.bufferSync(dy);
+    for (let batch = 0; batch < convInfo.batchSize; ++batch) {
+        for (let channel = 0; channel < convInfo.inChannels; ++channel) {
+            for (let dxDepth = 0; dxDepth < convInfo.inDepth; ++dxDepth) {
+                for (let dxRow = 0; dxRow < convInfo.inHeight; ++dxRow) {
+                    for (let dxCol = 0; dxCol < convInfo.inWidth; ++dxCol) {
+                        // Shader code begins
+                        const dyDepthCorner = dxDepth - padFront;
+                        const dyRowCorner = dxRow - padTop;
+                        const dyColCorner = dxCol - padLeft;
+                        let dotProd = 0;
+                        for (let wDepth = 0; wDepth < effectiveFilterDepth; wDepth += dilationDepth) {
+                            const dyDepth = (dyDepthCorner + wDepth) / strideDepth;
+                            if (dyDepth < 0 || dyDepth >= convInfo.outDepth ||
+                                Math.floor(dyDepth) !== dyDepth) {
+                                continue;
+                            }
+                            for (let wRow = 0; wRow < effectiveFilterHeight; wRow += dilationHeight) {
+                                const dyRow = (dyRowCorner + wRow) / strideHeight;
+                                if (dyRow < 0 || dyRow >= convInfo.outHeight ||
+                                    Math.floor(dyRow) !== dyRow) {
+                                    continue;
+                                }
+                                for (let wCol = 0; wCol < effectiveFilterWidth; wCol += dilationWidth) {
+                                    const dyCol = (dyColCorner + wCol) / strideWidth;
+                                    if (dyCol < 0 || dyCol >= convInfo.outWidth ||
+                                        Math.floor(dyCol) !== dyCol) {
+                                        continue;
+                                    }
+                                    const maxPos = effectiveFilterDepth * effectiveFilterHeight *
+                                        effectiveFilterWidth -
+                                        1 -
+                                        maxPosBuf.get(batch, dyDepth, dyRow, dyCol, channel);
+                                    const curPos = wDepth * effectiveFilterHeight * effectiveFilterWidth +
+                                        wRow * effectiveFilterWidth + wCol;
+                                    const mask = maxPos === curPos ? 1 : 0;
+                                    if (mask === 0) {
+                                        continue;
+                                    }
+                                    const pixel = dyBuf.get(batch, dyDepth, dyRow, dyCol, channel);
+                                    dotProd += pixel * mask;
+                                }
+                            }
+                        }
+                        dx.set(dotProd, batch, dxDepth, dxRow, dxCol, channel);
+                    }
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const maxPool3DGradConfig$1 = {
+    kernelName: MaxPool3DGrad,
+    backendName: 'cpu',
+    kernelFunc: maxPool3DGrad
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function maxPoolGrad$1(args) {
+    const { inputs, backend, attrs } = args;
+    const { dy, input, output } = inputs;
+    const x = input;
+    assertNotComplex([input, output], 'maxPoolGrad');
+    const { filterSize, strides, pad, dimRoundingMode } = attrs;
+    const convInfo = computePool2DInfo(x.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode);
+    const xValues = backend.data.get(x.dataId).values;
+    const maxPosBuf = buffer(convInfo.outShape, x.dtype, maxPoolPositions(xValues, x.shape, x.dtype, convInfo).values);
+    const strideHeight = convInfo.strideHeight;
+    const strideWidth = convInfo.strideWidth;
+    const dilationHeight = convInfo.dilationHeight;
+    const dilationWidth = convInfo.dilationWidth;
+    const effectiveFilterHeight = convInfo.effectiveFilterHeight;
+    const effectiveFilterWidth = convInfo.effectiveFilterWidth;
+    const padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
+    const padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
+    const dx = buffer(x.shape, 'float32');
+    const dyData = backend.data.get(dy.dataId).values;
+    const dyBuf = buffer(dy.shape, 'float32', dyData);
+    for (let b = 0; b < convInfo.batchSize; ++b) {
+        for (let d = 0; d < convInfo.inChannels; ++d) {
+            for (let dxR = 0; dxR < convInfo.inHeight; ++dxR) {
+                for (let dxC = 0; dxC < convInfo.inWidth; ++dxC) {
+                    // Shader code begins.
+                    const dyRCorner = dxR - padTop;
+                    const dyCCorner = dxC - padLeft;
+                    let dotProd = 0;
+                    for (let wR = 0; wR < effectiveFilterHeight; wR += dilationHeight) {
+                        const dyR = (dyRCorner + wR) / strideHeight;
+                        if (dyR < 0 || dyR >= convInfo.outHeight ||
+                            Math.floor(dyR) !== dyR) {
+                            continue;
+                        }
+                        for (let wC = 0; wC < effectiveFilterWidth; wC += dilationWidth) {
+                            const dyC = (dyCCorner + wC) / strideWidth;
+                            if (dyC < 0 || dyC >= convInfo.outWidth ||
+                                Math.floor(dyC) !== dyC) {
+                                continue;
+                            }
+                            const maxPos = effectiveFilterHeight * effectiveFilterWidth - 1 -
+                                maxPosBuf.get(b, dyR, dyC, d);
+                            const curPos = wR * effectiveFilterWidth + wC;
+                            const mask = maxPos === curPos ? 1 : 0;
+                            if (mask === 0) {
+                                continue;
+                            }
+                            const pixel = dyBuf.get(b, dyR, dyC, d);
+                            dotProd += pixel * mask;
+                        }
+                    }
+                    dx.set(dotProd, b, dxR, dxC, d);
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
+}
+const maxPoolGradConfig$1 = {
+    kernelName: MaxPoolGrad,
+    backendName: 'cpu',
+    kernelFunc: maxPoolGrad$1
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function maxPoolWithArgmaxImpl(xValues, xShape, dtype, includeBatchInIndex, convInfo) {
+    const strides = computeStrides(xShape);
+    const maxPools = pool(xValues, xShape, dtype, strides, convInfo, 'max');
+    const maxPositions = maxPoolPositions(xValues, xShape, dtype, convInfo, true, includeBatchInIndex);
+    return [maxPools.values, maxPositions.values];
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const maxPoolWithArgmaxConfig = {
+    kernelName: MaxPoolWithArgmax,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, attrs, backend }) => {
+        const { x } = inputs;
+        const { filterSize, strides, pad, includeBatchInIndex } = attrs;
+        const cpuBackend = backend;
+        assertNotComplex(x, 'MaxPoolWithArgmax');
+        const values = cpuBackend.data.get(x.dataId).values;
+        const convInfo = computePool2DInfo(x.shape, filterSize, strides, [1, 1], pad);
+        const [pooled, indexes] = maxPoolWithArgmaxImpl(values, x.shape, x.dtype, includeBatchInIndex, convInfo);
+        const pooledDataId = cpuBackend.write(pooled, convInfo.outShape, x.dtype);
+        const indexesDataId = cpuBackend.write(indexes, convInfo.outShape, x.dtype);
+        return [
+            { dataId: pooledDataId, shape: convInfo.outShape, dtype: x.dtype },
+            { dataId: indexesDataId, shape: convInfo.outShape, dtype: 'int32' }
+        ];
+    }
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function mean(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, keepDims } = attrs;
+    const axes = parseAxisParam(axis, x.shape);
+    const shapes = computeOutAndReduceShapes(x.shape, axes);
+    const reduceShape = shapes[1];
+    const reduceSize = sizeFromShape(reduceShape);
+    const toDispose = [];
+    const reduceSizeScalar = backend.makeTensorInfo([], 'float32', new Float32Array([reduceSize]));
+    toDispose.push(reduceSizeScalar);
+    const $x = cast$2({ inputs: { x }, backend, attrs: { dtype: 'float32' } });
+    toDispose.push($x);
+    const res = div({ inputs: { a: $x, b: reduceSizeScalar }, backend });
+    toDispose.push(res);
+    const result = sum({ inputs: { x: res }, backend, attrs: { axis, keepDims } });
+    toDispose.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return result;
+}
+const meanConfig = {
+    kernelName: Mean,
+    backendName: 'cpu',
+    kernelFunc: mean
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function min(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { axis, keepDims } = attrs;
+    assertNotComplex(x, 'min');
+    const origAxes = parseAxisParam(axis, x.shape);
+    let axes = origAxes;
+    const permutedAxes = getAxesPermutation(axes, x.shape.length);
+    let $x = x;
+    if (permutedAxes != null) {
+        $x = transpose$1({ inputs: { x }, backend, attrs: { perm: permutedAxes } });
+        axes = getInnerMostAxes(axes.length, x.shape.length);
+    }
+    assertAxesAreInnerMostDims('min', axes, $x.shape.length);
+    const [outShape, reduceShape] = computeOutAndReduceShapes($x.shape, axes);
+    const reduceSize = sizeFromShape(reduceShape);
+    const vals = makeZerosTypedArray(sizeFromShape(outShape), $x.dtype);
+    const aVals = backend.data.get($x.dataId).values;
+    for (let i = 0; i < vals.length; ++i) {
+        const offset = i * reduceSize;
+        let min = aVals[offset];
+        for (let j = 0; j < reduceSize; ++j) {
+            const value = aVals[offset + j];
+            if (Number.isNaN(value) ||
+                value < min) { // comparison with NaN always return false
+                min = value;
+            }
+        }
+        vals[i] = min;
+    }
+    if (permutedAxes != null) {
+        backend.disposeIntermediateTensorInfo($x);
+    }
+    const result = backend.makeTensorInfo(outShape, $x.dtype, vals);
+    if (keepDims) {
+        const expandedShape = expandShapeToKeepDim(outShape, origAxes);
+        const reshapedResult = reshape({ inputs: { x: result }, backend, attrs: { shape: expandedShape } });
+        backend.disposeIntermediateTensorInfo(result);
+        return reshapedResult;
+    }
+    return result;
+}
+const minConfig = {
+    kernelName: Min,
+    backendName: 'cpu',
+    kernelFunc: min
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function mirrorPad(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { paddings, mode } = attrs;
+    assertNotComplex(x, 'mirrorPad');
+    const outShape = paddings.map((p, i) => p[0] /* beforePad */ + x.shape[i] + p[1] /* afterPad */);
+    const start = paddings.map(p => p[0]);
+    const end = paddings.map((p, i) => p[0] + x.shape[i]);
+    const offset = mode === 'reflect' ? 0 : 1;
+    const xVals = backend.data.get(x.dataId).values;
+    const xRank = x.shape.length;
+    const xStrides = computeStrides(x.shape);
+    const resultSize = sizeFromShape(outShape);
+    const resultRank = outShape.length;
+    const resultStrides = computeStrides(outShape);
+    const resVals = getTypedArrayFromDType(x.dtype, resultSize);
+    for (let i = 0; i < resultSize; i++) {
+        let coords = indexToLoc(i, resultRank, resultStrides);
+        for (let i = 0; i < resultRank; i++) {
+            if (coords[i] < start[i]) {
+                coords[i] = start[i] * 2 - coords[i] - offset;
+            }
+            else if (coords[i] >= end[i]) {
+                coords[i] = (end[i] - 1) * 2 - coords[i] + offset;
+            }
+        }
+        coords = coords.map((c, i) => c - start[i]);
+        const inIndex = locToIndex(coords, xRank, xStrides);
+        resVals[i] = xVals[inIndex];
+    }
+    const outId = backend.write(resVals, outShape, x.dtype);
+    return { dataId: outId, shape: outShape, dtype: x.dtype };
+}
+const mirrorPadConfig = {
+    kernelName: MirrorPad,
+    backendName: 'cpu',
+    kernelFunc: mirrorPad
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const modImpl = createSimpleBinaryKernelImpl(((aValue, bValue) => {
+    const rem = aValue % bValue;
+    if ((aValue < 0 && bValue < 0) || (aValue >= 0 && bValue >= 0)) {
+        return rem;
+    }
+    else {
+        return (rem + bValue) % bValue;
+    }
+}));
+const mod = binaryKernelFunc$1(Mod, modImpl);
+const modConfig = {
+    kernelName: Mod,
+    backendName: 'cpu',
+    kernelFunc: mod
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function softmax(args) {
+    const { inputs, backend, attrs } = args;
+    const { logits } = inputs;
+    const { dim } = attrs;
+    const logitsRank = logits.shape.length;
+    let $dim = dim;
+    if ($dim === -1) {
+        $dim = logitsRank - 1;
+    }
+    if ($dim !== logitsRank - 1) {
+        throw Error('Softmax along a non-last dimension is not yet supported. ' +
+            `Logits was rank ${logitsRank} and dim was ${$dim}`);
+    }
+    const axes = parseAxisParam([$dim], logits.shape);
+    const maxLogit = max({
+        inputs: { x: logits },
+        backend,
+        attrs: { reductionIndices: axes, keepDims: false }
+    });
+    const expandedShape = expandShapeToKeepDim(maxLogit.shape, axes);
+    const maxLogitReshaped = reshape({ inputs: { x: maxLogit }, backend, attrs: { shape: expandedShape } });
+    const a = sub$1({ inputs: { a: logits, b: maxLogitReshaped }, backend });
+    const b = exp$1({ inputs: { x: a }, backend });
+    const sumExp = sum({ inputs: { x: b }, backend, attrs: { axis: axes, keepDims: false } });
+    const sumReshaped = reshape({ inputs: { x: sumExp }, backend, attrs: { shape: expandedShape } });
+    const result = div({ inputs: { a: b, b: sumReshaped }, backend });
+    backend.disposeIntermediateTensorInfo(maxLogit);
+    backend.disposeIntermediateTensorInfo(maxLogitReshaped);
+    backend.disposeIntermediateTensorInfo(a);
+    backend.disposeIntermediateTensorInfo(b);
+    backend.disposeIntermediateTensorInfo(sumExp);
+    backend.disposeIntermediateTensorInfo(sumReshaped);
+    return result;
+}
+const softmaxConfig = {
+    kernelName: Softmax$1,
+    backendName: 'cpu',
+    kernelFunc: softmax
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function multinomial(args) {
+    const { inputs, backend, attrs } = args;
+    const { logits } = inputs;
+    const { numSamples, seed, normalized } = attrs;
+    assertNotComplex(logits, 'multinomial');
+    const probabilities = normalized ?
+        logits :
+        softmax({ inputs: { logits }, backend, attrs: { dim: -1 } });
+    const batchSize = probabilities.shape[0];
+    const numEvents = probabilities.shape[1];
+    const probVals = backend.data.get(probabilities.dataId).values;
+    const resShape = [batchSize, numSamples];
+    const resVals = makeZerosTypedArray(sizeFromShape(resShape), 'int32');
+    for (let b = 0; b < batchSize; ++b) {
+        const offset = b * numEvents;
+        // The cdf won't include the last event. It will be implicit if no other
+        // event happened.
+        const cdf = new Float32Array(numEvents - 1);
+        cdf[0] = probVals[offset];
+        for (let event = 1; event < cdf.length; ++event) {
+            cdf[event] = cdf[event - 1] + probVals[offset + event];
+        }
+        const random = seedrandom.alea(seed.toString());
+        const outOffset = b * numSamples;
+        for (let sampleId = 0; sampleId < numSamples; ++sampleId) {
+            const r = random();
+            // Assume last event happened by default.
+            resVals[outOffset + sampleId] = cdf.length;
+            for (let event = 0; event < cdf.length; event++) {
+                if (r < cdf[event]) {
+                    resVals[outOffset + sampleId] = event;
+                    break;
+                }
+            }
+        }
+    }
+    if (!normalized) {
+        backend.disposeIntermediateTensorInfo(probabilities);
+    }
+    return backend.makeTensorInfo(resShape, 'int32', resVals);
+}
+const multinomialConfig = {
+    kernelName: Multinomial,
+    backendName: 'cpu',
+    kernelFunc: multinomial
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const nonMaxSuppressionV3Impl = nonMaxSuppressionV3Impl$2;
+function nonMaxSuppressionV3(args) {
+    const { inputs, backend, attrs } = args;
+    const { boxes, scores } = inputs;
+    const { maxOutputSize, iouThreshold, scoreThreshold } = attrs;
+    assertNotComplex(boxes, 'NonMaxSuppression');
+    const boxesVals = backend.data.get(boxes.dataId).values;
+    const scoresVals = backend.data.get(scores.dataId).values;
+    const { selectedIndices } = nonMaxSuppressionV3Impl(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold);
+    return backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices));
+}
+const nonMaxSuppressionV3Config = {
+    kernelName: NonMaxSuppressionV3,
+    backendName: 'cpu',
+    kernelFunc: nonMaxSuppressionV3
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const nonMaxSuppressionV4Impl = nonMaxSuppressionV4Impl$2;
+function nonMaxSuppressionV4(args) {
+    const { inputs, backend, attrs } = args;
+    const { boxes, scores } = inputs;
+    const { maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize } = attrs;
+    assertNotComplex(boxes, 'NonMaxSuppressionPadded');
+    const boxesVals = backend.data.get(boxes.dataId).values;
+    const scoresVals = backend.data.get(scores.dataId).values;
+    const { selectedIndices, validOutputs } = nonMaxSuppressionV4Impl(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize);
+    return [
+        backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices)),
+        backend.makeTensorInfo([], 'int32', new Int32Array([validOutputs]))
+    ];
+}
+const nonMaxSuppressionV4Config = {
+    kernelName: NonMaxSuppressionV4,
+    backendName: 'cpu',
+    kernelFunc: nonMaxSuppressionV4
+};
+
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const nonMaxSuppressionV5Impl = nonMaxSuppressionV5Impl$2;
+function nonMaxSuppressionV5(args) {
+    const { inputs, backend, attrs } = args;
+    const { boxes, scores } = inputs;
+    const { maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma } = attrs;
+    assertNotComplex(boxes, 'NonMaxSuppressionWithScore');
+    const boxesVals = backend.data.get(boxes.dataId).values;
+    const scoresVals = backend.data.get(scores.dataId).values;
+    const maxOutputSizeVal = maxOutputSize;
+    const iouThresholdVal = iouThreshold;
+    const scoreThresholdVal = scoreThreshold;
+    const softNmsSigmaVal = softNmsSigma;
+    const { selectedIndices, selectedScores } = nonMaxSuppressionV5Impl(boxesVals, scoresVals, maxOutputSizeVal, iouThresholdVal, scoreThresholdVal, softNmsSigmaVal);
+    return [
+        backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices)),
+        backend.makeTensorInfo([selectedScores.length], 'float32', new Float32Array(selectedScores))
+    ];
+}
+const nonMaxSuppressionV5Config = {
+    kernelName: NonMaxSuppressionV5,
+    backendName: 'cpu',
+    kernelFunc: nonMaxSuppressionV5
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function oneHot(args) {
+    const { inputs, backend, attrs } = args;
+    const { indices } = inputs;
+    const { dtype, depth, onValue, offValue } = attrs;
+    assertNotComplex(indices, 'oneHot');
+    const indicesSize = sizeFromShape(indices.shape);
+    const res = new Float32Array(indicesSize * depth);
+    res.fill(offValue);
+    const indicesVal = backend.data.get(indices.dataId).values;
+    for (let event = 0; event < indicesSize; ++event) {
+        if (indicesVal[event] >= 0 && indicesVal[event] < depth) {
+            res[event * depth + indicesVal[event]] = onValue;
+        }
+    }
+    return backend.makeTensorInfo([...indices.shape, depth], dtype, res);
+}
+const oneHotConfig = {
+    kernelName: OneHot,
+    backendName: 'cpu',
+    kernelFunc: oneHot
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function zerosLike(args) {
+    const { inputs, backend } = args;
+    const { x } = inputs;
+    if (x.dtype === 'string') {
+        throw new Error('zerosLike is not supported for string tensors');
+    }
+    else if (x.dtype === 'complex64') {
+        const realPart = real$1({ inputs: { input: x }, backend });
+        const r = zerosLike({ inputs: { x: realPart }, backend });
+        const imagPart = imag({ inputs: { input: x }, backend });
+        const i = zerosLike({ inputs: { x: imagPart }, backend });
+        const result = complex$1({ inputs: { real: r, imag: i }, backend });
+        backend.disposeIntermediateTensorInfo(realPart);
+        backend.disposeIntermediateTensorInfo(r);
+        backend.disposeIntermediateTensorInfo(imagPart);
+        backend.disposeIntermediateTensorInfo(i);
+        return result;
+    }
+    else {
+        return fill({ backend, attrs: { shape: x.shape, value: 0, dtype: x.dtype } });
+    }
+}
+const zerosLikeConfig = {
+    kernelName: ZerosLike,
+    backendName: 'cpu',
+    kernelFunc: zerosLike
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function onesLike(args) {
+    const { inputs, backend } = args;
+    const { x } = inputs;
+    if (x.dtype === 'string') {
+        throw new Error('onesLike is not supported for string tensors');
+    }
+    else if (x.dtype === 'complex64') {
+        const realPart = real$1({ inputs: { input: x }, backend });
+        const r = onesLike({ inputs: { x: realPart }, backend });
+        const imagPart = imag({ inputs: { input: x }, backend });
+        const i = zerosLike({ inputs: { x: imagPart }, backend });
+        const result = complex$1({ inputs: { real: r, imag: i }, backend });
+        backend.disposeIntermediateTensorInfo(realPart);
+        backend.disposeIntermediateTensorInfo(r);
+        backend.disposeIntermediateTensorInfo(imagPart);
+        backend.disposeIntermediateTensorInfo(i);
+        return result;
+    }
+    else {
+        return fill({ backend, attrs: { shape: x.shape, value: 1, dtype: x.dtype } });
+    }
+}
+const onesLikeConfig = {
+    kernelName: OnesLike,
+    backendName: 'cpu',
+    kernelFunc: onesLike
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function pack(args) {
+    const { inputs, backend, attrs } = args;
+    const { axis } = attrs;
+    if (inputs.length === 1) {
+        return expandDims$1({ inputs: { input: inputs[0] }, backend, attrs: { dim: axis } });
+    }
+    const shape = inputs[0].shape;
+    const dtype = inputs[0].dtype;
+    inputs.forEach(t => {
+        assertShapesMatch(shape, t.shape, 'All tensors passed to stack must have matching shapes');
+        assert$1(dtype === t.dtype, () => 'All tensors passed to stack must have matching dtypes');
+    });
+    const intermediateTensorInfos = [];
+    const expandedTensors = inputs.map(t => {
+        const expandedT = expandDims$1({ inputs: { input: t }, backend, attrs: { dim: axis } });
+        intermediateTensorInfos.push(expandedT);
+        return expandedT;
+    });
+    const result = concat({ inputs: expandedTensors, backend, attrs: { axis } });
+    intermediateTensorInfos.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return result;
+}
+const packConfig = {
+    kernelName: Pack,
+    backendName: 'cpu',
+    kernelFunc: pack
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function padV2(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { paddings, constantValue } = attrs;
+    assertNotComplex(x, 'pad');
+    const outShape = paddings.map((p, i) => p[0] /* beforePad */ + x.shape[i] + p[1] /* afterPad */);
+    const start = paddings.map(p => p[0]);
+    const xVals = backend.data.get(x.dataId).values;
+    const xSize = sizeFromShape(x.shape);
+    const xRank = x.shape.length;
+    const xStrides = computeStrides(x.shape);
+    const resultSize = sizeFromShape(outShape);
+    const resultRank = outShape.length;
+    const resultStrides = computeStrides(outShape);
+    const resVals = getTypedArrayFromDType(x.dtype, resultSize);
+    if (constantValue !== 0) {
+        resVals.fill(constantValue);
+    }
+    for (let i = 0; i < xSize; i++) {
+        const coords = indexToLoc(i, xRank, xStrides);
+        const outCoords = coords.map((c, i) => c + start[i]);
+        const outIndex = locToIndex(outCoords, resultRank, resultStrides);
+        resVals[outIndex] = xVals[i];
+    }
+    const outId = backend.write(resVals, outShape, x.dtype);
+    return { dataId: outId, shape: outShape, dtype: x.dtype };
+}
+const padV2Config = {
+    kernelName: PadV2,
+    backendName: 'cpu',
+    kernelFunc: padV2
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const powImpl = createSimpleBinaryKernelImpl((a, b) => Math.pow(a, b));
+const pow = binaryKernelFunc$1(Pow, powImpl);
+const powConfig = {
+    kernelName: Pow,
+    backendName: 'cpu',
+    kernelFunc: pow
+};
+
+/**
+ * @license
+ * Copyright 2022 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function raggedGather(args) {
+    const { inputs, backend} = args;
+    const { paramsNestedSplits, paramsDenseValues, indices } = inputs;
+    const $paramsNestedSplits = paramsNestedSplits.map(t => backend.data.get(t.dataId).values);
+    const $paramsNestedSplitsShapes = paramsNestedSplits.map(t => t.shape);
+    const $paramsDenseValues = backend.data.get(paramsDenseValues.dataId).values;
+    const $indices = backend.data.get(indices.dataId).values;
+    const [outputNestedSplits, outputDenseValues, outputDenseValuesShape] = raggedGatherImpl($paramsNestedSplits, $paramsNestedSplitsShapes, $paramsDenseValues, paramsDenseValues.shape, paramsDenseValues.dtype, $indices, indices.shape);
+    const outputNestedSplitsTensors = outputNestedSplits.map((splits) => backend.makeTensorInfo([splits.length], 'int32', splits));
+    const outputDenseValuesTensor = backend.makeTensorInfo(outputDenseValuesShape, paramsDenseValues.dtype, outputDenseValues);
+    return outputNestedSplitsTensors.concat([outputDenseValuesTensor]);
+}
+const raggedGatherConfig = {
+    kernelName: RaggedGather,
+    backendName: 'cpu',
+    kernelFunc: raggedGather,
+};
+
+/**
+ * @license
+ * Copyright 2022 Google LLC.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function raggedRange(args) {
+    const { inputs, backend } = args;
+    const { starts, limits, deltas } = inputs;
+    const $starts = backend.data.get(starts.dataId).values;
+    const $limits = backend.data.get(limits.dataId).values;
+    const $deltas = backend.data.get(deltas.dataId).values;
+    const [rtNestedSplitsData, rtDenseValuesData] = raggedRangeImpl($starts, starts.shape, starts.dtype, $limits, limits.shape, $deltas, deltas.shape);
+    const rtNestedSplits = backend.makeTensorInfo([rtNestedSplitsData.length], 'int32', rtNestedSplitsData);
+    const rtDenseValues = backend.makeTensorInfo([rtDenseValuesData.length], starts.dtype, rtDenseValuesData);
+    return [rtNestedSplits, rtDenseValues];
+}
+const raggedRangeConfig = {
+    kernelName: RaggedRange,
+    backendName: 'cpu',
+    kernelFunc: raggedRange,
+};
+
+/**
+ * @license
+ * Copyright 2022 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function raggedTensorToTensor(args) {
+    const { inputs, backend, attrs } = args;
+    const { shape, values, defaultValue, rowPartitionTensors } = inputs;
+    const { rowPartitionTypes } = attrs;
+    const $shape = backend.data.get(shape.dataId).values;
+    const $values = backend.data.get(values.dataId).values;
+    const $defaultValue = backend.data.get(defaultValue.dataId).values;
+    const $rowPartitionValues = rowPartitionTensors.map(t => backend.data.get(t.dataId).values);
+    const rowPartitionValuesShapes = rowPartitionTensors.map(t => t.shape);
+    const [outputShape, output] = raggedTensorToTensorImpl($shape, shape.shape, $values, values.shape, values.dtype, $defaultValue, defaultValue.shape, $rowPartitionValues, rowPartitionValuesShapes, rowPartitionTypes);
+    return backend.makeTensorInfo(outputShape, values.dtype, output);
+}
+const raggedTensorToTensorConfig = {
+    kernelName: RaggedTensorToTensor,
+    backendName: 'cpu',
+    kernelFunc: raggedTensorToTensor,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function range$1(args) {
+    const { backend, attrs } = args;
+    const { start, stop, dtype, step } = attrs;
+    const values = rangeImpl(start, stop, step, dtype);
+    return backend.makeTensorInfo([values.length], dtype, values);
+}
+const rangeConfig = {
+    kernelName: Range,
+    backendName: 'cpu',
+    kernelFunc: range$1
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const reciprocal = unaryKernelFunc$1(Reciprocal, (xi) => 1 / xi);
+const reciprocalConfig = {
+    kernelName: Reciprocal,
+    backendName: 'cpu',
+    kernelFunc: reciprocal,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function resizeBilinear(args) {
+    const { inputs, backend, attrs } = args;
+    const { images } = inputs;
+    const { alignCorners, halfPixelCenters, size } = attrs;
+    assertNotComplex(images, 'resizeBilinear');
+    const imagesStrides = computeStrides(images.shape);
+    const [newHeight, newWidth] = size;
+    const [batch, oldHeight, oldWidth, numChannels] = images.shape;
+    const xValues = backend.data.get(images.dataId).values;
+    const result = new Float32Array(sizeFromShape([batch, newHeight, newWidth, numChannels]));
+    const effectiveInputSize = [
+        (alignCorners && newHeight > 1) ? oldHeight - 1 : oldHeight,
+        (alignCorners && newWidth > 1) ? oldWidth - 1 : oldWidth
+    ];
+    const effectiveOutputSize = [
+        (alignCorners && newHeight > 1) ? newHeight - 1 : newHeight,
+        (alignCorners && newWidth > 1) ? newWidth - 1 : newWidth
+    ];
+    let outputIdx = 0;
+    const effectiveRowSizeRatio = effectiveInputSize[0] / effectiveOutputSize[0];
+    const effectiveColSizeRatio = effectiveInputSize[1] / effectiveOutputSize[1];
+    for (let b = 0; b < batch; b++) {
+        for (let r = 0; r < newHeight; r++) {
+            let sourceFracRow;
+            if (halfPixelCenters) {
+                sourceFracRow = effectiveRowSizeRatio * (r + 0.5) - 0.5;
+            }
+            else {
+                sourceFracRow = effectiveRowSizeRatio * r;
+            }
+            const sourceRowFloor = Math.max(0, Math.floor(sourceFracRow));
+            const rowFrac = sourceFracRow - sourceRowFloor;
+            const sourceRowCeil = Math.min(oldHeight - 1, Math.ceil(sourceFracRow));
+            const topRowOffset = b * imagesStrides[0] + sourceRowFloor * imagesStrides[1];
+            const botRowOffset = b * imagesStrides[0] + sourceRowCeil * imagesStrides[1];
+            for (let c = 0; c < newWidth; c++) {
+                let sourceFracCol;
+                if (halfPixelCenters) {
+                    sourceFracCol = effectiveColSizeRatio * (c + 0.5) - 0.5;
+                }
+                else {
+                    sourceFracCol = effectiveColSizeRatio * c;
+                }
+                const sourceColFloor = Math.max(0, Math.floor(sourceFracCol));
+                const colFrac = sourceFracCol - sourceColFloor;
+                const sourceColCeil = Math.min(oldWidth - 1, Math.ceil(sourceFracCol));
+                const topLeftOffest = topRowOffset + sourceColFloor * imagesStrides[2];
+                const botLeftOffset = botRowOffset + sourceColFloor * imagesStrides[2];
+                const topRightOffset = topRowOffset + sourceColCeil * imagesStrides[2];
+                const botRightOffest = botRowOffset + sourceColCeil * imagesStrides[2];
+                for (let d = 0; d < numChannels; d++) {
+                    // Begin shader.
+                    // Compute the fractional index of the source.
+                    const topLeft = xValues[topLeftOffest + d];
+                    const bottomLeft = xValues[botLeftOffset + d];
+                    const topRight = xValues[topRightOffset + d];
+                    const bottomRight = xValues[botRightOffest + d];
+                    const top = topLeft + (topRight - topLeft) * colFrac;
+                    const bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac;
+                    const newValue = top + (bottom - top) * rowFrac;
+                    result[outputIdx++] = newValue;
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo([batch, newHeight, newWidth, numChannels], 'float32', result);
+}
+const resizeBilinearConfig = {
+    kernelName: ResizeBilinear,
+    backendName: 'cpu',
+    kernelFunc: resizeBilinear
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function resizeBilinearGrad(args) {
+    const { inputs, backend, attrs } = args;
+    const { images, dy } = inputs;
+    const { alignCorners } = attrs;
+    assertNotComplex([dy, images], 'resizeBilinearGrad');
+    const imagesStrides = computeStrides(images.shape);
+    const [batch, xHeight, xWidth, depth] = images.shape;
+    const [, yHeight, yWidth] = dy.shape;
+    const output = new Float32Array(batch * xHeight * xWidth * depth);
+    // In the backwards pass, we want to find the pixels that were generated
+    // for each pixel in the input image the forward pass and add the
+    // corresponding coefficient from dy to the gradient (with some
+    // interpolation).
+    const effectiveXSize = [
+        (alignCorners && yHeight > 1) ? xHeight - 1 : xHeight,
+        (alignCorners && yWidth > 1) ? xWidth - 1 : xWidth
+    ];
+    const effectiveYSize = [
+        (alignCorners && yHeight > 1) ? yHeight - 1 : yHeight,
+        (alignCorners && yWidth > 1) ? yWidth - 1 : yWidth
+    ];
+    const heightScale = effectiveXSize[0] / effectiveYSize[0];
+    const widthScale = effectiveXSize[1] / effectiveYSize[1];
+    // Reference implementation
+    // tslint:disable-next-line:max-line-length
+    // https://github.com/tensorflow/tensorflow/blob/3039375c86a5bbc9610c7725dcaa95d635f87ba2/tensorflow/core/kernels/resize_bilinear_op.cc#L275
+    const dyValues = backend.data.get(dy.dataId).values;
+    let offset = 0;
+    for (let b = 0; b < batch; b++) {
+        const bOffset = b * imagesStrides[0];
+        for (let r = 0; r < yHeight; r++) {
+            const dxR = r * heightScale;
+            const topDxRIndex = Math.floor(dxR);
+            const bottomDxRIndex = Math.min(Math.ceil(dxR), xHeight - 1);
+            const topDxROffset = bOffset + topDxRIndex * imagesStrides[1];
+            const bottomDxROffset = bOffset + bottomDxRIndex * imagesStrides[1];
+            const dxRLerp = dxR - topDxRIndex;
+            const inverseDxRLerp = 1.0 - dxRLerp;
+            for (let c = 0; c < yWidth; c++) {
+                const dxC = c * widthScale;
+                const leftDxCIndex = Math.floor(dxC);
+                const rightDxCIndex = Math.min(Math.ceil(dxC), xWidth - 1);
+                const dxCLerp = dxC - leftDxCIndex;
+                const inverseDxCLerp = 1.0 - dxCLerp;
+                const topLeftRCOffset = topDxROffset + leftDxCIndex * imagesStrides[2];
+                const topRightRCOffset = topDxROffset + rightDxCIndex * imagesStrides[2];
+                const bottomLeftRCOffset = bottomDxROffset + leftDxCIndex * imagesStrides[2];
+                const bottomRightRCOffset = bottomDxROffset + rightDxCIndex * imagesStrides[2];
+                const inverseDxRLerpTimesInverseDxCLerp = inverseDxRLerp * inverseDxCLerp;
+                const inverseDxRLerpTimesDxCLerp = inverseDxRLerp * dxCLerp;
+                const dxRLerpTimesInverseDxCLerp = dxRLerp * inverseDxCLerp;
+                const dxRLerpTimesDxCLerp = dxRLerp * dxCLerp;
+                for (let d = 0; d < depth; d++) {
+                    const dyVal = dyValues[offset++];
+                    output[topLeftRCOffset + d] +=
+                        dyVal * inverseDxRLerpTimesInverseDxCLerp;
+                    output[topRightRCOffset + d] += dyVal * inverseDxRLerpTimesDxCLerp;
+                    output[bottomLeftRCOffset + d] += dyVal * dxRLerpTimesInverseDxCLerp;
+                    output[bottomRightRCOffset + d] += dyVal * dxRLerpTimesDxCLerp;
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo([batch, xWidth, xHeight, depth], 'float32', output);
+}
+const resizeBilinearGradConfig$1 = {
+    kernelName: ResizeBilinearGrad,
+    backendName: 'cpu',
+    kernelFunc: resizeBilinearGrad
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function resizeNearestNeighbor(args) {
+    const { inputs, backend, attrs } = args;
+    const { images } = inputs;
+    const { alignCorners, halfPixelCenters, size } = attrs;
+    assertNotComplex(images, 'resizeNearestNeighbor');
+    const imagesStrides = computeStrides(images.shape);
+    const [newHeight, newWidth] = size;
+    const [batch, oldHeight, oldWidth, numChannels] = images.shape;
+    const xValues = backend.data.get(images.dataId).values;
+    const output = new Float32Array(batch * newHeight * newWidth * numChannels);
+    const effectiveInputSize = [
+        (alignCorners && newHeight > 1) ? oldHeight - 1 : oldHeight,
+        (alignCorners && newWidth > 1) ? oldWidth - 1 : oldWidth
+    ];
+    const effectiveOutputSize = [
+        (alignCorners && newHeight > 1) ? newHeight - 1 : newHeight,
+        (alignCorners && newWidth > 1) ? newWidth - 1 : newWidth
+    ];
+    const effectiveRowSizeRatio = effectiveInputSize[0] / effectiveOutputSize[0];
+    const effectiveColSizeRatio = effectiveInputSize[1] / effectiveOutputSize[1];
+    let outputOffset = 0;
+    for (let b = 0; b < batch; b++) {
+        const batchOffset = b * imagesStrides[0];
+        for (let r = 0; r < newHeight; r++) {
+            const sourceFracRow = halfPixelCenters ?
+                effectiveRowSizeRatio * (r + 0.5) :
+                effectiveRowSizeRatio * r;
+            let sourceNearestRow = Math.min(oldHeight - 1, alignCorners ? Math.round(sourceFracRow) : Math.floor(sourceFracRow));
+            if (halfPixelCenters) {
+                sourceNearestRow = Math.max(0, sourceNearestRow);
+            }
+            const rowOffset = batchOffset + sourceNearestRow * imagesStrides[1];
+            for (let c = 0; c < newWidth; c++) {
+                const sourceFracCol = halfPixelCenters ?
+                    effectiveColSizeRatio * (c + 0.5) :
+                    effectiveColSizeRatio * c;
+                let sourceNearestCol = Math.min(oldWidth - 1, alignCorners ? Math.round(sourceFracCol) :
+                    Math.floor(sourceFracCol));
+                if (halfPixelCenters) {
+                    sourceNearestCol = Math.max(0, sourceNearestCol);
+                }
+                const colOffset = rowOffset + sourceNearestCol * imagesStrides[2];
+                for (let d = 0; d < numChannels; d++) {
+                    // Begin shader.
+                    // Compute the fractional index of the source.
+                    const newVal = xValues[colOffset + d];
+                    output[outputOffset++] = newVal;
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo([batch, newHeight, newWidth, numChannels], images.dtype, output);
+}
+const resizeNearestNeighborConfig = {
+    kernelName: ResizeNearestNeighbor,
+    backendName: 'cpu',
+    kernelFunc: resizeNearestNeighbor
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function resizeNearestNeighborGrad(args) {
+    const { inputs, backend, attrs } = args;
+    const { images, dy } = inputs;
+    const { alignCorners } = attrs;
+    assertNotComplex([dy, images], 'resizeNearestNeighborGrad');
+    const imagesStrides = computeStrides(images.shape);
+    const dyStrides = computeStrides(dy.shape);
+    const [batch, xHeight, xWidth, depth] = images.shape;
+    const [, yHeight, yWidth] = dy.shape;
+    const output = new Float32Array(batch * xHeight * xWidth * depth);
+    const dyValues = backend.data.get(dy.dataId).values;
+    // In the backwards pass, we want to find the pixels that were generated
+    // for each pixel in the input image the forward pass
+    const effectiveXSize = [
+        (alignCorners && yHeight > 1) ? xHeight - 1 : xHeight,
+        (alignCorners && yWidth > 1) ? xWidth - 1 : xWidth
+    ];
+    const effectiveYSize = [
+        (alignCorners && yHeight > 1) ? yHeight - 1 : yHeight,
+        (alignCorners && yWidth > 1) ? yWidth - 1 : yWidth
+    ];
+    const heightScale = effectiveXSize[0] / effectiveYSize[0];
+    const widthScale = effectiveXSize[1] / effectiveYSize[1];
+    const invHeightScale = 1 / heightScale;
+    const invWidthScale = 1 / widthScale;
+    // This defines the size of the window of values around a particular
+    // index in dy that we want to search for contributions to dx.
+    const winHeight = (Math.ceil(invHeightScale) * 2) + 2;
+    const winWidth = (Math.ceil(invWidthScale) * 2) + 2;
+    // Loop over the output space.
+    for (let b = 0; b < batch; b++) {
+        const batchOffset = b * imagesStrides[0];
+        for (let r = 0; r < xHeight; r++) {
+            const rowOffset = batchOffset + r * imagesStrides[1];
+            // Compute bounds for where in dy we will look
+            const startRLerp = Math.floor(r * invHeightScale);
+            const startDyR = Math.floor(startRLerp - (winHeight / 2));
+            for (let c = 0; c < xWidth; c++) {
+                const colOffset = rowOffset + c * imagesStrides[2];
+                // Compute bounds for where in dy we will look
+                const startCLerp = Math.floor(c * invWidthScale);
+                const startDyC = Math.floor(startCLerp - (winWidth / 2));
+                for (let d = 0; d < depth; d++) {
+                    let accum = 0;
+                    // loop over dy
+                    for (let dyRIndex = 0; dyRIndex < winHeight; dyRIndex++) {
+                        const dyR = dyRIndex + startDyR;
+                        // Guard against the window exceeding the bounds of dy
+                        if (dyR < 0 || dyR >= yHeight) {
+                            continue;
+                        }
+                        const dyROffset = batchOffset + dyR * dyStrides[1];
+                        const sourceFracRow = dyR * heightScale;
+                        const sourceNearestRow = Math.min(xHeight - 1, alignCorners ? Math.round(sourceFracRow) :
+                            Math.floor(sourceFracRow));
+                        if (r !== sourceNearestRow) {
+                            continue;
+                        }
+                        for (let dyCIndex = 0; dyCIndex < winWidth; dyCIndex++) {
+                            const dyC = dyCIndex + startDyC;
+                            // Guard against the window exceeding the bounds of dy
+                            if (dyC < 0 || dyC >= yWidth) {
+                                continue;
+                            }
+                            const dyCOffset = dyROffset + dyC * dyStrides[2];
+                            const sourceFracCol = dyC * widthScale;
+                            const sourceNearestCol = Math.min(xWidth - 1, alignCorners ? Math.round(sourceFracCol) :
+                                Math.floor(sourceFracCol));
+                            if (c === sourceNearestCol) {
+                                accum += dyValues[dyCOffset + d];
+                            }
+                        }
+                    }
+                    output[colOffset + d] = accum;
+                }
+            }
+        }
+    }
+    return backend.makeTensorInfo(images.shape, images.dtype, output);
+}
+const resizeNearestNeighborGradConfig$1 = {
+    kernelName: ResizeNearestNeighborGrad,
+    backendName: 'cpu',
+    kernelFunc: resizeNearestNeighborGrad
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function reverse(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { dims } = attrs;
+    assertNotComplex(x, 'reverse');
+    const xRank = x.shape.length;
+    const $dims = parseAxisParam(dims, x.shape);
+    if (xRank === 0) {
+        return identity$1({ inputs: { x }, backend });
+    }
+    const outBuf = new TensorBuffer(x.shape, x.dtype);
+    const xBuf = backend.bufferSync(x);
+    for (let i = 0; i < outBuf.size; i++) {
+        const outLoc = outBuf.indexToLoc(i);
+        const inLoc = outLoc.slice();
+        $dims.forEach(d => inLoc[d] = x.shape[d] - 1 - inLoc[d]);
+        outBuf.set(xBuf.get(...inLoc), ...outLoc);
+    }
+    return backend.makeTensorInfo(outBuf.shape, outBuf.dtype, outBuf.values);
+}
+const reverseConfig = {
+    kernelName: Reverse,
+    backendName: 'cpu',
+    kernelFunc: reverse
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const rotateWithOffsetConfig = {
+    kernelName: RotateWithOffset,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, attrs, backend }) => {
+        const { image } = inputs;
+        const { radians, fillValue, center } = attrs;
+        const cpuBackend = backend;
+        const output = getTypedArrayFromDType(image.dtype, sizeFromShape(image.shape));
+        const [batch, imageHeight, imageWidth, numChannels] = image.shape;
+        const [centerX, centerY] = getImageCenter(center, imageHeight, imageWidth);
+        const fullOpacityValue = 255;
+        const sinFactor = Math.sin(radians);
+        const cosFactor = Math.cos(radians);
+        const imageVals = cpuBackend.data.get(image.dataId).values;
+        for (let batchIdx = 0; batchIdx < batch; batchIdx++) {
+            const batchOffset = batchIdx * imageWidth * imageHeight * numChannels;
+            for (let row = 0; row < imageHeight; row++) {
+                const rowOffset = row * (imageWidth * numChannels);
+                for (let col = 0; col < imageWidth; col++) {
+                    const colOffset = col * numChannels;
+                    for (let channel = 0; channel < numChannels; channel++) {
+                        const coords = [batch, row, col, channel];
+                        const x = coords[2];
+                        const y = coords[1];
+                        // coordX/coordY are the result of rotating and translating x/y.
+                        let coordX = (x - centerX) * cosFactor - (y - centerY) * sinFactor;
+                        let coordY = (x - centerX) * sinFactor + (y - centerY) * cosFactor;
+                        coordX = Math.round(coordX + centerX);
+                        coordY = Math.round(coordY + centerY);
+                        let outputValue = fillValue;
+                        if (typeof fillValue !== 'number') {
+                            if (channel === 3) {
+                                outputValue = fullOpacityValue;
+                            }
+                            else {
+                                outputValue = fillValue[channel];
+                            }
+                        }
+                        // If the coordinate position falls within the image boundaries...
+                        if (coordX >= 0 && coordX < imageWidth && coordY >= 0 &&
+                            coordY < imageHeight) {
+                            // set the output to the image value at the coordinate position.
+                            const rotatedRowOffset = coordY * (imageWidth * numChannels);
+                            const rotatedColOffset = coordX * numChannels;
+                            const imageIdx = batchOffset + rotatedRowOffset + rotatedColOffset + channel;
+                            outputValue = imageVals[imageIdx];
+                        }
+                        const outIdx = batchOffset + rowOffset + colOffset + channel;
+                        output[outIdx] = outputValue;
+                    }
+                }
+            }
+        }
+        const dataId = cpuBackend.write(output, image.shape, image.dtype);
+        return { dataId, shape: image.shape, dtype: image.dtype };
+    }
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const round = unaryKernelFunc$1(Round, (xi) => {
+    // The algorithm is based on banker's rounding.
+    const base = Math.floor(xi);
+    if (xi - base < 0.5) {
+        return Math.floor(xi);
+    }
+    else if (xi - base > 0.5) {
+        return Math.ceil(xi);
+    }
+    else {
+        if (base % 2.0 === 0.0) {
+            return base;
+        }
+        else {
+            return base + 1.0;
+        }
+    }
+});
+const roundConfig = {
+    kernelName: Round,
+    backendName: 'cpu',
+    kernelFunc: round,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function scatterNd(args) {
+    const { inputs, backend, attrs } = args;
+    const { indices, updates } = inputs;
+    const { shape } = attrs;
+    const { sliceRank, numUpdates, sliceSize, strides, outputSize } = calculateShapes(updates, indices, shape);
+    const sumDupeIndices = true;
+    const indicesBuf = backend.bufferSync(indices);
+    const updatesBuf = backend.bufferSync(updates);
+    const outBuf = scatterImpl(indicesBuf, updatesBuf, shape, outputSize, sliceSize, numUpdates, sliceRank, strides, 0 /* defaultValue */, sumDupeIndices);
+    return backend.makeTensorInfo(shape, outBuf.dtype, outBuf.values);
+}
+const scatterNdConfig = {
+    kernelName: ScatterNd,
+    backendName: 'cpu',
+    kernelFunc: scatterNd
+};
+
+/**
+ * @license
+ * Copyright 2022 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function lowerBound(array, value) {
+    let left = 0;
+    let right = array.length;
+    let mid = 0;
+    while (left < right) {
+        mid = Math.floor((left + right) / 2);
+        if (array[mid] < value) {
+            left = mid + 1;
+        }
+        else {
+            right = mid;
+        }
+    }
+    return right;
+}
+function upperBound(array, value) {
+    let left = 0;
+    let right = array.length;
+    let mid = 0;
+    while (left < right) {
+        mid = Math.floor((left + right) / 2);
+        if (array[mid] <= value) {
+            left = mid + 1;
+        }
+        else {
+            right = mid;
+        }
+    }
+    return right;
+}
+function searchSortedImpl(sortedInputs, values, batchSize, numInputs, numValues, side) {
+    const output = getArrayFromDType('int32', batchSize * numValues);
+    for (let b = 0; b < batchSize; ++b) {
+        const sortedInputsSlice = sortedInputs.slice(b * numInputs, (b + 1) * numInputs);
+        const outputOffset = b * numValues;
+        for (let i = 0; i < numValues; ++i) {
+            output[outputOffset + i] = side === 'left' ?
+                lowerBound(sortedInputsSlice, values[i + outputOffset]) :
+                upperBound(sortedInputsSlice, values[i + outputOffset]);
+        }
+    }
+    return output;
+}
+
+/**
+ * @license
+ * Copyright 2022 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function searchSorted(args) {
+    const { inputs, backend, attrs } = args;
+    const { sortedSequence, values } = inputs;
+    const { side } = attrs;
+    const $sortedSequence = backend.data.get(sortedSequence.dataId).values;
+    const $values = backend.data.get(values.dataId).values;
+    const output = searchSortedImpl($sortedSequence, $values, sortedSequence.shape[0], sortedSequence.shape[1], values.shape[1], side);
+    return backend.makeTensorInfo(values.shape, 'int32', output);
+}
+const searchSortedConfig = {
+    kernelName: SearchSorted,
+    backendName: 'cpu',
+    kernelFunc: searchSorted,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function select(args) {
+    const { inputs, backend } = args;
+    const { condition, t, e } = inputs;
+    assertNotComplex([condition, t, e], 'select');
+    const conditionRank = condition.shape.length;
+    const values = backend.data.get(condition.dataId).values;
+    const tValues = backend.data.get(t.dataId).values;
+    const eValues = backend.data.get(e.dataId).values;
+    const resultDtype = upcastType(t.dtype, e.dtype);
+    const newValues = makeZerosTypedArray(sizeFromShape(t.shape), resultDtype);
+    let index = 0;
+    const offset = conditionRank === 0 || conditionRank > 1 || t.shape.length === 1 ?
+        1 :
+        sizeFromShape(t.shape.slice(1));
+    for (let i = 0; i < values.length; i++) {
+        for (let j = 0; j < offset; j++) {
+            if (values[i] === 1) {
+                newValues[index++] = tValues[i];
+            }
+            else {
+                newValues[index++] = eValues[i];
+            }
+        }
+    }
+    return backend.makeTensorInfo(t.shape, resultDtype, newValues);
+}
+const selectConfig = {
+    kernelName: Select,
+    backendName: 'cpu',
+    kernelFunc: select
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const scaleAlpha = SELU_SCALEALPHA;
+const scale = SELU_SCALE;
+const selu = unaryKernelFunc$1(Selu$1, (xi) => {
+    if (xi >= 0) {
+        return scale * xi;
+    }
+    else {
+        return scaleAlpha * (Math.exp(xi) - 1);
+    }
+});
+const seluConfig = {
+    kernelName: Selu$1,
+    backendName: 'cpu',
+    kernelFunc: selu,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const sign = unaryKernelFunc$1(Sign, (xi) => {
+    if (xi < 0) {
+        return -1;
+    }
+    else if (xi > 0) {
+        return 1;
+    }
+    else {
+        return 0;
+    }
+});
+const signConfig = {
+    kernelName: Sign,
+    backendName: 'cpu',
+    kernelFunc: sign,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const sin = unaryKernelFunc$1(Sin, (xi) => Math.sin(xi));
+const sinConfig = {
+    kernelName: Sin,
+    backendName: 'cpu',
+    kernelFunc: sin,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const sinh = unaryKernelFunc$1(Sinh, (xi) => Math.sinh(xi));
+const sinhConfig = {
+    kernelName: Sinh,
+    backendName: 'cpu',
+    kernelFunc: sinh,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+// mirrors the implementation of tf.nn.softplus: https://goo.gl/vkcvwX
+// epsilon is the difference between 1.0 and the next representable float.
+// For a single precision 32 bit float this should be 2^-23, see:
+// https://math.byu.edu/~schow/work/IEEEFloatingPoint.htm
+const epsilon$1 = 1.1920928955078125e-7;
+const threshold = Math.log(epsilon$1) + 2.0;
+const softplus = unaryKernelFunc$1(Softplus$1, (xi) => {
+    // Value above which exp(x) may overflow, but softplus(x) == x
+    // is within machine epsilon.
+    const tooLarge = xi > -threshold;
+    // Value below which exp(x) may underflow, but softplus(x) == exp(x)
+    // is within machine epsilon.
+    const tooSmall = xi < threshold;
+    const expX = Math.exp(xi);
+    let result;
+    if (tooSmall) {
+        result = expX;
+    }
+    else if (tooLarge) {
+        result = xi;
+    }
+    else {
+        result = Math.log(1.0 + expX);
+    }
+    return result;
+});
+const softplusConfig = {
+    kernelName: Softplus$1,
+    backendName: 'cpu',
+    kernelFunc: softplus,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function spaceToBatchND(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { blockShape, paddings } = attrs;
+    assertNotComplex([x], 'spaceToBatchND');
+    const prod = sizeFromShape(blockShape);
+    const completePaddings = [[0, 0]];
+    completePaddings.push(...paddings);
+    for (let i = 1 + blockShape.length; i < x.shape.length; ++i) {
+        completePaddings.push([0, 0]);
+    }
+    const paddedX = padV2Config.kernelFunc({
+        inputs: { x },
+        backend,
+        attrs: { paddings: completePaddings, constantValue: 0 }
+    });
+    const reshapedPaddedShape = getReshaped(paddedX.shape, blockShape, prod, false);
+    const permutedReshapedPaddedPermutation = getPermuted(reshapedPaddedShape.length, blockShape.length, false);
+    const flattenShape = getReshapedPermuted(paddedX.shape, blockShape, prod, false);
+    const reshapeInputs = { x: paddedX };
+    const reshapeAttrs = { shape: reshapedPaddedShape };
+    const paddedXReshaped = reshape({ inputs: reshapeInputs, backend, attrs: reshapeAttrs });
+    const transposeInputs = { x: paddedXReshaped };
+    const transposeAttrs = { perm: permutedReshapedPaddedPermutation };
+    const paddedXT = transpose$1({ inputs: transposeInputs, backend, attrs: transposeAttrs });
+    const resultReshapeInputs = { x: paddedXT };
+    const resultReshapeAttrs = { shape: flattenShape };
+    const result = reshape({ inputs: resultReshapeInputs, backend, attrs: resultReshapeAttrs });
+    backend.disposeIntermediateTensorInfo(paddedX);
+    backend.disposeIntermediateTensorInfo(paddedXReshaped);
+    backend.disposeIntermediateTensorInfo(paddedXT);
+    return result;
+}
+const spaceToBatchNDConfig = {
+    kernelName: SpaceToBatchND,
+    backendName: 'cpu',
+    kernelFunc: spaceToBatchND
+};
+
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function sparseFillEmptyRows(args) {
+    const { inputs, backend } = args;
+    const { indices, values, denseShape, defaultValue } = inputs;
+    if (denseShape.shape.length !== 1) {
+        throw new Error(`Dense shape must be a vector, saw:
+        ${denseShape.shape}`);
+    }
+    if (indices.shape.length !== 2) {
+        throw new Error(`Indices must be a matrix, saw:
+        ${indices.shape}`);
+    }
+    if (values.shape.length !== 1) {
+        throw new Error(`Values must be a vector, saw:
+        ${values.shape}`);
+    }
+    if (defaultValue.shape.length !== 0) {
+        throw new Error(`Default value must be a scalar, saw:
+        ${defaultValue.shape}`);
+    }
+    const $indices = backend.data.get(indices.dataId).values;
+    const $values = backend.data.get(values.dataId).values;
+    const $denseShape = backend.data.get(denseShape.dataId).values;
+    const $defaultValue = backend.data.get(defaultValue.dataId).values[0];
+    const [outputIndices, outputIndicesShape, outputValues, emptyRowIndicator, reverseIndexMap] = sparseFillEmptyRowsImpl($indices, indices.shape, indices.dtype, $values, values.dtype, $denseShape, $defaultValue);
+    return [
+        backend.makeTensorInfo(outputIndicesShape, indices.dtype, outputIndices),
+        backend.makeTensorInfo([outputIndicesShape[0]], values.dtype, outputValues),
+        backend.makeTensorInfo([emptyRowIndicator.length], 'bool', new Uint8Array(emptyRowIndicator.map((value) => Number(value)))),
+        backend.makeTensorInfo([reverseIndexMap.length], indices.dtype, new Int32Array(reverseIndexMap)),
+    ];
+}
+const sparseFillEmptyRowsConfig = {
+    kernelName: SparseFillEmptyRows,
+    backendName: 'cpu',
+    kernelFunc: sparseFillEmptyRows,
+};
+
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function sparseReshape(args) {
+    const { inputs, backend } = args;
+    const { inputIndices, inputShape, newShape } = inputs;
+    if (inputIndices.shape.length !== 2) {
+        throw new Error(`Input indices should be a matrix but received shape
+        ${inputIndices.shape}`);
+    }
+    if (inputShape.shape.length !== 1) {
+        throw new Error(`Input shape should be a vector but received shape
+        ${inputShape.shape}`);
+    }
+    if (newShape.shape.length !== 1) {
+        throw new Error(`Target shape should be a vector but received shape ${newShape.shape}`);
+    }
+    const $inputShape = Array.from(backend.data.get(inputShape.dataId).values);
+    const $inputIndices = backend.data.get(inputIndices.dataId).values;
+    const targetShape = Array.from(backend.data.get(newShape.dataId).values);
+    const [newIndices, indicesShape, outputShape] = sparseReshapeImpl($inputIndices, inputIndices.shape, inputIndices.dtype, $inputShape, targetShape);
+    return [
+        backend.makeTensorInfo(indicesShape, inputIndices.dtype, newIndices),
+        backend.makeTensorInfo([outputShape.length], newShape.dtype, new Int32Array(outputShape)),
+    ];
+}
+const sparseReshapeConfig = {
+    kernelName: SparseReshape,
+    backendName: 'cpu',
+    kernelFunc: sparseReshape,
+};
+
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function sparseSegmentMean(args) {
+    const { inputs, backend } = args;
+    const { data, indices, segmentIds } = inputs;
+    if (data.shape.length < 1) {
+        throw new Error(`Data should be at least 1 dimensional but received scalar`);
+    }
+    if (indices.shape.length !== 1) {
+        throw new Error(`Indices should be a vector but received shape
+          ${indices.shape}`);
+    }
+    if (segmentIds.shape.length !== 1) {
+        throw new Error(`Segment ids should be a vector but received shape
+          ${segmentIds.shape}`);
+    }
+    if (indices.shape[0] !== segmentIds.shape[0]) {
+        throw new Error(`segmentIds and indices should have same size.`);
+    }
+    const $data = backend.data.get(data.dataId).values;
+    const $indices = backend.data.get(indices.dataId).values;
+    const $segmentIds = backend.data.get(segmentIds.dataId).values;
+    const [outputData, outputDataShape] = sparseSegmentReductionImpl($data, data.shape, data.dtype, $indices, $segmentIds, true);
+    return backend.makeTensorInfo(outputDataShape, data.dtype, outputData);
+}
+const sparseSegmentMeanConfig = {
+    kernelName: SparseSegmentMean,
+    backendName: 'cpu',
+    kernelFunc: sparseSegmentMean,
+};
+
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function sparseSegmentSum(args) {
+    const { inputs, backend } = args;
+    const { data, indices, segmentIds } = inputs;
+    if (data.shape.length < 1) {
+        throw new Error(`Data should be at least 1 dimensional but received scalar`);
+    }
+    if (indices.shape.length !== 1) {
+        throw new Error(`Indices should be a vector but received shape
+         ${indices.shape}`);
+    }
+    if (segmentIds.shape.length !== 1) {
+        throw new Error(`Segment ids should be a vector but received shape
+         ${segmentIds.shape}`);
+    }
+    if (indices.shape[0] !== segmentIds.shape[0]) {
+        throw new Error(`segmentIds and indices should have same size.`);
+    }
+    const $data = backend.data.get(data.dataId).values;
+    const $indices = backend.data.get(indices.dataId).values;
+    const $segmentIds = backend.data.get(segmentIds.dataId).values;
+    const [outputData, outputDataShape] = sparseSegmentReductionImpl($data, data.shape, data.dtype, $indices, $segmentIds);
+    return backend.makeTensorInfo(outputDataShape, data.dtype, outputData);
+}
+const sparseSegmentSumConfig = {
+    kernelName: SparseSegmentSum,
+    backendName: 'cpu',
+    kernelFunc: sparseSegmentSum,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function sparseToDense(args) {
+    const { inputs, backend, attrs } = args;
+    const { sparseIndices, sparseValues, defaultValue } = inputs;
+    const { outputShape } = attrs;
+    const { sliceRank, numUpdates, sliceSize, strides, outputSize } = calculateShapes(sparseValues, sparseIndices, outputShape);
+    const sumDupeIndices = false;
+    const indicesBuf = backend.bufferSync(sparseIndices);
+    let outBuf;
+    switch (sparseValues.dtype) {
+        case 'bool': {
+            const updatesBuf = backend.bufferSync(sparseValues);
+            const $defaultValue = Boolean(backend.data.get(defaultValue.dataId).values[0]);
+            outBuf = scatterImpl(indicesBuf, updatesBuf, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, $defaultValue, sumDupeIndices);
+            break;
+        }
+        case 'float32': {
+            const updatesBuf = backend.bufferSync(sparseValues);
+            const $defaultValue = backend.data.get(defaultValue.dataId).values[0];
+            outBuf = scatterImpl(indicesBuf, updatesBuf, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, $defaultValue, sumDupeIndices);
+            break;
+        }
+        case 'int32': {
+            const updatesBuf = backend.bufferSync(sparseValues);
+            const $defaultValue = backend.data.get(defaultValue.dataId).values[0];
+            outBuf = scatterImpl(indicesBuf, updatesBuf, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, $defaultValue, sumDupeIndices);
+            break;
+        }
+        case 'string': {
+            const updatesBuf = backend.bufferSync(sparseValues);
+            const $defaultValue = decodeString(backend.data.get(defaultValue.dataId).values[0]);
+            outBuf = scatterImpl(indicesBuf, updatesBuf, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, $defaultValue, sumDupeIndices);
+            break;
+        }
+        default:
+            throw new Error(`Unsupported type ${sparseValues.dtype}`);
+    }
+    return backend.makeTensorInfo(outputShape, outBuf.dtype, outBuf.values);
+}
+const sparseToDenseConfig = {
+    kernelName: SparseToDense,
+    backendName: 'cpu',
+    kernelFunc: sparseToDense
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function splitV(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { numOrSizeSplits, axis } = attrs;
+    const $axis = parseAxisParam(axis, x.shape)[0];
+    const splitSizes = prepareSplitSize(x, numOrSizeSplits, $axis);
+    const begin = new Array(x.shape.length).fill(0);
+    const size = x.shape.slice();
+    return splitSizes.map(s => {
+        const sliceSize = [...size];
+        sliceSize[$axis] = s;
+        const sliceT = slice$1({ inputs: { x }, backend, attrs: { begin, size: sliceSize } });
+        begin[$axis] += s;
+        return sliceT;
+    });
+}
+const splitVConfig = {
+    kernelName: SplitV,
+    backendName: 'cpu',
+    kernelFunc: splitV
+};
+
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const squareConfig = {
+    kernelName: Square,
+    backendName: 'cpu',
+    kernelFunc: ({ inputs, backend }) => {
+        const { x } = inputs;
+        const cpuBackend = backend;
+        assertNotComplex(x, 'square');
+        const values = cpuBackend.data.get(x.dataId).values;
+        const newValues = new Float32Array(values.length);
+        for (let i = 0; i < values.length; ++i) {
+            const value = values[i];
+            newValues[i] = value * value;
+        }
+        const dataId = cpuBackend.write(newValues, x.shape, x.dtype);
+        return { dataId, shape: x.shape, dtype: x.dtype };
+    }
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const step = unaryKernelFunc$1(Step, (xi, attrs) => {
+    const stepAttrs = attrs;
+    if (isNaN(xi)) {
+        return NaN;
+    }
+    else {
+        return xi > 0 ? 1 : stepAttrs.alpha;
+    }
+});
+const stepConfig = {
+    kernelName: Step,
+    backendName: 'cpu',
+    kernelFunc: step,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function stridedSlice(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { begin, end, strides, beginMask, endMask, ellipsisMask, newAxisMask, shrinkAxisMask } = attrs;
+    assertNotComplex(x, 'stridedSlice');
+    const { finalShapeSparse, finalShape, isIdentity, sliceDim0, isSimpleSlice, begin: $begin, end: $end, strides: $strides } = sliceInfo(x.shape, begin, end, strides, beginMask, endMask, ellipsisMask, newAxisMask, shrinkAxisMask);
+    let result;
+    // ref:
+    // https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/strided_slice_op.cc
+    if (isIdentity) {
+        // Optimization #1, slice is a no-op plus reshape
+        result = reshape({ inputs: { x }, backend, attrs: { shape: finalShape } });
+    }
+    else if (sliceDim0 || isSimpleSlice) {
+        // Optimization #2, slice is memory contiguous (only occurs in dim 0)
+        assert$1(x.shape.length >= 1, () => `Input must have rank at least 1, got: ${x.shape.length}`);
+        const size = computeOutShape$2($begin, $end, $strides);
+        // To tolerate begin[0] > end[0] (a 0-output slice), we min(begin, end).
+        const sliced = slice$1({ inputs: { x }, backend, attrs: { begin: $begin, size } });
+        result =
+            reshape({ inputs: { x: sliced }, backend, attrs: { shape: finalShape } });
+        backend.disposeIntermediateTensorInfo(sliced);
+    }
+    else {
+        const xBuf = backend.bufferSync(x);
+        const outBuf = stridedSliceImpl(finalShapeSparse, xBuf, $strides, $begin);
+        result = backend.makeTensorInfo(finalShape, outBuf.dtype, outBuf.values);
+    }
+    return result;
+}
+const stridedSliceConfig = {
+    kernelName: StridedSlice,
+    backendName: 'cpu',
+    kernelFunc: stridedSlice
+};
+
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function stringNGrams(args) {
+    const { inputs, backend, attrs } = args;
+    const { separator, nGramWidths, leftPad, rightPad, padWidth, preserveShortSequences } = attrs;
+    const { data, dataSplits } = inputs;
+    const $data = backend.data.get(data.dataId).values;
+    const $dataSplits = backend.data.get(dataSplits.dataId).values;
+    const [nGrams, nGramsSplits] = stringNGramsImpl($data, $dataSplits, separator, nGramWidths, leftPad, rightPad, padWidth, preserveShortSequences);
+    return [
+        backend.makeTensorInfo([nGrams.length], 'string', nGrams),
+        backend.makeTensorInfo(dataSplits.shape, 'int32', nGramsSplits),
+    ];
+}
+const stringNGramsConfig = {
+    kernelName: StringNGrams,
+    backendName: 'cpu',
+    kernelFunc: stringNGrams,
+};
+
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function stringSplit(args) {
+    const { inputs, backend, attrs } = args;
+    const { skipEmpty } = attrs;
+    const { input, delimiter } = inputs;
+    if (input.dtype !== 'string') {
+        throw new Error('Input must be of datatype string');
+    }
+    if (input.shape.length !== 1) {
+        throw new Error(`Input must be a vector, got shape: ${input.shape}`);
+    }
+    if (delimiter.shape.length !== 0) {
+        throw new Error(`Delimiter must be a scalar, got shape: ${delimiter.shape}`);
+    }
+    const $input = backend.data.get(input.dataId).values;
+    const $delimiter = backend.data.get(delimiter.dataId).values[0];
+    const [indices, values, shape] = stringSplitImpl($input, $delimiter, skipEmpty);
+    const outputSize = values.length;
+    return [
+        backend.makeTensorInfo([outputSize, 2], 'int32', indices),
+        backend.makeTensorInfo([outputSize], 'string', values),
+        backend.makeTensorInfo([2], 'int32', new Int32Array(shape))
+    ];
+}
+const stringSplitConfig = {
+    kernelName: StringSplit,
+    backendName: 'cpu',
+    kernelFunc: stringSplit,
+};
+
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function stringToHashBucketFast(args) {
+    const { inputs, backend, attrs } = args;
+    const { numBuckets } = attrs;
+    const { input } = inputs;
+    if (input.dtype !== 'string') {
+        throw new Error('Input must be of datatype string');
+    }
+    if (numBuckets <= 0) {
+        throw new Error(`Number of buckets must be at least 1`);
+    }
+    const $input = backend.data.get(input.dataId).values;
+    const output = stringToHashBucketFastImpl($input, numBuckets);
+    return backend.makeTensorInfo(input.shape, 'int32', output);
+}
+const stringToHashBucketFastConfig = {
+    kernelName: StringToHashBucketFast,
+    backendName: 'cpu',
+    kernelFunc: stringToHashBucketFast,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const tan = unaryKernelFunc$1(Tan, (xi) => Math.tan(xi));
+const tanConfig = {
+    kernelName: Tan,
+    backendName: 'cpu',
+    kernelFunc: tan,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const tanh = unaryKernelFunc$1(Tanh$1, (xi) => Math.tanh(xi));
+const tanhConfig = {
+    kernelName: Tanh$1,
+    backendName: 'cpu',
+    kernelFunc: tanh,
+};
+
+/**
+ * @license
+ * Copyright 2022 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function tensorScatterUpdate(args) {
+    const { inputs, backend } = args;
+    const { tensor, indices, updates } = inputs;
+    const { sliceRank, numUpdates, sliceSize, strides, outputSize } = calculateShapes(updates, indices, tensor.shape);
+    const sumDupeIndices = false;
+    const indicesBuf = backend.bufferSync(indices);
+    const updatesBuf = backend.bufferSync(updates);
+    const tensorBuf = backend.bufferSync(tensor);
+    const outBuf = scatterImpl(indicesBuf, updatesBuf, tensor.shape, outputSize, sliceSize, numUpdates, sliceRank, strides, tensorBuf, sumDupeIndices);
+    return backend.makeTensorInfo(tensor.shape, outBuf.dtype, outBuf.values);
+}
+const tensorScatterUpdateConfig = {
+    kernelName: TensorScatterUpdate,
+    backendName: 'cpu',
+    kernelFunc: tensorScatterUpdate
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function tile$1(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { reps } = attrs;
+    assertNotComplex(x, 'tile');
+    const outBuf = tileImpl(backend.bufferSync(x), reps);
+    return backend.makeTensorInfo(outBuf.shape, outBuf.dtype, outBuf.values);
+}
+const tileConfig = {
+    kernelName: Tile,
+    backendName: 'cpu',
+    kernelFunc: tile$1
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function topK(args) {
+    const { inputs, backend, attrs } = args;
+    const { x } = inputs;
+    const { k, sorted } = attrs;
+    assertNotComplex(x, 'topk');
+    const xVals = backend.data.get(x.dataId).values;
+    const [allTopKVals, allTopKIndices] = topKImpl(xVals, x.shape, x.dtype, k, sorted);
+    return [
+        backend.makeTensorInfo(allTopKVals.shape, allTopKVals.dtype, allTopKVals.values),
+        backend.makeTensorInfo(allTopKIndices.shape, allTopKIndices.dtype, allTopKIndices.values)
+    ];
+}
+const topKConfig = {
+    kernelName: TopK,
+    backendName: 'cpu',
+    kernelFunc: topK
+};
+
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function transform(args) {
+    const { inputs, attrs, backend } = args;
+    const { image, transforms } = inputs;
+    const { interpolation, fillMode, fillValue, outputShape } = attrs;
+    const [batch, imageHeight, imageWidth, numChannels] = image.shape;
+    const [outHeight, outWidth] = outputShape != null ? outputShape : [imageHeight, imageWidth];
+    const outShape = [batch, outHeight, outWidth, numChannels];
+    const inStrides = computeStrides(image.shape);
+    const batchInStride = inStrides[0];
+    const rowInStride = inStrides[1];
+    const colInStride = inStrides[2];
+    const outStrides = computeStrides(outShape);
+    const batchOutStride = outStrides[0];
+    const rowOutStride = outStrides[1];
+    const colOutStride = outStrides[2];
+    const outVals = getTypedArrayFromDType(image.dtype, sizeFromShape(outShape));
+    outVals.fill(fillValue);
+    const imageVals = backend.data.get(image.dataId).values;
+    const transformVals = backend.data.get(transforms.dataId).values;
+    // Ref TF implementation:
+    // https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/image/image_ops.h
+    for (let b = 0; b < batch; ++b) {
+        const transform = transforms.shape[0] === 1 ?
+            transformVals :
+            transformVals.subarray(b * 8, b * 8 + 8);
+        for (let outY = 0; outY < outHeight; ++outY) {
+            for (let outX = 0; outX < outWidth; ++outX) {
+                for (let channel = 0; channel < numChannels; ++channel) {
+                    let val;
+                    const projection = transform[6] * outX + transform[7] * outY + 1;
+                    if (projection === 0) {
+                        // Return the fill value for infinite coordinates,
+                        // which are outside the input image
+                        continue;
+                    }
+                    const inX = (transform[0] * outX + transform[1] * outY + transform[2]) /
+                        projection;
+                    const inY = (transform[3] * outX + transform[4] * outY + transform[5]) /
+                        projection;
+                    const x = mapCoord(inX, imageWidth, fillMode);
+                    const y = mapCoord(inY, imageHeight, fillMode);
+                    switch (interpolation) {
+                        case 'nearest':
+                            val = nearestInterpolation(imageVals, imageHeight, imageWidth, batchInStride, rowInStride, colInStride, b, y, x, channel, fillValue);
+                            break;
+                        case 'bilinear':
+                            val = bilinearInterpolation(imageVals, imageHeight, imageWidth, batchInStride, rowInStride, colInStride, b, y, x, channel, fillValue);
+                            break;
+                        default:
+                            throw new Error(`Error in Transform: Expect 'nearest' or ` +
+                                `'bilinear', but got ${interpolation}`);
+                    }
+                    const ind = b * batchOutStride + outY * rowOutStride +
+                        outX * colOutStride + channel;
+                    outVals[ind] = val;
+                }
+            }
+        }
+        return backend.makeTensorInfo(outShape, image.dtype, outVals);
+    }
+    const dataId = backend.write(outVals, outShape, image.dtype);
+    return { dataId, shape: image.shape, dtype: image.dtype };
+}
+const transformConfig = {
+    kernelName: Transform,
+    backendName: 'cpu',
+    kernelFunc: transform
+};
+function mapCoord(outCoord, len, mode) {
+    switch (mode) {
+        case 'reflect':
+            return mapCoordReflect(outCoord, len);
+        case 'wrap':
+            return mapCoordWrap(outCoord, len);
+        case 'nearest':
+            return mapCoordNearest(outCoord, len);
+        case 'constant':
+        default:
+            return mapCoordConstant(outCoord);
+    }
+}
+function mapCoordReflect(outCoord, len) {
+    // Reflect [abcd] to [dcba|abcd|dcba].
+    let inCoord = outCoord;
+    if (inCoord < 0) {
+        if (len <= 1) {
+            inCoord = 0;
+        }
+        else {
+            const sz2 = 2 * len;
+            if (inCoord < sz2) {
+                inCoord = sz2 * Math.trunc(-inCoord / sz2) + inCoord;
+            }
+            inCoord = inCoord < -len ? inCoord + sz2 : -inCoord - 1;
+        }
+    }
+    else if (inCoord > len - 1) {
+        if (len <= 1) {
+            inCoord = 0;
+        }
+        else {
+            const sz2 = 2 * len;
+            inCoord -= sz2 * Math.trunc(inCoord / sz2);
+            if (inCoord >= len) {
+                inCoord = sz2 - inCoord - 1;
+            }
+        }
+    }
+    // clamp is necessary because when outCoord = 3.5 and len = 4,
+    // inCoord = 3.5 and will be rounded to 4 in nearest interpolation.
+    return clamp(0, inCoord, len - 1);
+}
+function mapCoordWrap(outCoord, len) {
+    // Wrap [abcd] to [abcd|abcd|abcd].
+    let inCoord = outCoord;
+    if (inCoord < 0) {
+        if (len <= 1) {
+            inCoord = 0;
+        }
+        else {
+            const sz = len - 1;
+            inCoord += len * (Math.trunc(-inCoord / sz) + 1);
+        }
+    }
+    else if (inCoord > len - 1) {
+        if (len <= 1) {
+            inCoord = 0;
+        }
+        else {
+            const sz = len - 1;
+            inCoord -= len * Math.trunc(inCoord / sz);
+        }
+    }
+    // clamp is necessary because when outCoord = -0.5 and len = 4,
+    // inCoord = 3.5 and will be rounded to 4 in nearest interpolation.
+    return clamp(0, inCoord, len - 1);
+}
+function mapCoordConstant(outCoord, len) {
+    return outCoord;
+}
+function mapCoordNearest(outCoord, len) {
+    return clamp(0, outCoord, len - 1);
+}
+function readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, y, x, channel, fillValue) {
+    const ind = batch * batchStride + y * rowStride + x * colStride + channel;
+    if (0 <= y && y < imageHeight && 0 <= x && x < imageWidth) {
+        return imageVals[ind];
+    }
+    else {
+        return fillValue;
+    }
+}
+function nearestInterpolation(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, y, x, channel, fillValue) {
+    const $y = Math.round(y);
+    const $x = Math.round(x);
+    return readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, $y, $x, channel, fillValue);
+}
+function bilinearInterpolation(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, y, x, channel, fillValue) {
+    const yFloor = Math.floor(y);
+    const xFloor = Math.floor(x);
+    const yCeil = yFloor + 1;
+    const xCeil = xFloor + 1;
+    // f(x, yFloor) = (xCeil - x) / (xCeil - xFloor) * f(xFloor, yFloor)
+    //               + (x - xFloor) / (xCeil - xFloor) * f(xCeil, yFloor)
+    const valueYFloor = (xCeil - x) *
+        readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, yFloor, xFloor, channel, fillValue) +
+        (x - xFloor) *
+            readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, yFloor, xCeil, channel, fillValue);
+    // f(x, yCeil) = (xCeil - x) / (xCeil - xFloor) * f(xFloor, yCeil)
+    //             + (x - xFloor) / (xCeil - xFloor) * f(xCeil, yCeil)
+    const valueYCeil = (xCeil - x) *
+        readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, yCeil, xFloor, channel, fillValue) +
+        (x - xFloor) *
+            readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, yCeil, xCeil, channel, fillValue);
+    // f(x, y) = (yCeil - y) / (yCeil - yFloor) * f(x, yFloor)
+    //         + (y - yFloor) / (yCeil - yFloor) * f(x, yCeil)
+    return (yCeil - y) * valueYFloor + (y - yFloor) * valueYCeil;
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function unique$1(args) {
+    const { inputs, attrs, backend } = args;
+    const { axis } = attrs;
+    const { x } = inputs;
+    assertNotComplex(x, 'unique');
+    const values = backend.data.get(x.dataId).values;
+    const { outputValues, outputShape, indices } = uniqueImpl(values, axis, x.shape, x.dtype);
+    return [
+        backend.makeTensorInfo(outputShape, x.dtype, outputValues),
+        backend.makeTensorInfo([indices.length], 'int32', indices),
+    ];
+}
+const uniqueConfig = {
+    kernelName: Unique,
+    backendName: 'cpu',
+    kernelFunc: unique$1,
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function unpack(args) {
+    const { inputs, backend, attrs } = args;
+    const { value } = inputs;
+    let { axis } = attrs;
+    if (axis < 0) {
+        axis += value.shape.length;
+    }
+    const valueRank = value.shape.length;
+    const num = value.shape[axis];
+    const outShape = new Array(valueRank - 1);
+    let outIndex = 0;
+    for (let i = 0; i < valueRank; i++) {
+        if (i !== axis) {
+            outShape[outIndex++] = value.shape[i];
+        }
+    }
+    const begin = new Array(valueRank).fill(0);
+    const size = value.shape.slice();
+    size[axis] = 1;
+    const res = new Array(num);
+    for (let i = 0; i < res.length; i++) {
+        begin[axis] = i;
+        const tempRes = slice$1({ inputs: { x: value }, backend, attrs: { begin, size } });
+        res[i] = reshape({ inputs: { x: tempRes }, backend, attrs: { shape: outShape } });
+        backend.disposeIntermediateTensorInfo(tempRes);
+    }
+    return res;
+}
+const unpackConfig = {
+    kernelName: Unpack,
+    backendName: 'cpu',
+    kernelFunc: unpack
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function unsortedSegmentSum(args) {
+    const { inputs, backend, attrs } = args;
+    const { x, segmentIds } = inputs;
+    const { numSegments } = attrs;
+    assertNotComplex(x, 'unsortedSegmentSum');
+    const xRank = x.shape.length;
+    const segmentIdsRank = segmentIds.shape.length;
+    const res = [];
+    const intermediates = [];
+    // Reshape the segment id's so that they can be broadcast with
+    // x. The new shape should be [segmentIds.shape, 1, ..., 1]
+    const numIters = xRank - segmentIdsRank;
+    let $segmentIds = segmentIds;
+    for (let i = 0; i < numIters; ++i) {
+        const expanded = expandDims$1({ inputs: { input: $segmentIds }, backend, attrs: { dim: i + 1 } });
+        $segmentIds = expanded;
+        intermediates.push(expanded);
+    }
+    for (let i = 0; i < numSegments; ++i) {
+        const scalarValue = createScalarValue(i, 'int32');
+        const segmentId = backend.makeTensorInfo([], 'int32', scalarValue);
+        const mask = equal$1({ inputs: { a: segmentId, b: $segmentIds }, backend });
+        const maskCasted = cast$2({ inputs: { x: mask }, backend, attrs: { dtype: 'float32' } });
+        const mul = multiply$1({ inputs: { a: maskCasted, b: x }, backend });
+        const sumTensorInfo = sum({ inputs: { x: mul }, backend, attrs: { axis: 0, keepDims: false } });
+        res.push(sumTensorInfo);
+        intermediates.push(segmentId);
+        intermediates.push(mask);
+        intermediates.push(maskCasted);
+        intermediates.push(mul);
+        intermediates.push(sumTensorInfo);
+    }
+    const result = pack({ inputs: res, backend, attrs: { axis: 0 } });
+    intermediates.forEach(t => backend.disposeIntermediateTensorInfo(t));
+    return result;
+}
+const unsortedSegmentSumConfig = {
+    kernelName: UnsortedSegmentSum,
+    backendName: 'cpu',
+    kernelFunc: unsortedSegmentSum
+};
+
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+// We explicitly import the modular kernels so they get registered in the
+// global registry when we compile the library. A modular build would replace
+// the contents of this file and import only the kernels that are needed.
+// List all kernel configs here
 const kernelConfigs = [
     _fusedMatMulConfig,
-    absConfig,
+    absConfig$1,
     acosConfig,
     acoshConfig,
-    addConfig,
+    addConfig$1,
     addNConfig,
     allConfig,
     anyConfig,
@@ -41395,12 +49885,12 @@ const kernelConfigs = [
     batchNormConfig,
     batchToSpaceNDConfig,
     bincountConfig,
-    bitwiseAndConfig,
+    bitwiseAndConfig$1,
     broadcastArgsConfig,
-    castConfig,
-    ceilConfig,
+    castConfig$1,
+    ceilConfig$1,
     clipByValueConfig,
-    complexConfig,
+    complexConfig$1,
     complexAbsConfig,
     concatConfig,
     conv2DConfig,
@@ -41408,7 +49898,7 @@ const kernelConfigs = [
     conv2DBackpropInputConfig,
     conv3DConfig,
     conv3DBackpropFilterV2Config,
-    conv3DBackpropInputConfig,
+    conv3DBackpropInputV2Config,
     cosConfig,
     coshConfig,
     cropAndResizeConfig,
@@ -41421,37 +49911,39 @@ const kernelConfigs = [
     depthwiseConv2dNativeBackpropInputConfig,
     diagConfig,
     dilation2DConfig,
+    dilation2DBackpropFilterConfig,
+    dilation2DBackpropInputConfig,
+    drawConfig,
     einsumConfig,
     eluConfig,
     eluGradConfig$1,
-    equalConfig,
+    equalConfig$1,
     erfConfig,
-    expConfig,
+    expConfig$1,
     expandDimsConfig,
-    expm1Config,
+    expm1Config$1,
     fftConfig,
     fillConfig,
     flipLeftRightConfig,
-    floorConfig,
-    floorDivConfig,
-    fromPixelsConfig,
+    floorConfig$1,
+    floorDivConfig$1,
     fusedConv2DConfig,
     fusedDepthwiseConv2DConfig,
     gatherNdConfig,
     gatherV2Config,
-    greaterConfig,
-    greaterEqualConfig,
-    identityConfig,
+    greaterConfig$1,
+    greaterEqualConfig$1,
+    identityConfig$1,
     ifftConfig,
     imagConfig,
     isFiniteConfig,
     isInfConfig,
     isNaNConfig,
     leakyReluConfig,
-    lessConfig,
-    lessEqualConfig,
+    lessConfig$1,
+    lessEqualConfig$1,
     linSpaceConfig,
-    logConfig,
+    logConfig$1,
     log1pConfig,
     logicalAndConfig,
     logicalNotConfig,
@@ -41459,7 +49951,7 @@ const kernelConfigs = [
     LRNConfig,
     LRNGradConfig,
     maxConfig,
-    maximumConfig,
+    maximumConfig$1,
     maxPoolConfig,
     maxPool3DConfig,
     maxPool3DGradConfig$1,
@@ -41467,28 +49959,28 @@ const kernelConfigs = [
     maxPoolWithArgmaxConfig,
     meanConfig,
     minConfig,
-    minimumConfig,
+    minimumConfig$1,
     mirrorPadConfig,
     modConfig,
     multinomialConfig,
-    multiplyConfig,
-    negConfig,
+    multiplyConfig$1,
+    negConfig$1,
     nonMaxSuppressionV3Config,
     nonMaxSuppressionV4Config,
     nonMaxSuppressionV5Config,
-    notEqualConfig,
+    notEqualConfig$1,
     oneHotConfig,
     onesLikeConfig,
     packConfig,
     padV2Config,
     powConfig,
     preluConfig,
-    prodConfig,
+    prodConfig$1,
     raggedGatherConfig,
     raggedRangeConfig,
     raggedTensorToTensorConfig,
     rangeConfig,
-    realConfig,
+    realConfig$1,
     realDivConfig,
     reciprocalConfig,
     reluConfig,
@@ -41501,16 +49993,16 @@ const kernelConfigs = [
     reverseConfig,
     rotateWithOffsetConfig,
     roundConfig,
-    rsqrtConfig,
+    rsqrtConfig$1,
     scatterNdConfig,
     searchSortedConfig,
     selectConfig,
     seluConfig,
-    sigmoidConfig,
+    sigmoidConfig$1,
     signConfig,
     sinConfig,
     sinhConfig,
-    sliceConfig,
+    sliceConfig$1,
     softmaxConfig,
     softplusConfig,
     spaceToBatchNDConfig,
@@ -41520,16 +50012,16 @@ const kernelConfigs = [
     sparseSegmentSumConfig,
     sparseToDenseConfig,
     splitVConfig,
-    sqrtConfig,
+    sqrtConfig$1,
     squareConfig,
-    squaredDifferenceConfig,
-    staticRegexReplaceConfig,
+    squaredDifferenceConfig$1,
+    staticRegexReplaceConfig$1,
     stepConfig,
     stridedSliceConfig,
     stringNGramsConfig,
     stringSplitConfig,
     stringToHashBucketFastConfig,
-    subConfig,
+    subConfig$1,
     sumConfig,
     tanConfig,
     tanhConfig,
@@ -41537,7 +50029,7 @@ const kernelConfigs = [
     tileConfig,
     topKConfig,
     transformConfig,
-    transposeConfig,
+    transposeConfig$1,
     uniqueConfig,
     unpackConfig,
     unsortedSegmentSumConfig,
@@ -41568,7 +50060,7 @@ const absGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(dy, step$1(cast$2(x, 'float32'), -1)) };
+        return { x: () => mul(dy, step$2(cast$3(x, 'float32'), -1)) };
     }
 };
 
@@ -41595,9 +50087,9 @@ const acosGradConfig = {
         const [x] = saved;
         return {
             x: () => {
-                const a = square$2(cast$2(x, 'float32'));
-                const b = sqrt$1(sub$1(scalar(1), a));
-                return neg$1(div(dy, b));
+                const a = square$2(cast$3(x, 'float32'));
+                const b = sqrt$2(sub$2(scalar(1), a));
+                return neg$2(div$1(dy, b));
             }
         };
     }
@@ -41626,8 +50118,8 @@ const acoshGradConfig = {
         const [x] = saved;
         return {
             x: () => {
-                const a = sqrt$1(sub$1(square$2(cast$2(x, 'float32')), 1));
-                return div(dy, a);
+                const a = sqrt$2(sub$2(square$2(cast$3(x, 'float32')), 1));
+                return div$1(dy, a);
             }
         };
     }
@@ -41659,17 +50151,17 @@ const addGradConfig = {
             let res = dy;
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, a.shape);
+            return reshape$2(res, a.shape);
         };
         const derB = () => {
             let res = dy;
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, b.shape);
+            return reshape$2(res, b.shape);
         };
         return { a: derA, b: derB };
     }
@@ -41724,7 +50216,7 @@ const argMaxGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => zerosLike$1(x) };
+        return { x: () => zerosLike$2(x) };
     }
 };
 
@@ -41749,7 +50241,7 @@ const argMinGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => zerosLike$1(x) };
+        return { x: () => zerosLike$2(x) };
     }
 };
 
@@ -41774,7 +50266,7 @@ const asinGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, sqrt$1(sub$1(scalar(1), square$2(cast$2(x, 'float32'))))) };
+        return { x: () => div$1(dy, sqrt$2(sub$2(scalar(1), square$2(cast$3(x, 'float32'))))) };
     }
 };
 
@@ -41801,8 +50293,8 @@ const asinhGradConfig = {
         const [x] = saved;
         return {
             x: () => {
-                const a = sqrt$1(add(scalar(1), square$2(cast$2(x, 'float32'))));
-                return div(dy, a);
+                const a = sqrt$2(add$1(scalar(1), square$2(cast$3(x, 'float32'))));
+                return div$1(dy, a);
             }
         };
     }
@@ -41831,22 +50323,22 @@ const atan2GradConfig = {
         const [a, b] = saved;
         const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
         const derA = () => {
-            const d = add(square$2(a), square$2(b));
-            let res = mul(dy, div(b, d));
+            const d = add$1(square$2(a), square$2(b));
+            let res = mul(dy, div$1(b, d));
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, a.shape);
+            return reshape$2(res, a.shape);
         };
         const derB = () => {
-            const d = add(square$2(a), square$2(b));
-            let res = neg$1(mul(dy, div(a, d)));
+            const d = add$1(square$2(a), square$2(b));
+            let res = neg$2(mul(dy, div$1(a, d)));
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, b.shape);
+            return reshape$2(res, b.shape);
         };
         return { a: derA, b: derB };
     }
@@ -41873,7 +50365,7 @@ const atanGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, add(square$2(cast$2(x, 'float32')), 1)) };
+        return { x: () => div$1(dy, add$1(square$2(cast$3(x, 'float32')), 1)) };
     }
 };
 
@@ -41898,7 +50390,7 @@ const atanhGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, sub$1(scalar(1), square$2(cast$2(x, 'float32')))) };
+        return { x: () => div$1(dy, sub$2(scalar(1), square$2(cast$3(x, 'float32')))) };
     }
 };
 
@@ -41946,8 +50438,8 @@ function avgPool3dGrad_(dy, input, filterSize, strides, pad, dimRoundingMode) {
     let reshapedTo5D = false;
     if ($input.rank === 4) {
         reshapedTo5D = true;
-        dy5D = reshape$1($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2], $dy.shape[3]]);
-        input5D = reshape$1($input, [
+        dy5D = reshape$2($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2], $dy.shape[3]]);
+        input5D = reshape$2($input, [
             1, $input.shape[0], $input.shape[1], $input.shape[2], $input.shape[3]
         ]);
     }
@@ -41961,7 +50453,7 @@ function avgPool3dGrad_(dy, input, filterSize, strides, pad, dimRoundingMode) {
     // tslint:disable-next-line: no-unnecessary-type-assertion
     const res = ENGINE.runKernel(AvgPool3DGrad, inputs, attrs);
     if (reshapedTo5D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
     }
     return res;
 }
@@ -42039,8 +50531,8 @@ function avgPoolGrad_(dy, input, filterSize, strides, pad) {
     if ($input.rank === 3) {
         reshapedTo4D = true;
         input4D =
-            reshape$1($input, [1, $input.shape[0], $input.shape[1], $input.shape[2]]);
-        dy4D = reshape$1($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2]]);
+            reshape$2($input, [1, $input.shape[0], $input.shape[1], $input.shape[2]]);
+        dy4D = reshape$2($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2]]);
     }
     assert$1(dy4D.rank === 4, () => `Error in avgPoolGrad: dy must be rank 4 but got rank ` +
         `${dy4D.rank}.`);
@@ -42051,7 +50543,7 @@ function avgPoolGrad_(dy, input, filterSize, strides, pad) {
     // tslint:disable-next-line: no-unnecessary-type-assertion
     const res = ENGINE.runKernel(AvgPoolGrad, inputs, attrs);
     if (reshapedTo4D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3]]);
     }
     return res;
 }
@@ -42152,7 +50644,7 @@ const batchToSpaceNDGradConfig = {
     kernelName: BatchToSpaceND,
     gradFunc: (dy, saved, attrs) => {
         const { blockShape, crops } = attrs;
-        return { x: () => spaceToBatchND$1(dy, blockShape, crops) };
+        return { x: () => spaceToBatchND$2(dy, blockShape, crops) };
     }
 };
 
@@ -42193,7 +50685,7 @@ const broadcastToGradConfig = {
                 axes.push(i);
             }
         }
-        return { x: () => sum$1(dy, axes, true /* keepDims */) };
+        return { x: () => sum$2(dy, axes, true /* keepDims */) };
     }
 };
 
@@ -42240,7 +50732,7 @@ const ceilGradConfig = {
     kernelName: Ceil,
     gradFunc: (dy) => {
         // TODO(manrajgrover): Return null for gradients when backprop supports it.
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -42267,7 +50759,7 @@ const clipByValueGradConfig = {
         const [x] = saved;
         const { clipValueMin, clipValueMax } = attrs;
         return {
-            x: () => where(logicalAnd$1(greaterEqual$1(x, clipValueMin), lessEqual$1(x, clipValueMax)), dy, zerosLike$1(dy)),
+            x: () => where(logicalAnd$2(greaterEqual$2(x, clipValueMin), lessEqual$2(x, clipValueMax)), dy, zerosLike$2(dy)),
         };
     }
 };
@@ -42348,8 +50840,8 @@ const conv2DGradConfig = {
         assert$1(tupleValuesAreOne(dilations), () => 'Error in gradient of conv2D: dilation rates greater than 1 ' +
             `are not yet supported in gradients. Got dilations '${dilations}'`);
         return {
-            x: () => conv2DBackpropInput$1(x4D.shape, dy, $filter, strides, pad, dataFormat),
-            filter: () => conv2DBackpropFilter$1(x4D, dy, $filter.shape, strides, pad, dataFormat)
+            x: () => conv2DBackpropInput$2(x4D.shape, dy, $filter, strides, pad, dataFormat),
+            filter: () => conv2DBackpropFilter$2(x4D, dy, $filter.shape, strides, pad, dataFormat)
         };
     }
 };
@@ -42378,7 +50870,7 @@ const conv2DBackpropInputGradConfig = {
         const { strides, pad, dataFormat, dimRoundingMode } = attrs;
         return {
             dy: () => conv2d$1(ddx, filter, strides, pad, dataFormat, 1 /* dilations */, dimRoundingMode),
-            filter: () => conv2DBackpropFilter$1(ddx, dy, filter.shape, strides, pad, dataFormat, dimRoundingMode)
+            filter: () => conv2DBackpropFilter$2(ddx, dy, filter.shape, strides, pad, dataFormat, dimRoundingMode)
         };
     }
 };
@@ -42418,11 +50910,11 @@ const conv2DBackpropInputGradConfig = {
 function conv3DBackpropFilter_(x, dy, filterShape, strides, pad) {
     let x5D = x;
     if (x.rank === 4) {
-        x5D = reshape$1(x, [1, x.shape[0], x.shape[1], x.shape[2], x.shape[3]]);
+        x5D = reshape$2(x, [1, x.shape[0], x.shape[1], x.shape[2], x.shape[3]]);
     }
     let dy5D = dy;
     if (dy5D.rank === 4) {
-        dy5D = reshape$1(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
+        dy5D = reshape$2(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
     }
     assert$1(x5D.rank === 5, () => `Error in conv3dDerFilter: input must be rank 5, but got shape ` +
         `${x5D.shape}.`);
@@ -42493,7 +50985,7 @@ const cosGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(neg$1(sin$1(cast$2(x, 'float32'))), dy) };
+        return { x: () => mul(neg$2(sin$2(cast$3(x, 'float32'))), dy) };
     }
 };
 
@@ -42518,7 +51010,7 @@ const coshGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(sinh$1(cast$2(x, 'float32')), dy) };
+        return { x: () => mul(sinh$2(cast$3(x, 'float32')), dy) };
     }
 };
 
@@ -42547,9 +51039,9 @@ const cumsumGradConfig = {
         return {
             x: () => {
                 const permutation = getAxesPermutation([axis], x.rank);
-                let out = cumsum$1(dy, axis, exclusive, !reverse);
+                let out = cumsum$2(dy, axis, exclusive, !reverse);
                 if (permutation != null) {
-                    out = transpose$1(out, permutation);
+                    out = transpose$2(out, permutation);
                 }
                 return out;
             }
@@ -42595,8 +51087,8 @@ const depthwiseConv2dNativeGradConfig = {
             `'${$dilations}'.`);
         checkPadOnDimRoundingMode('depthwiseConv2d', pad, dimRoundingMode);
         return {
-            x: () => depthwiseConv2dNativeBackpropInput$1(x.shape, dy, filter, strides, pad, $dilations, dimRoundingMode),
-            filter: () => depthwiseConv2dNativeBackpropFilter$1(x, dy, filter.shape, strides, pad, $dilations, dimRoundingMode),
+            x: () => depthwiseConv2dNativeBackpropInput$2(x.shape, dy, filter, strides, pad, $dilations, dimRoundingMode),
+            filter: () => depthwiseConv2dNativeBackpropFilter$2(x, dy, filter.shape, strides, pad, $dilations, dimRoundingMode),
         };
     }
 };
@@ -42678,7 +51170,7 @@ const erfGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        const a = mul(exp$1(neg$1(square$2(x))), 2 / Math.sqrt(Math.PI));
+        const a = mul(exp$2(neg$2(square$2(x))), 2 / Math.sqrt(Math.PI));
         return { x: () => mul(dy, a) };
     }
 };
@@ -42729,7 +51221,7 @@ const expandDimsGradConfig = {
     inputsToSave: ['input'],
     gradFunc: (dy, saved) => {
         const [input] = saved;
-        return { input: () => reshape$1(dy, input.shape) };
+        return { input: () => reshape$2(dy, input.shape) };
     }
 };
 
@@ -42754,7 +51246,7 @@ const expm1GradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(dy, exp$1(x)) };
+        return { x: () => mul(dy, exp$2(x)) };
     }
 };
 
@@ -42777,7 +51269,7 @@ const expm1GradConfig = {
 const floorGradConfig = {
     kernelName: Floor,
     gradFunc: (dy) => {
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -42804,21 +51296,21 @@ const floorDivGradConfig = {
         const [a, b] = saved;
         const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
         const derA = () => {
-            const res = div(dy, cast$2(b, 'float32'));
+            const res = div$1(dy, cast$3(b, 'float32'));
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                return reshape$1(sum$1(res, reduceAxes), a.shape);
+                return reshape$2(sum$2(res, reduceAxes), a.shape);
             }
             return res;
         };
         const derB = () => {
-            let res = mul(dy, cast$2(a, 'float32'));
+            let res = mul(dy, cast$3(a, 'float32'));
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = reshape$1(sum$1(res, reduceAxes), b.shape);
+                res = reshape$2(sum$2(res, reduceAxes), b.shape);
             }
             const tmp = square$2(b);
-            return neg$1(div(res, cast$2(tmp, 'float32')));
+            return neg$2(div$1(res, cast$3(tmp, 'float32')));
         };
         return { a: derA, b: derB };
     }
@@ -42855,46 +51347,46 @@ const fusedBatchNormGradConfig = {
             }
             tileShape.push(1);
         }
-        const xMinusMean = sub$1(x, mean);
+        const xMinusMean = sub$2(x, mean);
         const dyTimesScaleValue = mul(dy, scaleValue);
-        const oneOverSqrtVariance = rsqrt$1(add(variance, scalar(varianceEpsilon)));
+        const oneOverSqrtVariance = rsqrt$2(add$1(variance, scalar(varianceEpsilon)));
         const minusHalfRCube = mul(mul(mul(oneOverSqrtVariance, oneOverSqrtVariance), oneOverSqrtVariance), scalar(-0.5));
         const derX = () => {
             if (mean.rank === 1) {
-                return reshape$1(mul(mul(dy, tile$2(reshape$1(oneOverSqrtVariance, [1, 1, 1, mean.shape[0]]), tileShape)), scaleValue), x.shape);
+                return reshape$2(mul(mul(dy, tile$3(reshape$2(oneOverSqrtVariance, [1, 1, 1, mean.shape[0]]), tileShape)), scaleValue), x.shape);
             }
             else {
-                return reshape$1(mul(mul(dy, oneOverSqrtVariance), scaleValue), x.shape);
+                return reshape$2(mul(mul(dy, oneOverSqrtVariance), scaleValue), x.shape);
             }
         };
         const derMean = () => {
             let meanDer = mul(mul(oneOverSqrtVariance, scalar(-1)), dyTimesScaleValue);
             if (mean.rank === 1) {
-                meanDer = sum$1(meanDer, reductionAxes);
+                meanDer = sum$2(meanDer, reductionAxes);
             }
-            return reshape$1(meanDer, mean.shape);
+            return reshape$2(meanDer, mean.shape);
         };
         const derVariance = () => {
             let varianceDer = mul(mul(minusHalfRCube, xMinusMean), dyTimesScaleValue);
             if (mean.rank === 1) {
-                varianceDer = sum$1(varianceDer, reductionAxes);
+                varianceDer = sum$2(varianceDer, reductionAxes);
             }
-            return reshape$1(varianceDer, mean.shape);
+            return reshape$2(varianceDer, mean.shape);
         };
         const derScale = () => {
             const xMinusMean2TimesRsqrt = mul(xMinusMean, oneOverSqrtVariance);
             let scaleDer = mul(dy, xMinusMean2TimesRsqrt);
             if (mean.rank === 1) {
-                scaleDer = sum$1(scaleDer, reductionAxes);
+                scaleDer = sum$2(scaleDer, reductionAxes);
             }
-            return reshape$1(scaleDer, mean.shape);
+            return reshape$2(scaleDer, mean.shape);
         };
         const derOffset = () => {
             let offsetDer = dy;
             if (mean.rank === 1) {
-                offsetDer = sum$1(offsetDer, reductionAxes);
+                offsetDer = sum$2(offsetDer, reductionAxes);
             }
-            return reshape$1(offsetDer, mean.shape);
+            return reshape$2(offsetDer, mean.shape);
         };
         return {
             x: derX,
@@ -42941,13 +51433,13 @@ const gatherGradConfig = {
                 const innerAxesIndices = arrayRange(outerDims + 1, outerDims + 1 + innerDims);
                 const valuesShape = arrayConcat([outerShape, [indicesSize],
                     innerShape]);
-                const values = reshape$1(dy, valuesShape);
-                const reshapedIndices = reshape$1(indices, [indicesSize]);
+                const values = reshape$2(dy, valuesShape);
+                const reshapedIndices = reshape$2(indices, [indicesSize]);
                 const transposeDims = arrayConcat([[outerDims], outerAxesIndices, innerAxesIndices]);
-                const valuesTranspose = transpose$1(values, transposeDims);
-                let paramsGrad = unsortedSegmentSum$1(valuesTranspose, reshapedIndices, x.shape[parsedAxis]);
+                const valuesTranspose = transpose$2(values, transposeDims);
+                let paramsGrad = unsortedSegmentSum$2(valuesTranspose, reshapedIndices, x.shape[parsedAxis]);
                 const invertTransposeDims = getUndoAxesPermutation(transposeDims);
-                paramsGrad = transpose$1(paramsGrad, invertTransposeDims);
+                paramsGrad = transpose$2(paramsGrad, invertTransposeDims);
                 return paramsGrad;
             };
         };
@@ -43005,7 +51497,7 @@ const greaterEqualGradConfig = {
     inputsToSave: ['a', 'b'],
     gradFunc: (dy, saved) => {
         const [a, b] = saved;
-        return { a: () => zerosLike$1(a), b: () => zerosLike$1(b) };
+        return { a: () => zerosLike$2(a), b: () => zerosLike$2(b) };
     }
 };
 
@@ -43028,7 +51520,7 @@ const greaterEqualGradConfig = {
 const identityGradConfig = {
     kernelName: Identity$1,
     gradFunc: (dy) => {
-        return { x: () => cast$2(dy, 'float32') };
+        return { x: () => cast$3(dy, 'float32') };
     }
 };
 
@@ -43053,7 +51545,7 @@ const isFiniteGradConfig = {
     gradFunc: (dy) => {
         // TODO(nsthorat): Let gradients be null for cases where we want to stop
         // backpropgation.
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -43078,7 +51570,7 @@ const isInfGradConfig = {
     gradFunc: (dy) => {
         // TODO(nsthorat): Let gradients be null for cases where we want to stop
         // backpropgation.
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -43103,7 +51595,7 @@ const isNanGradConfig = {
     gradFunc: (dy) => {
         // TODO(nsthorat): Let gradients be null for cases where we want to stop
         // backpropgation.
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -43129,7 +51621,7 @@ const leakyReluGradConfig = {
     gradFunc: (dy, saved, attrs) => {
         const [x] = saved;
         const { alpha } = attrs;
-        const mask = greater$1(x, 0);
+        const mask = greater$2(x, 0);
         // Returns `gradients * (features > 0) + alpha * gradients * (features <=
         // 0)`.
         return { x: () => where(mask, dy, mul(dy, alpha)) };
@@ -43157,7 +51649,7 @@ const log1pGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, add(x, 1)) };
+        return { x: () => div$1(dy, add$1(x, 1)) };
     }
 };
 
@@ -43182,7 +51674,7 @@ const logGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, cast$2(x, 'float32')) };
+        return { x: () => div$1(dy, cast$3(x, 'float32')) };
     }
 };
 
@@ -43212,8 +51704,8 @@ const logSoftmaxGradConfig = {
         return {
             logits: () => {
                 const keepDims = true;
-                const softmax = exp$1(value);
-                return sub$1(dy, mul(sum$1(dy, axis, keepDims), softmax));
+                const softmax = exp$2(value);
+                return sub$2(dy, mul(sum$2(dy, axis, keepDims), softmax));
             }
         };
     }
@@ -43292,14 +51784,14 @@ const lrnGradConfig = {
  */
 function gradForMinAndMax(dy, y, xOrig, origAxes) {
     if (y.rank < xOrig.rank) {
-        y = reshape$1(y, expandShapeToKeepDim(y.shape, origAxes));
+        y = reshape$2(y, expandShapeToKeepDim(y.shape, origAxes));
     }
     if (dy.rank < xOrig.rank) {
-        dy = reshape$1(dy, expandShapeToKeepDim(dy.shape, origAxes));
+        dy = reshape$2(dy, expandShapeToKeepDim(dy.shape, origAxes));
     }
     return {
         x: () => {
-            const dx = mul(dy, cast$2(equal$1(xOrig, y), dy.dtype));
+            const dx = mul(dy, cast$3(equal$2(xOrig, y), dy.dtype));
             return dx;
         }
     };
@@ -43361,8 +51853,8 @@ const maximumGradConfig = {
     inputsToSave: ['a', 'b'],
     gradFunc: (dy, saved) => {
         const [a, b] = saved;
-        const derA = () => mul(dy, cast$2(greaterEqual$1(a, b), 'float32'));
-        const derB = () => mul(dy, cast$2(less$1(a, b), 'float32'));
+        const derA = () => mul(dy, cast$3(greaterEqual$2(a, b), 'float32'));
+        const derB = () => mul(dy, cast$3(less$2(a, b), 'float32'));
         return { a: derA, b: derB };
     }
 };
@@ -43415,11 +51907,11 @@ function maxPool3dGrad_(dy, input, output, filterSize, strides, pad, dimRounding
     let reshapedTo5D = false;
     if ($input.rank === 4) {
         reshapedTo5D = true;
-        dy5D = reshape$1($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2], $dy.shape[3]]);
-        input5D = reshape$1($input, [
+        dy5D = reshape$2($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2], $dy.shape[3]]);
+        input5D = reshape$2($input, [
             1, $input.shape[0], $input.shape[1], $input.shape[2], $input.shape[3]
         ]);
-        output5D = reshape$1($output, [
+        output5D = reshape$2($output, [
             1, $output.shape[0], $output.shape[1], $output.shape[2], $output.shape[3]
         ]);
     }
@@ -43435,7 +51927,7 @@ function maxPool3dGrad_(dy, input, output, filterSize, strides, pad, dimRounding
     // tslint:disable-next-line: no-unnecessary-type-assertion
     const res = ENGINE.runKernel(MaxPool3DGrad, inputs, attrs);
     if (reshapedTo5D) {
-        return reshape$1(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
+        return reshape$2(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
     }
     return res;
 }
@@ -43585,8 +52077,8 @@ const meanGradConfig = {
             axes.forEach(axis => {
                 expandedDyShape[axis] = 1;
             });
-            const expandedDy = reshape$1(dy, expandedDyShape);
-            const res = div(mul(expandedDy, ones(x.shape, 'float32')), reduceSize);
+            const expandedDy = reshape$2(dy, expandedDyShape);
+            const res = div$1(mul(expandedDy, ones(x.shape, 'float32')), reduceSize);
             return res;
         };
         return { x: derX };
@@ -43648,8 +52140,8 @@ const minimumGradConfig = {
     inputsToSave: ['a', 'b'],
     gradFunc: (dy, saved) => {
         const [a, b] = saved;
-        const derA = () => mul(dy, cast$2(lessEqual$1(a, b), 'float32'));
-        const derB = () => mul(dy, cast$2(greater$1(a, b), 'float32'));
+        const derA = () => mul(dy, cast$3(lessEqual$2(a, b), 'float32'));
+        const derB = () => mul(dy, cast$3(greater$2(a, b), 'float32'));
         return { a: derA, b: derB };
     }
 };
@@ -43679,7 +52171,7 @@ const mirrorPadGradConfig = {
         const x = saved[0];
         const { paddings } = attrs;
         const begin = paddings.map(p => p[0]);
-        return { x: () => slice$1(dy, begin, x.shape) };
+        return { x: () => slice$2(dy, begin, x.shape) };
     }
 };
 
@@ -43708,15 +52200,15 @@ const modGradConfig = {
         const derA = () => {
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                return reshape$1(sum$1(dy, reduceAxes), a.shape);
+                return reshape$2(sum$2(dy, reduceAxes), a.shape);
             }
             return dy;
         };
         const derB = () => {
-            const res = mul(dy, neg$1(floor$1(div(a, b))));
+            const res = mul(dy, neg$2(floor$2(div$1(a, b))));
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                return reshape$1(sum$1(res, reduceAxes), b.shape);
+                return reshape$2(sum$2(res, reduceAxes), b.shape);
             }
             return res;
         };
@@ -43747,18 +52239,18 @@ const multiplyGradConfig = {
         const [a, b] = saved;
         const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
         const derA = () => {
-            const res = mul(dy, cast$2(b, 'float32'));
+            const res = mul(dy, cast$3(b, 'float32'));
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                return reshape$1(sum$1(res, reduceAxes), a.shape);
+                return reshape$2(sum$2(res, reduceAxes), a.shape);
             }
             return res;
         };
         const derB = () => {
-            const res = mul(dy, cast$2(a, 'float32'));
+            const res = mul(dy, cast$3(a, 'float32'));
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                return reshape$1(sum$1(res, reduceAxes), b.shape);
+                return reshape$2(sum$2(res, reduceAxes), b.shape);
             }
             return res;
         };
@@ -43785,7 +52277,7 @@ const multiplyGradConfig = {
 const negGradConfig = {
     kernelName: Neg,
     gradFunc: (dy) => {
-        return { x: () => neg$1(dy) };
+        return { x: () => neg$2(dy) };
     }
 };
 
@@ -43810,7 +52302,7 @@ const oneHotGradConfig = {
     inputsToSave: ['indices'],
     gradFunc: (dy, saved) => {
         const indices = saved[0];
-        return { indices: () => zeros(indices.shape, 'float32') };
+        return { indices: () => zeros$1(indices.shape, 'float32') };
     }
 };
 
@@ -43833,7 +52325,7 @@ const oneHotGradConfig = {
 const onesLikeGradConfig = {
     kernelName: OnesLike,
     gradFunc: (dy) => {
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -43888,7 +52380,7 @@ const padV2GradConfig = {
         const x = saved[0];
         const { paddings } = attrs;
         const begin = paddings.map(p => p[0]);
-        return { x: () => slice$1(dy, begin, x.shape) };
+        return { x: () => slice$2(dy, begin, x.shape) };
     }
 };
 
@@ -43918,23 +52410,23 @@ const powGradConfig = {
         const exp = b;
         const outShape = assertAndGetBroadcastShape(base.shape, exp.shape);
         const derBase = () => {
-            const expFloat = cast$2(exp, 'float32');
-            let res = mul(dy, mul(expFloat, pow$1(base, sub$1(expFloat, scalar(1)))));
+            const expFloat = cast$3(exp, 'float32');
+            let res = mul(dy, mul(expFloat, pow$2(base, sub$2(expFloat, scalar(1)))));
             const reduceAxes = getReductionAxes(base.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, base.shape);
+            return reshape$2(res, base.shape);
         };
         const derExp = () => {
-            const condition = greater$1(base, 0);
-            const logBase = where(condition, log$1(base), zerosLike$1(base));
+            const condition = greater$2(base, 0);
+            const logBase = where(condition, log$2(base), zerosLike$2(base));
             let res = mul(dy, mul(y, logBase));
             const reduceAxes = getReductionAxes(exp.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, exp.shape);
+            return reshape$2(res, exp.shape);
         };
         return { a: derBase, b: derExp };
     }
@@ -43961,16 +52453,16 @@ const preluGradConfig = {
     inputsToSave: ['x', 'alpha'],
     gradFunc: (dy, saved) => {
         const [x, alpha] = saved;
-        const mask = greater$1(x, 0);
+        const mask = greater$2(x, 0);
         return {
             x: () => where(mask, dy, mul(dy, alpha)),
             alpha: () => {
-                let res = where(mask, zerosLike$1(dy), mul(dy, x));
+                let res = where(mask, zerosLike$2(dy), mul(dy, x));
                 const reduceAxes = getReductionAxes(alpha.shape, dy.shape);
                 if (reduceAxes.length > 0) {
-                    res = sum$1(res, reduceAxes);
+                    res = sum$2(res, reduceAxes);
                 }
-                return reshape$1(res, alpha.shape);
+                return reshape$2(res, alpha.shape);
             }
         };
     }
@@ -44000,9 +52492,9 @@ function prodGradFn_(x, dy, axis) {
     const expandedYShape = x.shape.slice();
     expandedYShape[axis] = 1;
     // The actual gradient computation.
-    const expandedDy = reshape$1(dy, expandedYShape);
-    const xCumProd = cumprod$1(x, axis, true, false);
-    const xCumRevProd = cumprod$1(x, axis, true, true);
+    const expandedDy = reshape$2(dy, expandedYShape);
+    const xCumProd = cumprod$2(x, axis, true, false);
+    const xCumRevProd = cumprod$2(x, axis, true, true);
     const dx = mul(xCumProd, xCumRevProd);
     return mul(expandedDy, dx);
 }
@@ -44016,7 +52508,7 @@ function prodsGradFn_(x, dy, axis) {
     const xPermutation = getAxesPermutation(axis, xRank);
     let permutedX = x;
     if (xPermutation != null) {
-        permutedX = transpose$1(x, xPermutation);
+        permutedX = transpose$2(x, xPermutation);
     }
     // Reshape all the prod dimensions into a single one, and do compute prod
     // gradients on that.
@@ -44031,7 +52523,7 @@ function prodsGradFn_(x, dy, axis) {
     prodGrad = prodGrad.reshape(permutedX.shape);
     if (xPermutation != null) {
         const undoPermutation = getUndoAxesPermutation(xPermutation);
-        prodGrad = transpose$1(prodGrad, undoPermutation);
+        prodGrad = transpose$2(prodGrad, undoPermutation);
     }
     return prodGrad;
 }
@@ -44092,21 +52584,21 @@ const divGradConfig = {
         const [a, b] = saved;
         const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
         const derA = () => {
-            const res = div(dy, cast$2(b, 'float32'));
+            const res = div$1(dy, cast$3(b, 'float32'));
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                return reshape$1(sum$1(res, reduceAxes), a.shape);
+                return reshape$2(sum$2(res, reduceAxes), a.shape);
             }
             return res;
         };
         const derB = () => {
-            let res = mul(dy, cast$2(a, 'float32'));
+            let res = mul(dy, cast$3(a, 'float32'));
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = reshape$1(sum$1(res, reduceAxes), b.shape);
+                res = reshape$2(sum$2(res, reduceAxes), b.shape);
             }
             const tmp = square$2(b);
-            return neg$1(div(res, cast$2(tmp, 'float32')));
+            return neg$2(div$1(res, cast$3(tmp, 'float32')));
         };
         return { a: derA, b: derB };
     }
@@ -44133,7 +52625,7 @@ const reciprocalGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, neg$1(square$2(x))) };
+        return { x: () => div$1(dy, neg$2(square$2(x))) };
     }
 };
 
@@ -44158,8 +52650,8 @@ const relu6GradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        const mask = mul(lessEqual$1(x, 6), step$1(x));
-        return { x: () => mul(dy, cast$2(mask, 'float32')) };
+        const mask = mul(lessEqual$2(x, 6), step$2(x));
+        return { x: () => mul(dy, cast$3(mask, 'float32')) };
     }
 };
 
@@ -44184,7 +52676,7 @@ const reluGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(dy, cast$2(step$1(x), 'float32')) };
+        return { x: () => mul(dy, cast$3(step$2(x), 'float32')) };
     }
 };
 
@@ -44209,7 +52701,7 @@ const reshapeGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => reshape$1(dy, x.shape) };
+        return { x: () => reshape$2(dy, x.shape) };
     }
 };
 
@@ -44292,7 +52784,7 @@ const reverseGradConfig = {
     gradFunc: (dy, saved, attrs) => {
         const { dims } = attrs;
         const axes = parseAxisParam(dims, dy.shape);
-        return { x: () => reverse$1(dy, axes) };
+        return { x: () => reverse$2(dy, axes) };
     }
 };
 
@@ -44317,7 +52809,7 @@ const roundGradConfig = {
     gradFunc: (dy) => {
         // TODO(nsthorat): Let gradients be null for cases where we want to stop
         // backpropgation.
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -44342,7 +52834,7 @@ const rsqrtGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => neg$1(div(dy, mul(pow$1(x, 1.5), 2))) };
+        return { x: () => neg$2(div$1(dy, mul(pow$2(x, 1.5), 2))) };
     }
 };
 
@@ -44370,9 +52862,9 @@ const selectGradConfig = {
         return {
             // TODO(julianoks): Return null for condition gradient
             // when backprop supports it.
-            condition: () => cast$2(zerosLike$1(condition), 'float32'),
-            t: () => mul(dy, cast$2(condition, dy.dtype)),
-            e: () => mul(dy, cast$2(logicalNot$1(condition), dy.dtype))
+            condition: () => cast$3(zerosLike$2(condition), 'float32'),
+            t: () => mul(dy, cast$3(condition, dy.dtype)),
+            e: () => mul(dy, cast$3(logicalNot$2(condition), dy.dtype))
         };
     }
 };
@@ -44400,11 +52892,11 @@ const seluGradConfig = {
         const [x] = saved;
         return {
             x: () => {
-                const mask = greater$1(x, scalar(0));
+                const mask = greater$2(x, scalar(0));
                 const scaleAlpha = scalar(SELU_SCALEALPHA);
                 const scale = scalar(SELU_SCALE);
                 const greaterThanZeroDer = mul(dy, scale);
-                const lessEqualZeroDer = mul(mul(dy, scaleAlpha), exp$1(cast$2(x, 'float32')));
+                const lessEqualZeroDer = mul(mul(dy, scaleAlpha), exp$2(cast$3(x, 'float32')));
                 return where(mask, greaterThanZeroDer, lessEqualZeroDer);
             }
         };
@@ -44432,7 +52924,7 @@ const sigmoidGradConfig = {
     outputsToSave: [true],
     gradFunc: (dy, saved) => {
         const [y] = saved;
-        return { x: () => mul(dy, mul(y, sub$1(scalar(1), y))) };
+        return { x: () => mul(dy, mul(y, sub$2(scalar(1), y))) };
     }
 };
 
@@ -44455,7 +52947,7 @@ const sigmoidGradConfig = {
 const signGradConfig = {
     kernelName: Sign,
     gradFunc: (dy) => {
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -44480,7 +52972,7 @@ const sinGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(cos$1(cast$2(x, 'float32')), dy) };
+        return { x: () => mul(cos$2(cast$3(x, 'float32')), dy) };
     }
 };
 
@@ -44505,7 +52997,7 @@ const sinhGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(cosh$1(cast$2(x, 'float32')), dy) };
+        return { x: () => mul(cosh$2(cast$3(x, 'float32')), dy) };
     }
 };
 
@@ -44571,7 +53063,7 @@ const softmaxGradConfig = {
         const keepDims = true;
         const dyTimesY = mul(dy, y);
         return {
-            logits: () => sub$1(dyTimesY, mul(sum$1(dyTimesY, [dim], keepDims), y))
+            logits: () => sub$2(dyTimesY, mul(sum$2(dyTimesY, [dim], keepDims), y))
         };
     }
 };
@@ -44597,7 +53089,7 @@ const softplusGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(dy, sigmoid$1(x)) };
+        return { x: () => mul(dy, sigmoid$2(x)) };
     }
 };
 
@@ -44621,7 +53113,7 @@ const spaceToBatchNDGradConfig = {
     kernelName: SpaceToBatchND,
     gradFunc: (dy, saved, attrs) => {
         const { blockShape, paddings } = attrs;
-        return { x: () => batchToSpaceND$1(dy, blockShape, paddings) };
+        return { x: () => batchToSpaceND$2(dy, blockShape, paddings) };
     }
 };
 
@@ -44645,7 +53137,7 @@ const splitVGradConfig = {
     kernelName: SplitV,
     gradFunc: (dy, saved, attrs) => {
         const { axis } = attrs;
-        return { x: () => concat$1(dy, axis) };
+        return { x: () => concat$2(dy, axis) };
     }
 };
 
@@ -44670,7 +53162,7 @@ const sqrtGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, mul(sqrt$1(cast$2(x, 'float32')), 2)) };
+        return { x: () => div$1(dy, mul(sqrt$2(cast$3(x, 'float32')), 2)) };
     }
 };
 
@@ -44695,7 +53187,7 @@ const squareGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => mul(dy, mul(cast$2(x, 'float32'), 2)) };
+        return { x: () => mul(dy, mul(cast$3(x, 'float32'), 2)) };
     }
 };
 
@@ -44721,8 +53213,8 @@ const squaredDifferenceGradConfig = {
     gradFunc: (dy, saved) => {
         const [a, b] = saved;
         const two = scalar(2);
-        const derA = () => mul(dy, mul(two, sub$1(a, b)));
-        const derB = () => mul(dy, mul(two, sub$1(b, a)));
+        const derA = () => mul(dy, mul(two, sub$2(a, b)));
+        const derB = () => mul(dy, mul(two, sub$2(b, a)));
         return { a: derA, b: derB };
     }
 };
@@ -44748,7 +53240,7 @@ const stepGradConfig = {
     gradFunc: (dy) => {
         // TODO(manrajgrover): Return null for gradients when backprop supports
         // it.
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -44778,17 +53270,17 @@ const subGradConfig = {
             let res = dy;
             const reduceAxes = getReductionAxes(a.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(res, a.shape);
+            return reshape$2(res, a.shape);
         };
         const derB = () => {
             let res = dy;
             const reduceAxes = getReductionAxes(b.shape, outShape);
             if (reduceAxes.length > 0) {
-                res = sum$1(res, reduceAxes);
+                res = sum$2(res, reduceAxes);
             }
-            return reshape$1(neg$1(res), b.shape);
+            return reshape$2(neg$2(res), b.shape);
         };
         return { a: derA, b: derB };
     }
@@ -44821,7 +53313,7 @@ const sumGradConfig = {
         axes.forEach(axis => {
             expandedDyShape[axis] = 1;
         });
-        const expandedDy = reshape$1(dy, expandedDyShape);
+        const expandedDy = reshape$2(dy, expandedDyShape);
         const derX = mul(expandedDy, ones(x.shape, 'float32'));
         return { x: () => derX };
     }
@@ -44848,7 +53340,7 @@ const tanGradConfig = {
     inputsToSave: ['x'],
     gradFunc: (dy, saved) => {
         const [x] = saved;
-        return { x: () => div(dy, square$2(cos$1(x))) };
+        return { x: () => div$1(dy, square$2(cos$2(x))) };
     }
 };
 
@@ -44873,7 +53365,7 @@ const tanhGradConfig = {
     outputsToSave: [true],
     gradFunc: (dy, saved) => {
         const [y] = saved;
-        return { x: () => mul(sub$1(scalar(1), square$2(y)), dy) };
+        return { x: () => mul(sub$2(scalar(1), square$2(y)), dy) };
     }
 };
 
@@ -44900,18 +53392,18 @@ const tileGradConfig = {
         const [x] = saved;
         const { reps } = attrs;
         const derX = () => {
-            let xGrad = zerosLike$1(x);
+            let xGrad = zerosLike$2(x);
             // TODO(cais): Maybe reduce memory footprint by avoiding repeated
             // slicing.
             if (x.rank === 1) {
                 for (let i = 0; i < reps[0]; ++i) {
-                    xGrad = add(xGrad, slice$1(dy, [i * x.shape[0]], [x.shape[0]]));
+                    xGrad = add$1(xGrad, slice$2(dy, [i * x.shape[0]], [x.shape[0]]));
                 }
             }
             else if (x.rank === 2) {
                 for (let i = 0; i < reps[0]; ++i) {
                     for (let j = 0; j < reps[1]; ++j) {
-                        xGrad = add(xGrad, slice$1(dy, [i * x.shape[0], j * x.shape[1]], [
+                        xGrad = add$1(xGrad, slice$2(dy, [i * x.shape[0], j * x.shape[1]], [
                             x.shape[0], x.shape[1]
                         ]));
                     }
@@ -44922,7 +53414,7 @@ const tileGradConfig = {
                     for (let j = 0; j < reps[1]; ++j) {
                         for (let k = 0; k < reps[2]; ++k) {
                             xGrad =
-                                add(xGrad, slice$1(dy, [i * x.shape[0], j * x.shape[1], k * x.shape[2]], [x.shape[0], x.shape[1], x.shape[2]]));
+                                add$1(xGrad, slice$2(dy, [i * x.shape[0], j * x.shape[1], k * x.shape[2]], [x.shape[0], x.shape[1], x.shape[2]]));
                         }
                     }
                 }
@@ -44933,7 +53425,7 @@ const tileGradConfig = {
                         for (let k = 0; k < reps[2]; ++k) {
                             for (let l = 0; l < reps[3]; ++l) {
                                 xGrad =
-                                    add(xGrad, slice$1(dy, [
+                                    add$1(xGrad, slice$2(dy, [
                                         i * x.shape[0], j * x.shape[1], k * x.shape[2],
                                         l * x.shape[3]
                                     ], [x.shape[0], x.shape[1], x.shape[2], x.shape[3]]));
@@ -44974,7 +53466,7 @@ const transposeGradConfig = {
         const transposeAttrs = attrs;
         const { perm } = transposeAttrs;
         const undoPerm = getUndoAxesPermutation(perm);
-        return { x: () => transpose$1(dy, undoPerm) };
+        return { x: () => transpose$2(dy, undoPerm) };
     }
 };
 
@@ -45034,15 +53526,15 @@ function gatherDropNegatives(x, indices) {
     // Helper function for unsorted segment ops. Gathers params for
     // positive segment ids and gathers 0 for inputs with negative segment id.
     // Mirrors _GatherDropNegatives from tensorflow/python/ops/math_grad.py
-    const zeroClippedIndices = maximum$1(indices, zerosLike$1(indices));
+    const zeroClippedIndices = maximum$2(indices, zerosLike$2(indices));
     const gathered = gather$1(x, zeroClippedIndices);
-    let isPositive = greaterEqual$1(indices, scalar(0, 'int32'));
+    let isPositive = greaterEqual$2(indices, scalar(0, 'int32'));
     const numIters = gathered.rank - isPositive.rank;
     for (let i = 0; i < numIters; ++i) {
-        isPositive = expandDims$2(isPositive, i + 1);
+        isPositive = expandDims$3(isPositive, i + 1);
     }
-    isPositive = logicalAnd$1(isPositive, ones(gathered.shape, 'bool'));
-    const zeroSlice = zerosLike$1(gathered);
+    isPositive = logicalAnd$2(isPositive, ones(gathered.shape, 'bool'));
+    const zeroSlice = zerosLike$2(gathered);
     return where(isPositive, gathered, zeroSlice);
 }
 
@@ -45065,7 +53557,7 @@ function gatherDropNegatives(x, indices) {
 const zerosLikeGradConfig = {
     kernelName: ZerosLike,
     gradFunc: (dy) => {
-        return { x: () => zerosLike$1(dy) };
+        return { x: () => zerosLike$2(dy) };
     }
 };
 
@@ -45990,7 +54482,7 @@ function imageDataFormat() {
  * @returns Tensor of the specified `dtype`.
  */
 function cast(x, dtype) {
-    return cast$2(x, dtype);
+    return cast$3(x, dtype);
 }
 /**
  * Adds a 1-sized dimension at index "axis".
@@ -46004,7 +54496,7 @@ function expandDims(x, axis = -1) {
         axis = outShape.length + axis + 1;
     }
     outShape.splice(axis, 0, 1);
-    return reshape$1(x, outShape);
+    return reshape$2(x, outShape);
 }
 /**
  * Repeats a 2D tensor.
@@ -46034,7 +54526,7 @@ function repeat(x, n) {
  */
 function flatten(x) {
     const newShape = [arrayProd(x.shape)];
-    return reshape$1(x, newShape);
+    return reshape$2(x, newShape);
 }
 /**
  * Turn a nD tensor into a 2D tensor with same 0th dimension.
@@ -46049,7 +54541,7 @@ function batchFlatten(x) {
         throw new ValueError(`batchFlatten requires a minimum rank of 2. Got rank: ${x.rank}.`);
     }
     const newShape = [x.shape[0], arrayProd(x.shape, 1)];
-    return reshape$1(x, newShape);
+    return reshape$2(x, newShape);
 }
 /**
  * Do slicing along the first axis.
@@ -46071,11 +54563,11 @@ function sliceAlongFirstAxis(array, start, size) {
             case 4:
                 return slice4d(array, [start, 0, 0, 0], [size, array.shape[1], array.shape[2], array.shape[3]]);
             case 5:
-                return slice$1(array, [start, 0, 0, 0, 0], [
+                return slice$2(array, [start, 0, 0, 0, 0], [
                     size, array.shape[1], array.shape[2], array.shape[3], array.shape[4]
                 ]);
             case 6:
-                return slice$1(array, [start, 0, 0, 0, 0, 0], [
+                return slice$2(array, [start, 0, 0, 0, 0, 0], [
                     size, array.shape[1], array.shape[2], array.shape[3], array.shape[4],
                     array.shape[5]
                 ]);
@@ -46100,7 +54592,7 @@ function tile(x, n) {
         throw new ValueError(`The length of input n (${n.length}) does not match ` +
             `the number of dimensions in input x (${x.rank})`);
     }
-    return tile$2(x, n);
+    return tile$3(x, n);
 }
 /* Creation of random tensors. */
 /**
@@ -46167,7 +54659,7 @@ function dot(a, b, activation, bias) {
         // Reshape x into the analogous 2D Tensor.
         const aFirstDims = a.shape.slice(); // Holds all but the last dim of x.
         const aLastDim = aFirstDims.pop();
-        a = reshape$1(a, [-1, aLastDim]);
+        a = reshape$2(a, [-1, aLastDim]);
         // Reshape y into the analogous 2D Tensor, and keep track of the
         // required dimensions to reproduce the output shape.
         const bShape = b.shape.slice();
@@ -46185,12 +54677,12 @@ function dot(a, b, activation, bias) {
             }
             return i;
         });
-        b = reshape$1(transpose$1(b, perm), [ySecondLastDim, -1]);
+        b = reshape$2(transpose$2(b, perm), [ySecondLastDim, -1]);
         // Multiply x and y as 2D Tensors, and then reshape back to original.
         const outputShape = [...aFirstDims, ...yOtherDims];
         const transposeA = false;
         const transposeB = false;
-        return reshape$1(matMul({
+        return reshape$2(matMul({
             a,
             b,
             transposeA,
@@ -46214,7 +54706,7 @@ function gather(reference, indices, axis) {
             indices = tensor1d(indices, 'int32');
         }
         else {
-            indices = cast$2(indices, 'int32');
+            indices = cast$3(indices, 'int32');
         }
         return gather$1(reference, indices, axis);
     });
@@ -46239,54 +54731,54 @@ function reshapeBias(xRank, bias, dataFormat) {
     if (xRank === 5) {
         if (dataFormat === 'channelsFirst') {
             if (biasShape.length === 1) {
-                return reshape$1(bias, [1, biasShape[0], 1, 1, 1]);
+                return reshape$2(bias, [1, biasShape[0], 1, 1, 1]);
             }
             else {
-                return reshape$1(bias, [1, biasShape[3], biasShape[0], biasShape[1], biasShape[2]]);
+                return reshape$2(bias, [1, biasShape[3], biasShape[0], biasShape[1], biasShape[2]]);
             }
         }
         else if (dataFormat === 'channelsLast') {
             if (biasShape.length === 1) {
-                return reshape$1(bias, [1, 1, 1, 1, biasShape[0]]);
+                return reshape$2(bias, [1, 1, 1, 1, biasShape[0]]);
             }
             else {
-                return reshape$1(bias, [1].concat(biasShape));
+                return reshape$2(bias, [1].concat(biasShape));
             }
         }
     }
     else if (xRank === 4) {
         if (dataFormat === 'channelsFirst') {
             if (biasShape.length === 1) {
-                return reshape$1(bias, [1, biasShape[0], 1, 1]);
+                return reshape$2(bias, [1, biasShape[0], 1, 1]);
             }
             else {
-                return reshape$1(bias, [1, biasShape[2], biasShape[0], biasShape[1]]);
+                return reshape$2(bias, [1, biasShape[2], biasShape[0], biasShape[1]]);
             }
         }
         else if (dataFormat === 'channelsLast') {
             if (biasShape.length === 1) {
-                return reshape$1(bias, [1, 1, 1, biasShape[0]]);
+                return reshape$2(bias, [1, 1, 1, biasShape[0]]);
             }
             else {
-                return reshape$1(bias, [1].concat(biasShape));
+                return reshape$2(bias, [1].concat(biasShape));
             }
         }
     }
     else if (xRank === 3) {
         if (dataFormat === 'channelsFirst') {
             if (biasShape.length === 1) {
-                return reshape$1(bias, [1, biasShape[0], 1]);
+                return reshape$2(bias, [1, biasShape[0], 1]);
             }
             else {
-                return reshape$1(bias, [1, biasShape[1], biasShape[0]]);
+                return reshape$2(bias, [1, biasShape[1], biasShape[0]]);
             }
         }
         else if (dataFormat === 'channelsLast') {
             if (biasShape.length === 1) {
-                return reshape$1(bias, [1, 1, biasShape[0]]);
+                return reshape$2(bias, [1, 1, biasShape[0]]);
             }
             else {
-                return reshape$1(bias, [1].concat(biasShape));
+                return reshape$2(bias, [1].concat(biasShape));
             }
         }
     }
@@ -46310,7 +54802,7 @@ function biasAdd(x, bias, dataFormat) {
             dataFormat = imageDataFormat();
         }
         checkDataFormat(dataFormat);
-        return add(x, reshapeBias(x.rank, bias, dataFormat));
+        return add$1(x, reshapeBias(x.rank, bias, dataFormat));
     });
 }
 /**
@@ -46325,7 +54817,7 @@ function elu(x, alpha = 1) {
         throw new NotImplementedError(`Support for alpha values other than 1 (${alpha}) is not implemented ` +
             `yet.`);
     }
-    return elu$2(x);
+    return elu$3(x);
 }
 /**
  * Softsign of a tensor.
@@ -46336,7 +54828,7 @@ function elu(x, alpha = 1) {
  * @returns Output.
  */
 function softsign(x) {
-    return tidy(() => div(x, add(abs$1(x), 1)));
+    return tidy(() => div$1(x, add$1(abs$2(x), 1)));
 }
 /**
  * Sets entries in `x` to zero at random, while scaling the entire tensor.
@@ -46362,8 +54854,8 @@ function dropout$1(x, level, noiseShape, seed) {
  */
 function hardSigmoid(x) {
     return tidy(() => {
-        const y = add(.5, mul(.2, x));
-        return clipByValue$1(y, 0, 1);
+        const y = add$1(.5, mul(.2, x));
+        return clipByValue$2(y, 0, 1);
     });
 }
 /**
@@ -46426,7 +54918,7 @@ class Initializer extends Serializable {
 }
 class Zeros extends Initializer {
     apply(shape, dtype) {
-        return zeros(shape, dtype);
+        return zeros$1(shape, dtype);
     }
 }
 /** @nocollapse */
@@ -48518,7 +57010,7 @@ function assertFeedCompatibility(key, val) {
     }
     try {
         //  b. Attempt to convert to expected type.
-        return cast$2(val, key.dtype);
+        return cast$3(val, key.dtype);
     }
     catch (err) {
         //  c. If conversion fails, return helpful error.
@@ -48932,7 +57424,7 @@ function getNodeOutputs(fetch) {
  * Helper function used by many of the Constraints to find the L2Norms.
  */
 function calcL2Norms(w, axis) {
-    return tidy(() => sqrt$1(sum$1(mul(w, w), axis, true)));
+    return tidy(() => sqrt$2(sum$2(mul(w, w), axis, true)));
 }
 /**
  * Base class for functions that impose constraints on weight values
@@ -48960,8 +57452,8 @@ class MaxNorm extends Constraint {
     apply(w) {
         return tidy(() => {
             const norms = calcL2Norms(w, this.axis);
-            const desired = clipByValue$1(norms, 0, this.maxValue);
-            return mul(w, div(desired, add(epsilon(), norms)));
+            const desired = clipByValue$2(norms, 0, this.maxValue);
+            return mul(w, div$1(desired, add$1(epsilon(), norms)));
         });
     }
     getConfig() {
@@ -48978,7 +57470,7 @@ class UnitNorm extends Constraint {
         this.axis = args.axis != null ? args.axis : this.defaultAxis;
     }
     apply(w) {
-        return tidy(() => div(w, add(epsilon(), calcL2Norms(w, this.axis))));
+        return tidy(() => div$1(w, add$1(epsilon(), calcL2Norms(w, this.axis))));
     }
     getConfig() {
         return { axis: this.axis };
@@ -48989,7 +57481,7 @@ UnitNorm.className = 'UnitNorm';
 registerClass(UnitNorm);
 class NonNeg extends Constraint {
     apply(w) {
-        return relu$1(w);
+        return relu$2(w);
     }
 }
 /** @nocollapse */
@@ -49012,8 +57504,8 @@ class MinMaxNorm extends Constraint {
     apply(w) {
         return tidy(() => {
             const norms = calcL2Norms(w, this.axis);
-            const desired = add(mul(this.rate, clipByValue$1(norms, this.minValue, this.maxValue)), mul(1.0 - this.rate, norms));
-            return mul(w, div(desired, add(epsilon(), norms)));
+            const desired = add$1(mul(this.rate, clipByValue$2(norms, this.minValue, this.maxValue)), mul(1.0 - this.rate, norms));
+            return mul(w, div$1(desired, add$1(epsilon(), norms)));
         });
     }
     getConfig() {
@@ -49355,7 +57847,7 @@ class BaseLogger extends BaseCallback {
                 else {
                     this.totals[key] = 0;
                 }
-                const total = tidy(() => add((this.totals[key]), mul(value, batchSize)));
+                const total = tidy(() => add$1((this.totals[key]), mul(value, batchSize)));
                 this.totals[key] = total;
                 if (oldTotalsToDispose != null) {
                     oldTotalsToDispose.dispose();
@@ -49374,7 +57866,7 @@ class BaseLogger extends BaseCallback {
                 }
                 else {
                     tidy(() => {
-                        const log = mul(div(1, this.seen), this.totals[key]);
+                        const log = mul(div$1(1, this.seen), this.totals[key]);
                         logs[key] = log;
                         this.totals[key].dispose();
                         keep(logs[key]);
@@ -49674,54 +58166,54 @@ function deserialize(config, customObjects = {}, fastWeightInit = false) {
 function l2Normalize(x, axis) {
     return tidy(() => {
         if (x.dtype !== 'float32') {
-            x = cast$2(x, 'float32');
+            x = cast$3(x, 'float32');
         }
-        const squareSum = sum$1(square(x), axis, true);
-        const epsilonTensor = fill$1(squareSum.shape, epsilon());
-        const norm = sqrt$1(maximum$1(squareSum, epsilonTensor));
-        return div(x, norm);
+        const squareSum = sum$2(square(x), axis, true);
+        const epsilonTensor = fill$2(squareSum.shape, epsilon());
+        const norm = sqrt$2(maximum$2(squareSum, epsilonTensor));
+        return div$1(x, norm);
     });
 }
 function meanSquaredError(yTrue, yPred) {
-    return tidy(() => mean(square(sub$1(yPred, yTrue)), -1));
+    return tidy(() => mean$1(square(sub$2(yPred, yTrue)), -1));
 }
 function meanAbsoluteError(yTrue, yPred) {
-    return tidy(() => mean(abs$1(sub$1(yPred, yTrue)), -1));
+    return tidy(() => mean$1(abs$2(sub$2(yPred, yTrue)), -1));
 }
 function meanAbsolutePercentageError(yTrue, yPred) {
     return tidy(() => {
-        const diff = sub$1(yTrue, yPred);
-        const clippedTrue = clipByValue$1(abs$1(yTrue), epsilon(), Number.MAX_VALUE);
-        const absResult = abs$1(div(diff, clippedTrue));
-        return mul(100, mean(absResult, -1));
+        const diff = sub$2(yTrue, yPred);
+        const clippedTrue = clipByValue$2(abs$2(yTrue), epsilon(), Number.MAX_VALUE);
+        const absResult = abs$2(div$1(diff, clippedTrue));
+        return mul(100, mean$1(absResult, -1));
     });
 }
 function meanSquaredLogarithmicError(yTrue, yPred) {
     return tidy(() => {
-        const clippedPred = clipByValue$1(yPred, epsilon(), Number.MAX_VALUE);
-        const firstLog = log$1(add(1, clippedPred));
-        const clippedTrue = clipByValue$1(yTrue, epsilon(), Number.MAX_VALUE);
-        const secondLog = log$1(add(1, clippedTrue));
-        return mean(square(sub$1(firstLog, secondLog)), -1);
+        const clippedPred = clipByValue$2(yPred, epsilon(), Number.MAX_VALUE);
+        const firstLog = log$2(add$1(1, clippedPred));
+        const clippedTrue = clipByValue$2(yTrue, epsilon(), Number.MAX_VALUE);
+        const secondLog = log$2(add$1(1, clippedTrue));
+        return mean$1(square(sub$2(firstLog, secondLog)), -1);
     });
 }
 function squaredHinge(yTrue, yPred) {
     return tidy(() => {
-        const maxResult = maximum$1(0, sub$1(1, mul(yTrue, yPred)));
-        return mean(square(maxResult), -1);
+        const maxResult = maximum$2(0, sub$2(1, mul(yTrue, yPred)));
+        return mean$1(square(maxResult), -1);
     });
 }
 function hinge(yTrue, yPred) {
     return tidy(() => {
-        const maxResult = maximum$1(0, sub$1(1, mul(yTrue, yPred)));
-        return mean(maxResult, -1);
+        const maxResult = maximum$2(0, sub$2(1, mul(yTrue, yPred)));
+        return mean$1(maxResult, -1);
     });
 }
 function categoricalHinge(yTrue, yPred) {
     return tidy(() => {
-        const pos = sum$1(mul(yTrue, yPred), -1);
-        const neg = max$1(mul(sub$1(1, yTrue), yPred), -1);
-        return maximum$1(0, add(1, sub$1(neg, pos)));
+        const pos = sum$2(mul(yTrue, yPred), -1);
+        const neg = max$2(mul(sub$2(1, yTrue), yPred), -1);
+        return maximum$2(0, add$1(1, sub$2(neg, pos)));
     });
 }
 /**
@@ -49735,23 +58227,23 @@ function categoricalHinge(yTrue, yPred) {
 function logcosh(yTrue, yPred) {
     return tidy(() => {
         const log2 = Math.log(2);
-        const predictionDiff = sub$1(yPred, yTrue);
-        const logcoshResult = sub$1(add(predictionDiff, softplus$1(mul(-2, predictionDiff))), log2);
-        return mean(logcoshResult, -1);
+        const predictionDiff = sub$2(yPred, yTrue);
+        const logcoshResult = sub$2(add$1(predictionDiff, softplus$2(mul(-2, predictionDiff))), log2);
+        return mean$1(logcoshResult, -1);
     });
 }
 function categoricalCrossentropy$1(target, output, fromLogits = false) {
     return tidy(() => {
         if (fromLogits) {
-            output = softmax$1(output);
+            output = softmax$2(output);
         }
         else {
             // scale preds so that the class probabilities of each sample sum to 1.
-            const outputSum = sum$1(output, output.shape.length - 1, true);
-            output = div(output, outputSum);
+            const outputSum = sum$2(output, output.shape.length - 1, true);
+            output = div$1(output, outputSum);
         }
-        output = clipByValue$1(output, epsilon(), 1 - epsilon());
-        return neg$1(sum$1(mul(cast$2(target, 'float32'), log$1(output)), output.shape.length - 1));
+        output = clipByValue$2(output, epsilon(), 1 - epsilon());
+        return neg$2(sum$2(mul(cast$3(target, 'float32'), log$2(output)), output.shape.length - 1));
     });
 }
 /**
@@ -49765,10 +58257,10 @@ function categoricalCrossentropy$1(target, output, fromLogits = false) {
  */
 function sparseCategoricalCrossentropy$1(target, output, fromLogits = false) {
     return tidy(() => {
-        const flatTarget = cast$2(floor$1(flatten(target)), 'int32');
-        output = clipByValue$1(output, epsilon(), 1 - epsilon());
+        const flatTarget = cast$3(floor$2(flatten(target)), 'int32');
+        output = clipByValue$2(output, epsilon(), 1 - epsilon());
         const outputShape = output.shape;
-        const oneHotTarget = reshape$1(oneHot$1(flatTarget, outputShape[outputShape.length - 1]), outputShape);
+        const oneHotTarget = reshape$2(oneHot$2(flatTarget, outputShape[outputShape.length - 1]), outputShape);
         return categoricalCrossentropy$1(oneHotTarget, output, fromLogits);
     });
 }
@@ -49805,30 +58297,30 @@ function sigmoidCrossEntropyWithLogits(labels, logits) {
         //   -x * z + log(1 + exp(x))
         // Note that these two expressions can be combined into the following:
         //   max(x, 0) - x * z + log(1 + exp(-abs(x)))
-        const reluLogits = relu$1(logits);
-        const negAbsLogits = neg$1(abs$1(logits));
-        return add(sub$1(reluLogits, mul(logits, labels)), log1p$1(exp$1(negAbsLogits)));
+        const reluLogits = relu$2(logits);
+        const negAbsLogits = neg$2(abs$2(logits));
+        return add$1(sub$2(reluLogits, mul(logits, labels)), log1p$2(exp$2(negAbsLogits)));
     });
 }
 function binaryCrossentropy$1(yTrue, yPred) {
     return tidy(() => {
         let y;
-        y = clipByValue$1(yPred, epsilon(), 1 - epsilon());
-        y = log$1(div(y, sub$1(1, y)));
-        return mean(sigmoidCrossEntropyWithLogits(yTrue, y), -1);
+        y = clipByValue$2(yPred, epsilon(), 1 - epsilon());
+        y = log$2(div$1(y, sub$2(1, y)));
+        return mean$1(sigmoidCrossEntropyWithLogits(yTrue, y), -1);
     });
 }
 function kullbackLeiblerDivergence(yTrue, yPred) {
     return tidy(() => {
-        const clippedTrue = clipByValue$1(yTrue, epsilon(), 1);
-        const clippedPred = clipByValue$1(yPred, epsilon(), 1);
-        return sum$1(mul(yTrue, log$1(div(clippedTrue, clippedPred))), -1);
+        const clippedTrue = clipByValue$2(yTrue, epsilon(), 1);
+        const clippedPred = clipByValue$2(yPred, epsilon(), 1);
+        return sum$2(mul(yTrue, log$2(div$1(clippedTrue, clippedPred))), -1);
     });
 }
 function poisson(yTrue, yPred) {
     return tidy(() => {
-        const logPred = log$1(add(epsilon(), yPred));
-        return mean(sub$1(yPred, mul(yTrue, logPred)), -1);
+        const logPred = log$2(add$1(epsilon(), yPred));
+        return mean$1(sub$2(yPred, mul(yTrue, logPred)), -1);
     });
 }
 function cosineProximity(yTrue, yPred) {
@@ -49836,7 +58328,7 @@ function cosineProximity(yTrue, yPred) {
         const trueNormalized = l2Normalize(yTrue, -1);
         const predNormalized = l2Normalize(yPred, -1);
         const trueXPred = mul(trueNormalized, predNormalized);
-        return neg$1(sum$1(trueXPred, -1));
+        return neg$2(sum$2(trueXPred, -1));
     });
 }
 // TODO(michaelterry): Add deserialize() function.
@@ -49890,30 +58382,30 @@ function get$1(identifierOrFn) {
  */
 function binaryAccuracy(yTrue, yPred) {
     return tidy(() => {
-        const threshold = mul(.5, onesLike$1(yPred));
-        const yPredThresholded = cast(greater$1(yPred, threshold), yTrue.dtype);
-        return mean(equal$1(yTrue, yPredThresholded), -1);
+        const threshold = mul(.5, onesLike$2(yPred));
+        const yPredThresholded = cast(greater$2(yPred, threshold), yTrue.dtype);
+        return mean$1(equal$2(yTrue, yPredThresholded), -1);
     });
 }
 function categoricalAccuracy(yTrue, yPred) {
-    return tidy(() => cast(equal$1(argMax$1(yTrue, -1), argMax$1(yPred, -1)), 'float32'));
+    return tidy(() => cast(equal$2(argMax$2(yTrue, -1), argMax$2(yPred, -1)), 'float32'));
 }
 function truePositives(yTrue, yPred) {
     return tidy(() => {
-        return cast$2(sum$1(logicalAnd$1(equal$1(yTrue, 1), equal$1(yPred, 1))), 'float32');
+        return cast$3(sum$2(logicalAnd$2(equal$2(yTrue, 1), equal$2(yPred, 1))), 'float32');
     });
 }
 function falsePositives(yTrue, yPred) {
     return tidy(() => {
-        return cast$2(sum$1(logicalAnd$1(equal$1(yTrue, 0), equal$1(yPred, 1))), 'float32');
+        return cast$3(sum$2(logicalAnd$2(equal$2(yTrue, 0), equal$2(yPred, 1))), 'float32');
     });
 }
 function precision(yTrue, yPred) {
     return tidy(() => {
         const tp = truePositives(yTrue, yPred);
         const fp = falsePositives(yTrue, yPred);
-        const denominator = add(tp, fp);
-        return cast$2(where(greater$1(denominator, 0), div(tp, denominator), 0), 'float32');
+        const denominator = add$1(tp, fp);
+        return cast$3(where(greater$2(denominator, 0), div$1(tp, denominator), 0), 'float32');
     });
 }
 function binaryCrossentropy(yTrue, yPred) {
@@ -49923,11 +58415,11 @@ function sparseCategoricalAccuracy(yTrue, yPred) {
     if (yTrue.rank === yPred.rank) {
         yTrue = squeeze(yTrue, [yTrue.rank - 1]);
     }
-    yPred = argMax$1(yPred, -1);
+    yPred = argMax$2(yPred, -1);
     if (yPred.dtype !== yTrue.dtype) {
-        yPred = cast$2(yPred, yTrue.dtype);
+        yPred = cast$3(yPred, yTrue.dtype);
     }
-    return cast$2(equal$1(yTrue, yPred), 'float32');
+    return cast$3(equal$2(yTrue, yPred), 'float32');
 }
 // Aliases.
 const mse = meanSquaredError;
@@ -51748,11 +60240,11 @@ async function standardizeWeights(y, sampleWeight, classWeight, sampleWeightMode
                 if (y.shape[1] > 1) {
                     // Assume one-hot encoding of classes.
                     const axis = 1;
-                    return argMax$1(y, axis);
+                    return argMax$2(y, axis);
                 }
                 else if (y.shape[1] === 1) {
                     // Class index.
-                    return reshape$1(y, [y.shape[0]]);
+                    return reshape$2(y, [y.shape[0]]);
                 }
                 else {
                     throw new Error(`Encountered unexpected last-dimension size (${y.shape[1]}) ` +
@@ -52108,7 +60600,7 @@ model, dataset, args) {
                     const batchOut = batchOuts[i];
                     const oldScalar = outs[i];
                     outs[i] =
-                        tidy(() => add(outs[i], mul(batchSize, batchOut)));
+                        tidy(() => add$1(outs[i], mul(batchSize, batchOut)));
                     if (batch > 0) {
                         dispose(oldScalar);
                     }
@@ -52133,7 +60625,7 @@ model, dataset, args) {
     }
     for (let i = 0; i < outs.length; ++i) {
         const oldScalar = outs[i];
-        outs[i] = div(outs[i], numExamples);
+        outs[i] = div$1(outs[i], numExamples);
         dispose(oldScalar);
     }
     return singletonOrArray(outs);
@@ -52202,7 +60694,7 @@ function sliceArraysByIndices(arrays, indices) {
         else {
             // TODO(cais): indices should be a pre-constructed Tensor1D to avoid
             //   tensor1d() calls.
-            return gather(arrays, indices.dtype === 'int32' ? indices : cast$2(indices, 'int32'));
+            return gather(arrays, indices.dtype === 'int32' ? indices : cast$3(indices, 'int32'));
         }
     });
 }
@@ -53155,7 +61647,7 @@ class LayersModel extends Container {
                 });
                 batchOuts.forEach((batchOut, i) => outsBatches[i].push(batchOut));
             }
-            return singletonOrArray(outsBatches.map(batches => concat$1(batches, 0)));
+            return singletonOrArray(outsBatches.map(batches => concat$2(batches, 0)));
         });
     }
     /**
@@ -53314,11 +61806,11 @@ class LayersModel extends Container {
                     for (let i = 0; i < batchOuts.length; ++i) {
                         const batchOut = batchOuts[i];
                         outs[i] =
-                            add(outs[i], mul(batchEnd - batchStart, batchOut));
+                            add$1(outs[i], mul(batchEnd - batchStart, batchOut));
                     }
                 }
                 for (let i = 0; i < outs.length; ++i) {
-                    outs[i] = div(outs[i], numSamples);
+                    outs[i] = div$1(outs[i], numSamples);
                 }
             }
             return outs;
@@ -53377,14 +61869,14 @@ class LayersModel extends Container {
                         loss = computeWeightedLoss(loss, sampleWeights[i]);
                     }
                     // TODO(cais): push Scalar instead.
-                    const meanLoss = mean(loss);
+                    const meanLoss = mean$1(loss);
                     // TODO(cais): Use a scope() instead, to avoid ownership.
                     lossValues.push(meanLoss);
                     if (i === 0) {
                         totalLoss = loss;
                     }
                     else {
-                        totalLoss = add(totalLoss, loss);
+                        totalLoss = add$1(totalLoss, loss);
                     }
                 }
                 // Compute the metrics.
@@ -53399,16 +61891,16 @@ class LayersModel extends Container {
                         const metric = this.metricsTensors[i][0];
                         const outputIndex = this.metricsTensors[i][1];
                         weightedMetric =
-                            mean(metric(targets[outputIndex], outputs[outputIndex]));
+                            mean$1(metric(targets[outputIndex], outputs[outputIndex]));
                     }
                     keep(weightedMetric);
                     // TODO(cais): Use a scope() instead, to avoid ownership.
                     metricsValues.push(weightedMetric);
                 }
-                totalLoss = mean(totalLoss);
+                totalLoss = mean$1(totalLoss);
                 // Add regularizer penalties.
                 this.calculateLosses().forEach(regularizerLoss => {
-                    totalLoss = add(totalLoss, regularizerLoss);
+                    totalLoss = add$1(totalLoss, regularizerLoss);
                 });
                 return totalLoss;
             };
@@ -53441,12 +61933,12 @@ class LayersModel extends Container {
                     const lossFunction = this.lossFunctions[i];
                     // TODO(cais): Add sample weighting and replace the simple
                     // averaging.
-                    const loss = mean(lossFunction(targets[i], outputs[i]));
+                    const loss = mean$1(lossFunction(targets[i], outputs[i]));
                     if (i === 0) {
                         totalLoss = loss;
                     }
                     else {
-                        totalLoss = add(totalLoss, loss);
+                        totalLoss = add$1(totalLoss, loss);
                     }
                     valOutputs.push(totalLoss);
                 }
@@ -53455,7 +61947,7 @@ class LayersModel extends Container {
                     const metric = this.metricsTensors[i][0];
                     const outputIndex = this.metricsTensors[i][1];
                     // TODO(cais): Replace K.mean() with a proper weighting function.
-                    const meanMetric = mean(metric(targets[outputIndex], outputs[outputIndex]));
+                    const meanMetric = mean$1(metric(targets[outputIndex], outputs[outputIndex]));
                     valOutputs.push(meanMetric);
                 }
                 return valOutputs;
@@ -55041,7 +63533,7 @@ registerClass(Elu);
  */
 class Selu extends Activation$1 {
     apply(x) {
-        return selu$1(x);
+        return selu$2(x);
     }
 }
 /** @nocollapse */
@@ -55052,7 +63544,7 @@ registerClass(Selu);
  */
 class Relu extends Activation$1 {
     apply(x) {
-        return relu$1(x);
+        return relu$2(x);
     }
 }
 /** @nocollapse */
@@ -55063,7 +63555,7 @@ registerClass(Relu);
  */
 class Relu6 extends Activation$1 {
     apply(x) {
-        return tidy(() => minimum$1(6.0, relu$1(x)));
+        return tidy(() => minimum$2(6.0, relu$2(x)));
     }
 }
 /** @nocollapse */
@@ -55083,7 +63575,7 @@ registerClass(Linear);
  */
 class Sigmoid extends Activation$1 {
     apply(x) {
-        return sigmoid$1(x);
+        return sigmoid$2(x);
     }
 }
 /** @nocollapse */
@@ -55105,7 +63597,7 @@ registerClass(HardSigmoid);
  */
 class Softplus extends Activation$1 {
     apply(x) {
-        return softplus$1(x);
+        return softplus$2(x);
     }
 }
 /** @nocollapse */
@@ -55127,7 +63619,7 @@ registerClass(Softsign);
  */
 class Tanh extends Activation$1 {
     apply(x) {
-        return tanh$1(x);
+        return tanh$2(x);
     }
 }
 /** @nocollapse */
@@ -55150,7 +63642,7 @@ class Softmax extends Activation$1 {
      * @throws ValueError: In case `dim(x) < 2`.
      */
     apply(x, axis = (-1)) {
-        return softmax$1(x, axis);
+        return softmax$2(x, axis);
     }
 }
 /** @nocollapse */
@@ -55195,7 +63687,7 @@ class Gelu extends Activation$1 {
             return tidy(() => {
                 const sqrtTwo = Math.sqrt(2);
                 // Compute Φ(x) using the erf function
-                const cdf = mul(0.5, add(1, erf$1(div(x, sqrtTwo))));
+                const cdf = mul(0.5, add$1(1, erf$2(div$1(x, sqrtTwo))));
                 // Compute GELU(x) = x * Φ(x)
                 return mul(x, cdf);
             });
@@ -55217,7 +63709,7 @@ class GeluNew extends Activation$1 {
      */
     apply(x) {
         return tidy(() => {
-            return mul(0.5, mul(x, add(1, tanh$1(mul(sqrt$1(div(2, Math.PI)), add(x, mul(0.044715, pow$1(x, 3))))))));
+            return mul(0.5, mul(x, add$1(1, tanh$2(mul(sqrt$2(div$1(2, Math.PI)), add$1(x, mul(0.044715, pow$2(x, 3))))))));
         });
     }
 }
@@ -55235,7 +63727,7 @@ class Mish extends Activation$1 {
      * @returns a Tensor of the same shape as x
      */
     apply(x) {
-        return tidy(() => mul(x, tanh$1(softplus$1(x))));
+        return tidy(() => mul(x, tanh$2(softplus$2(x))));
     }
 }
 /** @nocollapse */
@@ -55253,7 +63745,7 @@ class Swish extends Activation$1 {
      * @returns a Tensor of the same shape as x
      */
     apply(x, alpha = 1) {
-        return tidy(() => mul(sigmoid$1(mul(x, alpha)), x));
+        return tidy(() => mul(sigmoid$2(mul(x, alpha)), x));
     }
 }
 /** @nocollapse */
@@ -55322,15 +63814,15 @@ class L1L2 extends Regularizer {
      */
     apply(x) {
         return tidy(() => {
-            let regularization = zeros([1]);
+            let regularization = zeros$1([1]);
             if (this.hasL1) {
-                regularization = add(regularization, sum$1(mul(this.l1, abs$1(x))));
+                regularization = add$1(regularization, sum$2(mul(this.l1, abs$2(x))));
             }
             if (this.hasL2) {
                 regularization =
-                    add(regularization, sum$1(mul(this.l2, square(x))));
+                    add$1(regularization, sum$2(mul(this.l2, square(x))));
             }
-            return reshape$1(regularization, []);
+            return reshape$2(regularization, []);
         });
     }
     getConfig() {
@@ -55575,7 +64067,7 @@ class Flatten extends Layer {
                     permutation.push(i);
                 }
                 permutation.push(1);
-                input = transpose$1(input, permutation);
+                input = transpose$2(input, permutation);
             }
             return batchFlatten(input);
         });
@@ -55723,7 +64215,7 @@ class Reshape extends Layer {
             const input = getExactlyOneTensor(inputs);
             const inputShape = input.shape;
             const outputShape = inputShape.slice(0, 1).concat(this.fixUnknownDimension(inputShape.slice(1), this.targetShape));
-            return reshape$1(input, outputShape);
+            return reshape$2(input, outputShape);
         });
     }
     getConfig() {
@@ -55768,7 +64260,7 @@ class Permute extends Layer {
         return outputShape;
     }
     call(inputs, kwargs) {
-        return transpose$1(getExactlyOneTensor(inputs), this.dimsIncludingBatch);
+        return transpose$2(getExactlyOneTensor(inputs), this.dimsIncludingBatch);
     }
     getConfig() {
         const config = {
@@ -55805,7 +64297,7 @@ class Masking extends Layer {
     computeMask(inputs, mask) {
         const input = getExactlyOneTensor(inputs);
         const axis = -1;
-        return any$1(notEqual$1(input, this.maskValue), axis);
+        return any$2(notEqual$2(input, this.maskValue), axis);
     }
     call(inputs, kwargs) {
         return tidy(() => {
@@ -55813,8 +64305,8 @@ class Masking extends Layer {
             const input = getExactlyOneTensor(inputs);
             const axis = -1;
             const keepDims = true;
-            const booleanMask = any$1(notEqual$1(input, this.maskValue), axis, keepDims);
-            const output = mul(input, cast$2(booleanMask, input.dtype));
+            const booleanMask = any$2(notEqual$2(input, this.maskValue), axis, keepDims);
+            const output = mul(input, cast$3(booleanMask, input.dtype));
             return output;
         });
     }
@@ -55882,4 +64374,4 @@ function dropout(args) {
     return new Dropout(args);
 }
 
-export { LayersModel, PlatformStub, dense, dropout, enableProdMode, env, fromMemory, glorotUniform, loadLayersModelFromIOHandler, sequential, stringToHashBucketFast$1 as stringToHashBucketFast, tensor1d, tensor2d, withSaveHandler };
+export { LayersModel, PlatformStub, dense, dropout, enableProdMode, env, fromMemory, glorotUniform, loadLayersModelFromIOHandler, sequential, stringToHashBucketFast$2 as stringToHashBucketFast, tensor1d, tensor2d, withSaveHandler };
diff --git a/src/mail-app/workerUtils/spamClassification/tensorflow-custom.js b/src/mail-app/workerUtils/spamClassification/tensorflow-custom.js
index 62823b9d30..7204c0d285 100644
--- a/src/mail-app/workerUtils/spamClassification/tensorflow-custom.js
+++ b/src/mail-app/workerUtils/spamClassification/tensorflow-custom.js
@@ -1,5 +1,6 @@
-// Use side-effect import to initialize WebGL backend
+// Use side effect import to initialize WebGL backend
 import "@tensorflow/tfjs-backend-webgl"
+import "@tensorflow/tfjs-backend-cpu"
 
 import "@tensorflow/tfjs-core/dist/register_all_gradients"